/// <summary> /// Builds Indy request for doing tokens payment /// according to this payment method. /// /// This method consumes set of UTXO inputs and outputs. /// /// Format of inputs is specific for payment method. Usually it should reference payment transaction /// with at least one output that corresponds to payment address that user owns. /// /// Note this endpoint is EXPERIMENTAL. Function signature and behaviour may change /// in the future releases. /// </summary> /// <returns>Indy request for doing tokens payment</returns> /// <param name="wallet">Wallet.</param> /// <param name="submitterDid">Submitter did.</param> /// <param name="inputsJson">The list of UTXO inputs as json array: /// ["input1", ...] /// Note that each input should reference paymentAddress</param> /// <param name="outputsJson">The list of UTXO outputs as json array: /// [{ /// paymentAddress: <str>, // payment address used as output /// amount: <int>, // amount of tokens to transfer to this payment address /// extra: <str>, // optional data /// }]</param> /// <param name="extra">Optional information for payment operation</param> public static Task <PaymentResult> BuildPaymentRequestAsync(Wallet wallet, string submitterDid, string inputsJson, string outputsJson, string extra) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(inputsJson, "inputsJson"); ParamGuard.NotNullOrWhiteSpace(outputsJson, "outputsJson"); var taskCompletionSource = new TaskCompletionSource <PaymentResult>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_build_payment_req( commandHandle, wallet.Handle, submitterDid, inputsJson, outputsJson, extra, BuildPaymentRequestCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Signs the provided claim for using the key provided in the specified claim request. /// </summary> /// <remarks> /// <para> /// The <paramref name="claimReqJson"/> parameter must be passed a claim request that was previously /// created using the <see cref="ProverCreateAndStoreClaimReqAsync(Wallet, string, string, string, string)"/> /// method. Usually the claim request will be received from another party that has performed this /// action. /// </para> /// <para> /// The claim to be signed is provided in the <paramref name="claimJson"/> parameter /// and the structure of the claim must conform to the schema from claim request provided in /// the <paramref name="claimReqJson"/> parameter. Claims must be structured as a series of /// attributes, each of which has two values; a human readable value and a hex encoded value. /// <code> /// { /// "attr1" : ["value1", "value1_as_int"], /// "attr2" : ["value2", "value2_as_int"] /// } /// </code> /// For example: /// <code> /// { /// 'name': ['Alex', '1139481716457488690172217916278103335'], /// 'height': ['175', '175'] /// } /// </code> /// </para> /// <para> /// This method results a revocation registry update JSON and a newly issued claim JSON. The /// claim JSON contains the issued claim, the DID of the issuer (<c>issuer_did</c>), /// schema sequence number (<c>schema_seq_no</c>) and revocation registry sequence number (<c> /// revoc_reg_seq_no</c>) used for issuance: /// <code> /// { /// "claim": <see claim_json above>, /// "signature": <signature>, /// "revoc_reg_seq_no", string, /// "issuer_did", string, /// "schema_seq_no", string, /// } /// </code> /// </para> /// </remarks> /// <param name="wallet">The wallet containing the keys to use for signing the claim.</param> /// <param name="claimReqJson">A claim request with a blinded secret.</param> /// <param name="claimJson">A claim containing attribute values for each of requested attribute names.</param> /// <param name="userRevocIndex">The index of a new user in the revocation registry or -1 if absentee.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that, when the operation completes, resolves to /// an <see cref="IssuerCreateClaimResult"/>.</returns> public static Task <IssuerCreateClaimResult> IssuerCreateClaimAsync(Wallet wallet, string claimReqJson, string claimJson, int userRevocIndex) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(claimReqJson, "claimReqJson"); ParamGuard.NotNullOrWhiteSpace(claimJson, "claimJson"); var taskCompletionSource = new TaskCompletionSource <IssuerCreateClaimResult>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_issuer_create_claim( commandHandle, wallet.Handle, claimReqJson, claimJson, userRevocIndex, _issuerCreateClaimCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Builds Indy request for setting fees for transactions in the ledger /// /// Note this endpoint is EXPERIMENTAL. Function signature and behaviour may change /// in the future releases. /// </summary> /// <returns>Indy request for setting fees for transactions in the ledger</returns> /// <param name="wallet">Wallet.</param> /// <param name="submitterDid">Submitter did.</param> /// <param name="paymentMethod">Payment method.</param> /// <param name="feesJson">Fees json. /// { /// txnType1: amount1, /// txnType2: amount2, /// ................. /// txnTypeN: amountN, /// }</param> public static Task <string> BuildSetTxnFeesRequestAsync(Wallet wallet, string submitterDid, string paymentMethod, string feesJson) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(submitterDid, "submitterDid"); ParamGuard.NotNullOrWhiteSpace(paymentMethod, "paymentMethod"); ParamGuard.NotNullOrWhiteSpace(feesJson, "feesJson"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_build_set_txn_fees_req( commandHandle, wallet.Handle, submitterDid, paymentMethod, feesJson, _buildSetTxnFeesReqCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Decrypts a message encrypted using an anonymous-encryption scheme /// </summary> /// <remarks> /// <para> /// Sealed boxes are designed to a <c>sender</c> to anonymously send messages to a <c>recipient</c> using the /// recipient's public key. /// Only the recipient can decrypt these messages, using their private key. /// While the recipient can verify the integrity of the message, they cannot verify the identity of the sender. /// </para> /// <note type="note"> /// To use DID keys with this method call the <see cref="Did.KeyForDidAsync(PoolApi.Pool, Wallet, string)"/> with the desired DID to get /// its verification key which can be used as the <paramref name="myVk"/> parameter when calling this method. /// </note> /// </remarks> /// <param name="wallet">The wallet containing the key-pair associated with the verification key specified in the <paramref name="myVk"/> parameter.</param> /// <param name="myVk">The verification key of the intended recipient of the encrypted message.</param> /// <param name="encryptedMessage">The encrypted message to decrypt.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to a byte array containing the decrypted message.</returns> /// <exception cref="WalletValueNotFoundException">Thrown if <paramref name="myVk"/> is not present in the <paramref name="wallet"/>.</exception> /// <exception cref="InvalidStructureException">Thrown if <paramref name="myVk"/> was not used to encrypt <paramref name="encryptedMessage"/>.</exception> public static Task <byte[]> AnonDecryptAsync(Wallet wallet, string myVk, byte[] encryptedMessage) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(myVk, "myVk"); ParamGuard.NotNull(encryptedMessage, "encryptedMessage"); var taskCompletionSource = new TaskCompletionSource <byte[]>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_crypto_anon_decrypt( commandHandle, wallet.Handle, myVk, encryptedMessage, encryptedMessage.Length, CryptoAnonDecryptCompletedCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Builds a GET_ATTRIB ledger request. /// </summary> /// <remarks> /// <para> /// Builds a request message that is suitable for requesting an attribute from the /// ledger. /// </para> /// </remarks> /// <param name="submitterDid">The DID of the submitter.</param> /// <param name="targetDid">The target DID.</param> /// <param name="raw">The name of the attribute to get.</param> /// <param name="hash"></param> /// <param name="enc"></param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to a <see cref="string"/> /// containing the request JSON. </returns> public static Task <string> BuildGetAttribRequestAsync(string submitterDid, string targetDid, string raw, string hash, string enc) { ParamGuard.NotNullOrWhiteSpace(submitterDid, "submitterDid"); ParamGuard.NotNullOrWhiteSpace(targetDid, "targetDid"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_build_get_attrib_request( commandHandle, submitterDid, targetDid, raw, hash, enc, BuildRequestCallback ); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Builds a GET_CLAIM_DEF ledger request. /// </summary> /// <remarks> /// Builds a request message that is suitable for getting a claim definition from a ledger. /// </remarks> /// <note type="note">The <paramref name="signatureType"/> parameter only accepts the value /// 'CL' at present.</note> /// <param name="submitterDid">The DID of the party that will submit the request.</param> /// <param name="xref">The sequence number of the schema the claim definition targets.</param> /// <param name="signatureType">The type of signature used in the claim definition.</param> /// <param name="origin">The DID of the issuer of the claim definition.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to a <see cref="string"/> /// containing the request JSON. </returns> public static Task <string> BuildGetClaimDefTxnAsync(string submitterDid, int xref, string signatureType, string origin) { ParamGuard.NotNullOrWhiteSpace(submitterDid, "submitterDid"); ParamGuard.NotNullOrWhiteSpace(signatureType, "signatureType"); ParamGuard.NotNullOrWhiteSpace(origin, "origin"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_build_get_claim_def_txn( commandHandle, submitterDid, xref, signatureType, origin, _buildRequestCallback ); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Builds a ledger request to store a NYM. /// </summary> /// <remarks> /// <para> /// Builds a request message that is suitable for storing a NYM for the <paramref name="targetDid"/> /// on the ledger. /// </para> /// <para> /// Only the <paramref name="submitterDid"/> and <paramref name="targetDid"/> parameters /// are required, however the other parameters provide greater control over the process. Normally /// the <paramref name="targetDid"/> and <paramref name="verKey"/> parameters would be from values /// generated by a prior call to <see cref="Did.CreateAndStoreMyDidAsync(Wallet, string)"/>. /// </para> /// <para> /// The <paramref name="role"/> parameter dictates what permissions the NYM will have - valid values /// are 'STEWARD' and 'TRUSTEE' and 'TRUST_ANCHOR'. /// </para> /// </remarks> /// <param name="submitterDid">The DID of the party who will submit the request to the ledger.</param> /// <param name="targetDid">The DID the NYM belongs to.</param> /// <param name="verKey">The verification key for the NYM.</param> /// <param name="alias">The alias for the NYM.</param> /// <param name="role">The role of the NYM.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to a <see cref="string"/> /// containing the request JSON. </returns> public static Task <string> BuildNymRequestAsync(string submitterDid, string targetDid, string verKey, string alias, string role) { ParamGuard.NotNullOrWhiteSpace(submitterDid, "submitterDid"); ParamGuard.NotNullOrWhiteSpace(targetDid, "targetDid"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_build_nym_request( commandHandle, submitterDid, targetDid, verKey, alias, role, BuildRequestCallback ); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Modifies Indy request by adding information how to pay fees for this transaction /// according to selected payment method. /// /// Payment selection is performed by looking to o /// /// This method consumes set of UTXO inputs and outputs. The difference between inputs balance /// and outputs balance is the fee for this transaction. /// /// Not that this method also produces correct fee signatures. /// /// Format of inputs is specific for payment method. Usually it should reference payment transaction /// with at least one output that corresponds to payment address that user owns. /// /// Note this endpoint is EXPERIMENTAL. Function signature and behaviour may change /// in the future releases. /// </summary> /// <returns>The request fees async.</returns> /// <param name="wallet">Wallet.</param> /// <param name="submitterDid">DID of request sender</param> /// <param name="reqJson">Initial transaction request as json</param> /// <param name="inputsJson">The list of UTXO inputs as json array: /// ["input1", ...] /// Notes: /// - each input should reference paymentAddress /// - this param will be used to determine payment_method /// </param> /// <param name="outputsJson">outputs_json: The list of UTXO outputs as json array: /// [{ /// paymentAddress: <str>, // payment address used as output /// amount: <int>, // amount of tokens to transfer to this payment address /// extra: <str>, // optional data /// }]</param> /// <param name="extra">Optional information for payment operation.</param> public static Task <PaymentResult> AddRequestFeesAsync(Wallet wallet, string submitterDid, string reqJson, string inputsJson, string outputsJson, string extra) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(submitterDid, "submitterDid"); var taskCompletionSource = new TaskCompletionSource <PaymentResult>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_add_request_fees( commandHandle, wallet.Handle, submitterDid, reqJson, inputsJson, outputsJson, extra, AddRequestFeesCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Sets the endpoint details for the specified DID. /// </summary> /// <param name="wallet">The wallet containing the DID.</param> /// <param name="did">The DID to set the endpoint details on.</param> /// <param name="address">The address of the endpoint.</param> /// <param name="transportKey">The transport key.</param> /// <returns>An asynchronous <see cref="Task"/> that completes when the operation completes.</returns> /// <exception cref="InvalidStructureException">Thrown if the <paramref name="did"/> or <paramref name="transportKey"/> values are malformed.</exception> public static Task SetEndpointForDidAsync(Wallet wallet, string did, string address, string transportKey) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(did, "did"); ParamGuard.NotNullOrWhiteSpace(address, "address"); ParamGuard.NotNullOrWhiteSpace(transportKey, "transportKey"); var taskCompletionSource = new TaskCompletionSource <bool>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_set_endpoint_for_did( commandHandle, wallet.Handle, did, address, transportKey, CallbackHelper.TaskCompletingNoValueCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Verifies a message signature with a verification key. /// </summary> /// <note type="note"> /// To use DID keys with this method call the <see cref="Did.KeyForDidAsync(PoolApi.Pool, Wallet, string)"/> with the desired DID to get /// its verification key which can be used as the <paramref name="theirVk"/> parameter when calling this method. /// </note> /// <param name="theirVk">The verification key belonging to the party that signed the message.</param> /// <param name="message">The message that was signed.</param> /// <param name="signature">The signature for the message.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that, when the operation completes, resolves to true if the signature was valid, otherwise false.</returns> public static Task <bool> VerifyAsync(string theirVk, byte[] message, byte[] signature) { ParamGuard.NotNullOrWhiteSpace(theirVk, "theirVk"); ParamGuard.NotNull(message, "message"); ParamGuard.NotNull(signature, "signature"); var taskCompletionSource = new TaskCompletionSource <bool>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_crypto_verify( commandHandle, theirVk, message, message.Length, signature, signature.Length, _cryptoVerifyCompletedCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// TODO: Issuers the create claim offer async. /// </summary> /// <returns>The create claim offer async.</returns> /// <param name="wallet">Wallet.</param> /// <param name="schemaJson">Schema json.</param> /// <param name="issuerDid">Issuer did.</param> /// <param name="proverDid">Prover did.</param> public static Task <string> IssuerCreateClaimOfferAsync(Wallet wallet, string schemaJson, string issuerDid, string proverDid) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(schemaJson, "schemaJson"); ParamGuard.NotNullOrWhiteSpace(issuerDid, "issuerDid"); ParamGuard.NotNullOrWhiteSpace(proverDid, "proverDid"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_issuer_create_claim_offer( commandHandle, wallet.Handle, schemaJson, issuerDid, proverDid, _issuerCreateClaimOfferCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Prepares a message so that it can be securely sent to a recipient. /// </summary> /// <param name="wallet">The wallet containing the keys of the sender and the recipient.</param> /// <param name="senderKey">The public key of the sender.</param> /// <param name="recipientKey">The verification key of the intended recipient of the message.</param> /// <param name="message">The message content to prepare.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to an array of bytes containing the prepared message.</returns> /// <exception cref="WalletValueNotFoundException">Thrown if the sender key does not exist in the <paramref name="wallet"/>.</exception> /// <exception cref="InvalidStructureException">Thrown if the <paramref name="recipientKey"/> is invalid.</exception> public static Task <byte[]> PrepMsgAsync(Wallet wallet, string senderKey, string recipientKey, byte[] message) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(senderKey, "senderKey"); ParamGuard.NotNullOrWhiteSpace(recipientKey, "recipientKey"); ParamGuard.NotNull(message, "message"); var taskCompletionSource = new TaskCompletionSource <byte[]>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_prep_msg( commandHandle, wallet.Handle, senderKey, recipientKey, message, message.Length, _agentMessagePreparedCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Signs and submits a request to the validator pool. /// </summary> /// <remarks> /// This method adds information associated with the submitter specified by the /// <paramref name="submitterDid"/> to the JSON provided in the <paramref name="requestJson"/> parameter /// then signs it with the submitter's signing key from the provided <paramref name="wallet"/> and sends the signed /// request message to the specified validator <paramref name="pool"/>. /// </remarks> /// <param name="pool">The validator pool to submit the request to.</param> /// <param name="wallet">The wallet containing the submitter keys to sign the request with.</param> /// <param name="submitterDid">The DID of the submitter identity.</param> /// <param name="requestJson">The request JSON to sign and submit.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to a JSON <see cref="string"/> /// containing the result of submission when the operation completes.</returns> public static Task <string> SignAndSubmitRequestAsync(Pool pool, Wallet wallet, string submitterDid, string requestJson) { ParamGuard.NotNull(pool, "pool"); ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(submitterDid, "submitterDid"); ParamGuard.NotNullOrWhiteSpace(requestJson, "requestJson"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_sign_and_submit_request( commandHandle, pool.Handle, wallet.Handle, submitterDid, requestJson, SubmitRequestCallback ); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Encrypts the provided message with the public key of the specified DID using the anonymous-encryption scheme. /// </summary> /// <remarks> /// <para>If the wallet specified in the <paramref name="wallet"/> parameter contains the public key /// associated with the DID specified in the <paramref name="did"/> parameter and the value has /// not expired then this key will be used for encryption. /// </para> /// <para>On the other hand, if the public key is not present in the wallet or has expired the public /// key will be read from the ledger in the node pool specified in the <paramref name="pool"/> /// parameter and the wallet will be updated with the new public key if required. /// </para> /// <para>For further information on registering a public key for a DID see the /// <see cref="StoreTheirDidAsync(Wallet, string)"/>method and for information on the expiry of /// values in a wallet see the <see cref="Wallet.CreateWalletAsync(string, string, string, string, string)"/> /// and <see cref="Wallet.OpenWalletAsync(string, string, string)"/> methods. /// </para> /// </remarks> /// <param name="wallet">The wallet containing the DID to use for encryption.</param> /// <param name="pool">The node pool to read the public key from if required.</param> /// <param name="did">The DID the message is to be encrypted for.</param> /// <param name="msg">The message to encrypt.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to a byte array containing the encrypted message once encryption is complete.</returns> public static Task <byte[]> EncryptSealedAsync(Wallet wallet, Pool pool, string did, byte[] msg) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNull(pool, "pool"); ParamGuard.NotNullOrWhiteSpace(did, "did"); ParamGuard.NotNull(msg, "msg"); var taskCompletionSource = new TaskCompletionSource <byte[]>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_encrypt_sealed( commandHandle, wallet.Handle, pool.Handle, did, msg, msg.Length, _encryptSealedCallback); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Creates keys for the given schema and signature type. /// </summary> /// <remarks> /// <para>This method creates both primary and revocation keys for the given /// signature type and schema and stores them in the provided <paramref name="wallet"/>. /// The generated claim definition is returned as a JSON string containing information about the /// signature type, schema, the issuer's public key and the unique identifier of the public key /// in the wallet. /// </para> /// <note type="note">Currently the only signature type that is supported is 'CL'.</note> /// </remarks> /// <param name="wallet">The wallet into which the claim definition will be stored.</param> /// <param name="issuerDid">The DID of the issuer of the claim definition.</param> /// <param name="schemaJson">The JSON schema of the claim definition.</param> /// <param name="signatureType">The type of signature to use.</param> /// <param name="createNonRevoc">Whether to request non-revocation claim.</param> /// <returns> /// An asynchronous <see cref="Task{T}"/> that, when the operation completes, resolves to a /// JSON string containing the claim definition.</returns> public static Task <string> IssuerCreateAndStoreClaimDefAsync(Wallet wallet, string issuerDid, string schemaJson, string signatureType, bool createNonRevoc) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(issuerDid, "issuerDid"); ParamGuard.NotNullOrWhiteSpace(schemaJson, "schemaJson"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_issuer_create_and_store_claim_def( commandHandle, wallet.Handle, issuerDid, schemaJson, signatureType, createNonRevoc, _issuerCreateAndStoreClaimDefCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Encrypt a message by authenticated-encryption scheme. /// /// Sender can encrypt a confidential message specifically for Recipient, using Sender's public key. /// Using Recipient's public key, Sender can compute a shared secret key. /// Using Sender's public key and his secret key, Recipient can compute the exact same shared secret key. /// That shared secret key can be used to verify that the encrypted message was not tampered with, /// before eventually decrypting it. /// </summary> /// <remarks>Note to use DID keys with this function you can call indy_key_for_did to get key id (verkey) /// for specific DID. /// </remarks> /// <returns>The crypt async.</returns> /// <param name="wallet">The wallet containing the key-pair to sign with.</param> /// <param name="myVk"> id (verkey) of my key. The key must be created by calling indy_create_key or indy_create_and_store_my_did</param> /// <param name="theirVk">id (verkey) of their key</param> /// <param name="message">message data to be encrypted</param> public static Task <byte[]> AuthCryptAsync(IWallet wallet, string myVk, string theirVk, byte[] message) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(theirVk, "myVk"); ParamGuard.NotNullOrWhiteSpace(theirVk, "theirVk"); ParamGuard.NotNull(message, "message"); var taskCompletionSource = new TaskCompletionSource <byte[]>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_crypto_auth_crypt( commandHandle, (int)wallet.Handle, myVk, theirVk, message, message.Length, CryptoEncryptCompletedCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
public RCommand(IRobot robot) { ParamGuard.NotNull(robot, nameof(robot)); this.robot = robot; }
public SimpleCommandParser(IRobot robot) { ParamGuard.NotNull(robot, nameof(robot)); this.robot = robot; }