/// <summary> /// Builds Indy request for getting UTXO list for payment address /// according to this payment method. /// /// Note this endpoint is EXPERIMENTAL. Function signature and behaviour may change /// in the future releases. /// </summary> /// <returns>get_utxo_txn_json - Indy request for getting UTXO list for payment address /// payment_method</returns> /// <param name="wallet">Wallet.</param> /// <param name="submittedDid">DID of request sender</param> /// <param name="paymentAddress">target payment address</param> public static Task <PaymentResult> BuildGetPaymentSourcesAsync(Wallet wallet, string submittedDid, string paymentAddress) { ParamGuard.NotNullOrWhiteSpace(submittedDid, "submittedDid"); ParamGuard.NotNullOrWhiteSpace(paymentAddress, "paymentAddress"); var taskCompletionSource = new TaskCompletionSource <PaymentResult>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_build_get_payment_sources_request( commandHandle, wallet.Handle, submittedDid, paymentAddress, BuildGetUtxoRequestCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Deletes a wallet. /// </summary> /// <remarks> /// <para>Deletes a wallet created earlier using the <see cref="CreateWalletAsync(string, string)"/> /// by name. /// </para> /// <para>The <paramref name="credentials"/> parameter is unused in the default wallet at present, /// however the value can be used by custom wallet implementations; it is up to the custom wallet /// type implementer to interpret the value. /// </para> /// </remarks> /// <param name="config">The name of the wallet to delete.</param> /// <param name="credentials">The wallet credentials.</param> /// <returns>An asynchronous <see cref="Task"/> with no return value that completes when the operation completes.</returns> public static Task DeleteWalletAsync(string config, string credentials) { ParamGuard.NotNullOrWhiteSpace(config, "config"); ParamGuard.NotNullOrWhiteSpace(credentials, "credentials"); var taskCompletionSource = new TaskCompletionSource <bool>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_delete_wallet( commandHandle, config, credentials, CallbackHelper.TaskCompletingNoValueCallback ); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Builds a SCHEMA request. Request to add Credential's schema. /// </summary> /// <returns>The get schema request async.</returns> /// <param name="submitterDid">DID of the submitter stored in secured Wallet..</param> /// <param name="schemaId">Schema ID in ledger</param> public static Task <string> BuildGetSchemaRequestAsync(string submitterDid, string schemaId) { ParamGuard.NotNullOrWhiteSpace(submitterDid, "submitterDid"); ParamGuard.NotNullOrWhiteSpace(schemaId, "schemaId"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_build_get_schema_request( commandHandle, submitterDid, schemaId, BuildRequestCallback ); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Retrieves abbreviated verkey if it is possible otherwise return full verkey. /// </summary> /// <returns>The verkey async.</returns> /// <param name="did">Did.</param> /// <param name="fullVerkey">Full verkey.</param> public static Task <string> AbbreviateVerkeyAsync(string did, string fullVerkey) { ParamGuard.NotNullOrWhiteSpace(did, "did"); ParamGuard.NotNullOrWhiteSpace(fullVerkey, "fullVerkey"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_abbreviate_verkey( commandHandle, did, fullVerkey, AbbreviateVerkeyCompletedCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Get info about My DID in format: DID, verkey, metadata /// </summary> /// <returns>The my did with meta async.</returns> /// <param name="wallet">Wallet.</param> /// <param name="myDid">My did.</param> public static Task <string> GetMyDidWithMetaAsync(Wallet wallet, string myDid) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(myDid, "myDid"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_get_my_did_with_meta( commandHandle, wallet.Handle, myDid, GetMyDidWithMetaCompletedCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Gets the verification key for the specified DID. /// </summary> /// <remarks> /// This method will obtain the verification key associated with the specified <paramref name="did"/>from the provided <paramref name="wallet"/> but will /// not attempt to retrieve the key from the ledger if not present in the wallet, nor will it perform any freshness check against the ledger to determine /// if the key is up-to-date. To ensure that the key is fresh use the <see cref="KeyForDidAsync(Pool, Wallet, string)"/> method instead. /// <note type="note"> /// The <see cref="CreateAndStoreMyDidAsync(Wallet, string)"/> and <see cref="Crypto.CreateKeyAsync(Wallet, string)"/> methods both create /// similar wallet records so the returned verification key in all generic crypto and messaging functions. /// </note> /// </remarks> /// <param name="wallet">The wallet to resolve the DID from.</param> /// <param name="did">The DID to get the verification key for.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to a string containing the verification key associated with the DID.</returns> /// <exception cref="WalletValueNotFoundException">Thrown if the DID could not be resolved from the <paramref name="wallet"/>.</exception> public static Task <string> KeyForLocalDidAsync(Wallet wallet, string did) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(did, "did"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_key_for_local_did( commandHandle, wallet.Handle, did, KeyForLocalDidCompletedCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Create the payment address for this payment method. /// /// This method generates private part of payment address /// and stores it in a secure place. Ideally it should be /// secret in libindy wallet (see crypto module). /// /// Note that payment method should be able to resolve this /// secret by fully resolvable payment address format. /// </summary> /// <returns>Public identifier of payment address in fully resolvable payment address format</returns> /// <param name="wallet">Wallet.</param> /// <param name="paymentMethod">Payment method to use (for example, 'sov')</param> /// <param name="config"> /// <code>payment address config as json: /// { /// seed: <str>, // allows deterministic creation of payment address /// } /// </code> /// </param> public static Task <string> CreatePaymentAddressAsync(Wallet wallet, string paymentMethod, string config) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(paymentMethod, "paymentMethod"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_create_payment_address( commandHandle, wallet.Handle, paymentMethod, config, CreatePaymentAddressCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Creates a new outgoing connection. /// </summary> /// <remarks> /// <para>When establishing a connection two DIDs are required, one for the sender identity (who is /// initiating the connection) and the other for the receiver identity (who the connection is being /// established with). /// </para> /// <para>The <see cref="Wallet"/> provided when creating the connection must contain information about /// the sender identity which must have been added using the <see cref="Signus.CreateAndStoreMyDidAsync(Wallet, string)"/> /// method prior to attempting to create the connection. /// </para> /// <para>The identity information for the receiver can also be stored in the wallet using /// the <see cref="Signus.StoreTheirDidAsync(Wallet, string)"/> method, however if no record is /// present in the wallet the identity information will be established from the ledger in the /// provided node <see cref="Pool"/> and will automatically be cached in the provided wallet. /// </para> /// </remarks> /// <seealso cref="Pool"/> /// <seealso cref="Wallet"/> /// <seealso cref="Signus"/> /// <param name="pool">The node pool that the destination DID is registered on.</param> /// <param name="wallet">The wallet containing the sender (and optionally receiver) DID.</param> /// <param name="senderDid">The DID of the identity imitating the connection.</param> /// <param name="receiverDid">The DID of the identity the connection is to be established with.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to an AgentConnection instance /// when the connection has been established.</returns> public static Task <AgentConnection> ConnectAsync(Pool pool, Wallet wallet, string senderDid, string receiverDid) { var connection = new AgentConnection(); var taskCompletionSource = new TaskCompletionSource <AgentConnection>(connection); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = IndyNativeMethods.indy_agent_connect( commandHandle, pool.Handle, wallet.Handle, senderDid, receiverDid, _connectionEstablishedCallback, connection.MessageReceivedCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Search for wallet records. /// /// Note instead of immediately returning of fetched records /// this call returns wallet_search_handle that can be used later /// to fetch records by small batches (with indy_fetch_wallet_search_next_records). /// </summary> /// <returns>The search async.</returns> /// <param name="wallet">Wallet.</param> /// <param name="type">Type.</param> /// <param name="queryJson"> /// MongoDB style query to wallet record tags: /// <code> /// { /// "tagName": "tagValue", /// $or: { /// "tagName2": { $regex: 'pattern' }, /// "tagName3": { $gte: '123' }, /// }, /// } /// </code> /// </param> /// <param name="optionsJson"> /// <code> /// { /// retrieveRecords: (optional, true by default) If false only "counts" will be calculated, /// retrieveTotalCount: (optional, false by default) Calculate total count, /// retrieveType: (optional, false by default) Retrieve record type, /// retrieveValue: (optional, true by default) Retrieve record value, /// retrieveTags: (optional, false by default) Retrieve record tags, /// } /// </code></param> public static Task <WalletSearch> OpenSearchAsync(Wallet wallet, string type, string queryJson, string optionsJson) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(type, "type"); ParamGuard.NotNullOrWhiteSpace(queryJson, "queryJson"); ParamGuard.NotNullOrWhiteSpace(optionsJson, "optionsJson"); var taskCompletionSource = new TaskCompletionSource <WalletSearch>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_open_wallet_search( commandHandle, wallet.Handle, type, queryJson, optionsJson, OpenSearchCallback); return(taskCompletionSource.Task); }
/// <summary> /// Gets request requirements (with minimal price) correspondent to specific auth rule /// in case the requester can perform this action. /// /// EXPERIMENTAL /// /// If the requester does not match to the request constraints `TransactionNotAllowed` error will be thrown. /// </summary> /// <param name="getAuthRuleResponseJson">Response on `GET_AUTH_RULE` request returning action constraints set on the ledger.</param> /// <param name="requesterInfoJson"> /// { /// "role": string (optional) - role of a user which can sign a transaction. /// "sig_count": u64 - number of signers. /// "is_owner": bool (optional) - if user is an owner of transaction (false by default). /// "is_off_ledger_signature": bool (optional) - if user did is unknow for ledger (false by default). /// }</param> /// <param name="feesJson">fees set on the ledger (result of <see cref="ParseGetTxnFeesResponseAsync" />).</param> /// <returns> /// request info if a requester match to the action constraints. /// { /// "price": u64 - fee required for the action performing, /// "requirements": [{ /// "role": string (optional) - role of users who should sign, /// "sig_count": u64 - number of signers, /// "need_to_be_owner": bool - if requester need to be owner, /// "off_ledger_signature": bool - allow signature of unknow for ledger did (false by default). /// }] /// } /// </returns> public static Task <string> GetRequestInfoAsync(string getAuthRuleResponseJson, string requesterInfoJson, string feesJson) { ParamGuard.NotNullOrWhiteSpace(getAuthRuleResponseJson, "getAuthRuleResponseJson"); ParamGuard.NotNullOrWhiteSpace(requesterInfoJson, "requesterInfoJson"); ParamGuard.NotNullOrWhiteSpace(feesJson, "feesJson"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_get_request_info( commandHandle, getAuthRuleResponseJson, requesterInfoJson, feesJson, GetRequestInfoDelegate); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Builds Indy request for doing tokens minting /// according to this payment method. /// /// Note this endpoint is EXPERIMENTAL. Function signature and behaviour may change /// in the future releases. /// </summary> /// <returns>Indy request for doing tokens minting.</returns> /// <param name="wallet">Wallet.</param> /// <param name="submitterDid">Submitter did.</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> BuildMintRequestAsync(Wallet wallet, string submitterDid, string outputsJson, string extra) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(outputsJson, "outputsJson"); var taskCompletionSource = new TaskCompletionSource <PaymentResult>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_build_mint_req( commandHandle, wallet.Handle, submitterDid, outputsJson, extra, BuildMintRequestCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Creates a proof for the provided proof request. /// </summary> /// <remarks> /// <para> /// Either a corresponding claim with optionally revealed attributes or self-attested attribute /// must be provided for each requested attribute - see the /// <see cref="ProverGetClaimsForProofReqAsync(Wallet, string)"/> method. /// A proof request may request multiple claims from different schema and different issuers. /// All required schema, public keys and revocation registries must be provided. /// The proof request also contains a nonce. /// The proof contains either proof or self-attested attribute value for each requested attribute. /// </para> /// <para> /// The <paramref name="proofReqJson"/> parameter expects a JSON string containing a proof request /// from the party that will verify the proof. E.g.: /// <code> /// { /// "nonce": string, /// "requested_attr1_uuid": <attr_info>, /// "requested_attr2_uuid": <attr_info>, /// "requested_attr3_uuid": <attr_info>, /// "requested_predicate_1_uuid": <predicate_info>, /// "requested_predicate_2_uuid": <predicate_info>, /// } /// </code> /// </para> /// <para> /// The <paramref name="requestedClaimsJson"/> parameter should contain either a claim or a /// self-attested attribute for each attribute requested in the proof request. E.g.: /// <code> /// { /// "requested_attr1_uuid": [claim1_uuid_in_wallet, true <reveal_attr>], /// "requested_attr2_uuid": [self_attested_attribute], /// "requested_attr3_uuid": [claim2_seq_no_in_wallet, false] /// "requested_attr4_uuid": [claim2_seq_no_in_wallet, true] /// "requested_predicate_1_uuid": [claim2_seq_no_in_wallet], /// "requested_predicate_2_uuid": [claim3_seq_no_in_wallet], /// } /// </code> /// </para> /// <para> /// The <paramref name="schemasJson"/> parameter expects the JSON for each schema that participates /// in the proof request. E.g.: /// <code> /// { /// "claim1_uuid_in_wallet": <schema1>, /// "claim2_uuid_in_wallet": <schema2>, /// "claim3_uuid_in_wallet": <schema3>, /// } /// </code> /// </para> /// <para> /// The <paramref name="masterSecretName"/> specifies the name of the master secret stored in /// the wallet. /// </para> /// <para> /// The <paramref name="claimDefsJson"/> parameter expects the JSON for each claim definition /// participating in the proof request. E.g.: /// <code> /// { /// "claim1_uuid_in_wallet": <claim_def1>, /// "claim2_uuid_in_wallet": <claim_def2>, /// "claim3_uuid_in_wallet": <claim_def3>, /// } /// </code> /// </para> /// <para> /// The <paramref name="revocRegsJson"/> parameter expects the JSON for each revocation registry /// participating in the proof request. E.g.: /// <code> /// { /// "claim1_uuid_in_wallet": <revoc_reg1>, /// "claim2_uuid_in_wallet": <revoc_reg2>, /// "claim3_uuid_in_wallet": <revoc_reg3>, /// } /// </code> /// </para> /// Upon successful completion the operation will return a JSON string. /// For each requested attribute either a proof (with optionally revealed attribute value) or /// self-attested attribute value is provided. /// Each proof is associated with a claim and corresponding schema_seq_no, issuer_did and revoc_reg_seq_no. /// There is also aggregated proof part common for all claim proofs. /// <code> /// { /// "requested": { /// "requested_attr1_id": [claim_proof1_uuid, revealed_attr1, revealed_attr1_as_int], /// "requested_attr2_id": [self_attested_attribute], /// "requested_attr3_id": [claim_proof2_uuid] /// "requested_attr4_id": [claim_proof2_uuid, revealed_attr4, revealed_attr4_as_int], /// "requested_predicate_1_uuid": [claim_proof2_uuid], /// "requested_predicate_2_uuid": [claim_proof3_uuid], /// } /// "claim_proofs": { /// "claim_proof1_uuid": [<claim_proof>, issuer_did, schema_seq_no, revoc_reg_seq_no], /// "claim_proof2_uuid": [<claim_proof>, issuer_did, schema_seq_no, revoc_reg_seq_no], /// "claim_proof3_uuid": [<claim_proof>, issuer_did, schema_seq_no, revoc_reg_seq_no] /// }, /// "aggregated_proof": <aggregated_proof> /// } /// </code> /// </remarks> /// <param name="wallet">The target wallet.</param> /// <param name="proofReqJson">The proof request JSON.</param> /// <param name="requestedClaimsJson">The requested claims JSON.</param> /// <param name="schemasJson">The schema JSON.</param> /// <param name="masterSecretName">The master secret name.</param> /// <param name="claimDefsJson">The claim definitions JSON.</param> /// <param name="revocRegsJson">The revocation registries JSON.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that, when the operation completes, resolves /// to a JSON string containing the proof.</returns> public static Task <string> ProverCreateProofAsync(Wallet wallet, string proofReqJson, string requestedClaimsJson, string schemasJson, string masterSecretName, string claimDefsJson, string revocRegsJson) { var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = IndyNativeMethods.indy_prover_create_proof( commandHandle, wallet.Handle, proofReqJson, requestedClaimsJson, schemasJson, masterSecretName, claimDefsJson, revocRegsJson, _proverCreateProofCallback); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Updates and stores the provided claim in the specified wallet. /// </summary> /// <remarks> /// <para> /// This method updates the claim provided in the <paramref name="claimsJson"/> parameter /// with a blinded master secret and stores it in the wallet specified in the /// <paramref name="wallet"/> parameter. /// </para> /// <para> /// The claim JSON is typically structured as follows: /// <code> /// { /// "claim": {attr1:[value, value_as_int]} /// "signature": <signature>, /// "schema_seq_no": string, /// "revoc_reg_seq_no", string /// "issuer_did", string /// } /// </code> /// It contains the information about the <c>schema_seq_no</c>, <c>issuer_did</c> /// and <c>revoc_reg_seq_no</c> - see the <see cref="IssuerCreateClaimAsync(Wallet, string, string, int)"/> /// method for details. /// </para> /// Seq_no is a sequence number of the corresponding transaction in the ledger. /// </remarks> /// <param name="wallet">The target wallet.</param> /// <param name="claimsJson">The claims JSON.</param> /// <param name="revRegJson">revocation registry json</param> /// <returns>An asynchronous <see cref="Task"/> that completes when the operation has completed.</returns> public static Task ProverStoreClaimAsync(Wallet wallet, string claimsJson, string revRegJson) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(claimsJson, "claimsJson"); var taskCompletionSource = new TaskCompletionSource <bool>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_prover_store_claim( commandHandle, wallet.Handle, claimsJson, revRegJson, CallbackHelper.TaskCompletingNoValueCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Send action to particular nodes of validator pool. /// </summary> /// <param name="pool">The validator pool to submit the request to.</param> /// <param name="requestJson">The request to submit.</param> /// <param name="nodes">A list of node names to send the request to.</param> /// <param name="timeout">The time in seconds to wait for a response from the nodes.</param> /// <remarks> /// The list of node names in the <paramref name="nodes"/> parameter is optional, however if provided it should conform /// to the format ["Node1", "Node2",...."NodeN"]. To use the default timeout provide the value -1 to the /// <paramref name="timeout"/> parameter. /// </remarks> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to a JSON <see cref="string"/> /// containing the results when the operation completes.</returns> public static Task <string> SubmitActionAsync(Pool pool, string requestJson, string nodes, int timeout) { ParamGuard.NotNull(pool, "pool"); ParamGuard.NotNullOrWhiteSpace(requestJson, "requestJson"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_submit_action( commandHandle, pool.Handle, requestJson, nodes, timeout, SubmitRequestCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Closes the connection. /// </summary> /// <remarks> /// Once closed a connection instance cannot be re-opened; a new connection instance must be /// created. /// </remarks> /// <returns>An asynchronous <see cref="Task"/> completes once the operation completes.</returns> public Task CloseAsync() { _requiresClose = false; var taskCompletionSource = new TaskCompletionSource <bool>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = IndyNativeMethods.indy_agent_close_connection( commandHandle, Handle, CallbackHelper.TaskCompletingNoValueCallback ); CallbackHelper.CheckResult(result); GC.SuppressFinalize(this); return(taskCompletionSource.Task); }
/// <summary> /// Builds a GET_REVOC_REG_DELTA request. Request to get the delta of the accumulated state of the Revocation Registry. /// The Delta is defined by from and to timestamp fields. /// If from is not specified, then the whole state till to will be returned. /// </summary> /// <returns>Request result as json.</returns> /// <param name="submitterDid">DID of the read request sender.</param> /// <param name="revocRegDefId">ID of the corresponding Revocation Registry Definition in ledger.</param> /// <param name="from">Requested time represented as a total number of seconds from Unix Epoch.</param> /// <param name="to">Requested time represented as a total number of seconds from Unix Epoch.</param> public static Task <string> BuildGetRevocRegDeltaRequestAsync(string submitterDid, string revocRegDefId, long from, long to) { ParamGuard.NotNullOrWhiteSpace(submitterDid, "submitterDid"); ParamGuard.NotNullOrWhiteSpace(revocRegDefId, "id"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_build_get_revoc_reg_delta_request( commandHandle, submitterDid, revocRegDefId, from, to, BuildRequestCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Sets metadata for the specified DID. /// </summary> /// <remarks> /// Any existing metadata stored for the DID will be replaced. /// </remarks> /// <param name="wallet">The wallet containing the DID.</param> /// <param name="did">The DID to set the metadata on.</param> /// <param name="metadata">The metadata to store.</param> /// <returns>An asynchronous <see cref="Task"/> that completes when the operation completes.</returns> /// <exception cref="WalletItemNotFoundException">Thrown if the <paramref name="wallet"/> does not contain the specified <paramref name="did"/>.</exception> /// <exception cref="InvalidStructureException">Thrown if the value provided to the <paramref name="did"/> parameter is malformed.</exception> public static Task SetDidMetadataAsync(Wallet wallet, string did, string metadata) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(did, "did"); var taskCompletionSource = new TaskCompletionSource <bool>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_set_did_metadata( commandHandle, wallet.Handle, did, metadata, CallbackHelper.TaskCompletingNoValueCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Builds Indy request for information to verify the payment receipt /// </summary> /// <returns>Indy request for verification receipt.</returns> /// <param name="wallet">Wallet.</param> /// <param name="submitterDid">DID of request sender</param> /// <param name="receipt">Payment receipt to verify.</param> public static Task <PaymentResult> BuildVerifyPaymentRequestAsync(IWallet wallet, IDid submitterDid, string receipt) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNull(submitterDid, "submitterDid"); ParamGuard.NotNullOrWhiteSpace(receipt, "receipt"); var taskCompletionSource = new TaskCompletionSource <PaymentResult>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_build_verify_payment_req( commandHandle, wallet.Handle, submitterDid.Did, receipt, BuildVerifyPaymentRequestCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Signs a request message. /// </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 wallet. /// </remarks> /// <param name="wallet">The wallet to use for signing.</param> /// <param name="submitterDid">The DID of the submitter identity in the provided wallet.</param> /// <param name="requestJson">The request JSON to sign.</param> /// <returns>An asynchronous task that resolves to a <see cref="string"/> containing the signed /// message.</returns> public static Task <string> SignRequestAsync(Wallet wallet, string submitterDid, string requestJson) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(submitterDid, "submitterDid"); ParamGuard.NotNullOrWhiteSpace(requestJson, "requestJson"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); int result = NativeMethods.indy_sign_request( commandHandle, wallet.Handle, submitterDid, requestJson, SignRequestCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Generates new signing and encryption keys in the specified wallet for an existing DID owned by the caller /// </summary> /// <remarks> /// The developer has some control over the generation of the new keys through the value passed to /// the <paramref name="identityJson"/> parameter. This parameter expects a valid JSON string /// with the following optional members: /// <code> /// { /// "seed": string, (optional) Seed that allows deterministic key creation (if not set random one will be created). /// Can be UTF-8, base64 or hex string. /// "crypto_type": string, (optional) if not set then ed25519 curve is used; /// currently only 'ed25519' value is supported for this field) /// } /// </code> /// <para>The <c>seed</c> member controls the seed that will be used to generate they keys. /// If not provided a random one will be created.</para> /// <para>The <c>crypto_type</c> member specifies the type of cryptographic algorithm will be /// used to generate they keys. If not provided then ed22519 curve will be used. /// <note type="note">The only value currently supported for this member is 'ed25519'.</note> /// </para> /// </remarks> /// <param name="wallet">The wallet the DID is stored in.</param> /// <param name="did">The did to replace the keys for.</param> /// <param name="identityJson">The identity information as JSON.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to a string containing the new verification key when the operation completes.</returns> public static Task <string> ReplaceKeysStartAsync(Wallet wallet, string did, string identityJson) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(did, "did"); ParamGuard.NotNullOrWhiteSpace(identityJson, "identityJson"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_replace_keys_start( commandHandle, wallet.Handle, did, identityJson, ReplaceKeysCallback); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Encrypts a message by anonymous-encryption scheme. /// /// Sealed boxes are designed to anonymously send messages to a Recipient given its public key. /// Only the Recipient can decrypt these messages, using its private key. /// While the Recipient can verify the integrity of the message, it cannot verify the identity of the Sender. /// /// Note to use DID keys with this function you can call indy_key_for_did to get key id (verkey) /// for specific DID. /// </summary> /// <returns>The crypt async.</returns> /// <param name="theirVk">id (verkey) of their key</param> /// <param name="message">Message to be encrypted</param> public static Task <byte[]> AnonCryptAsync(string theirVk, byte[] message) { ParamGuard.NotNullOrWhiteSpace(theirVk, "theirVk"); ParamGuard.NotNull(message, "message"); var taskCompletionSource = new TaskCompletionSource <byte[]>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_crypto_anon_crypt( commandHandle, theirVk, message, message.Length, _cryptoEncryptCompletedCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Builds Indy get request for getting 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 getting fees for transactions in the ledger.</returns> /// <param name="wallet">Wallet.</param> /// <param name="submitterDid">DID of request sender</param> /// <param name="paymentMethod">Payment method.</param> public static Task <string> BuildGetTxnFeesRequestAsync(IWallet wallet, IDid submitterDid, string paymentMethod) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNull(submitterDid, "submitterDid"); ParamGuard.NotNullOrWhiteSpace(paymentMethod, "paymentMethod"); var taskCompletionSource = new TaskCompletionSource <string>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_build_get_txn_fees_req( commandHandle, wallet.Handle, submitterDid.Did, paymentMethod, BuildGetTxnFeesReqCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Update a non-secret wallet record value /// </summary> /// <returns>The record async.</returns> /// <param name="wallet">Wallet.</param> /// <param name="type">Allows to separate different record types collections.</param> /// <param name="id">The id of record.</param> /// <param name="value">The value of record.</param> public static Task UpdateRecordValueAsync(Wallet wallet, string type, string id, string value) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(type, "type"); ParamGuard.NotNullOrWhiteSpace(id, "id"); ParamGuard.NotNullOrWhiteSpace(value, "value"); var taskCompletionSource = new TaskCompletionSource <bool>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_update_wallet_record_value( commandHandle, wallet.Handle, type, id, value, CallbackHelper.TaskCompletingNoValueCallback); return(taskCompletionSource.Task); }
/// <summary> /// Delete tags from the wallet record /// </summary> /// <returns>The record tags async.</returns> /// <param name="wallet">Wallet.</param> /// <param name="type">Allows to separate different record types collections.</param> /// <param name="id">The id of record.</param> /// <param name="tagsJson">the list of tag names to remove from the record as json array: /// <c> ["tagName1", "tagName2", ...]</c></param> public static Task DeleteRecordTagsAsync(Wallet wallet, string type, string id, string tagsJson) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(type, "type"); ParamGuard.NotNullOrWhiteSpace(id, "id"); ParamGuard.NotNullOrWhiteSpace(tagsJson, "tagsJson"); var taskCompletionSource = new TaskCompletionSource <bool>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_delete_wallet_record_tags( commandHandle, wallet.Handle, type, id, tagsJson, CallbackHelper.TaskCompletingNoValueCallback); return(taskCompletionSource.Task); }
/// <summary> /// Sets user defined metadata for a key-pair in the specified wallet. /// </summary> /// <remarks> /// Any existing metadata stored for the key-pair will be replaced. /// </remarks> /// <param name="wallet">The wallet containing the key.</param> /// <param name="verKey">The verification key of the key pair.</param> /// <param name="metadata">The metadata to set.</param> /// <returns>An asynchronous <see cref="Task"/> that completes when the operation completes.</returns> /// <exception cref="WalletItemNotFoundException">Thrown if the wallet does not contain a key-pair matching the provided <paramref name="verKey"/>.</exception> public static Task SetKeyMetadataAsync(IWallet wallet, string verKey, string metadata) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(verKey, "verKey"); var taskCompletionSource = new TaskCompletionSource <bool>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_set_key_metadata( commandHandle, (int)wallet.Handle, verKey, metadata, CallbackHelper.TaskCompletingNoValueCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Creates a new AgentListener that listens for incoming connections on the specified endpoint. /// </summary> /// <remarks> /// The endpoint specified must be in the format <c>address:port</c> where <c>address</c> is /// an IP address or host address and <c>port</c> is a numeric port number. /// </remarks> /// <param name="endpoint">The endpoint on which the incoming connections will listened for.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to an AgentListener instance /// once the listener has been created.</returns> public static Task <AgentListener> ListenAsync(string endpoint) { ParamGuard.NotNullOrWhiteSpace(endpoint, "endpoint"); var listener = new AgentListener(); var taskCompletionSource = new TaskCompletionSource <AgentListener>(listener); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = IndyNativeMethods.indy_agent_listen( commandHandle, endpoint, _listenerCreatedCallback, listener.ConnectionEstablishedCallback, listener.MessageReceivedCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Removes an identity from the listener. /// </summary> /// <remarks> /// <para>Once an identity has been added to an AgentListner using the <see cref="AddIdentityAsync(Pool, Wallet, string)"/> /// it can be removed using this method. A <see cref="Wallet"/> lookup will be performed to find /// the identity information for the DID so the wallet containing the DID must be provided. /// </para> /// </remarks> /// <param name="wallet">The wallet that contains the identity for the DID.</param> /// <param name="did">The DID of the identity to remove. </param> /// <returns>An asynchronous <see cref="Task"/> completes once the operation completes.</returns> public Task RemoveIdentityAsync(Wallet wallet, string did) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(did, "did"); var taskCompletionSource = new TaskCompletionSource <bool>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = IndyNativeMethods.indy_agent_remove_identity( commandHandle, Handle, wallet.Handle, did, CallbackHelper.TaskCompletingNoValueCallback ); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Gets the endpoint details for the specified DID. /// </summary> /// <remarks> /// If the <paramref name="did"/> is present in the <paramref name="wallet"/> and is considered "fresh" then /// the endpoint will be resolved from the wallet. If, on the other hand, the DID is not present in the wallet or /// is not fresh then the details will be resolved from the <paramref name="pool"/> and will be cached in the wallet. /// </remarks> /// <param name="wallet">The wallet containing the DID.</param> /// <param name="pool">The pool to resolve the endpoint data from if not present in the wallet.</param> /// <param name="did">The DID to get the endpoint data for.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to an <see cref="EndpointForDidResult"/> containing the endpoint information /// associated with the DID.</returns> public static Task <EndpointForDidResult> GetEndpointForDidAsync(Wallet wallet, Pool pool, string did) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNull(pool, "pool"); ParamGuard.NotNullOrWhiteSpace(did, "did"); var taskCompletionSource = new TaskCompletionSource <EndpointForDidResult>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var commandResult = NativeMethods.indy_get_endpoint_for_did( commandHandle, wallet.Handle, pool.Handle, did, GetEndpointForDidCompletedCallback ); CallbackHelper.CheckResult(commandResult); return(taskCompletionSource.Task); }
/// <summary> /// Creates a new wallet. /// </summary> /// <remarks> /// <para>Each created wallet is given a name which is then subsequently used to open it /// with the <see cref="OpenWalletAsync(string, string, string)"/> or delete it using the /// <see cref="DeleteWalletAsync(string, string)"/> static methods. /// <note type="note">Wallet names must be unique within a pool.</note> /// </para> /// <para> /// When creating a new Wallet the <paramref name="type"/> parameter can be null or "default" to /// use the default wallet implementation, or a type name specified in an earlier call to the /// <see cref="RegisterWalletTypeAsync(string, WalletType)"/> method to use a custom wallet implementation. /// Attempting to use a wallet type that hasn't previously been registered will result in an error. /// </para> /// <para>The <paramref name="config"/> parameter allows configuration values to be passed to the wallet /// when it is created. When using the default wallet this value can be null to use the default /// wallet configuration or a JSON string with the following format can be used: /// <code> /// { /// "freshness_time": int /// } /// </code> /// The value of the <c>freshness_time</c> key is an integer representing the number of seconds /// a value in the wallet will remain valid before expiring. If not specified the default value /// for <c>freshness_time</c> is 24 * 60 seconds. /// </para> /// <para>If using a custom wallet type the content of the <paramref name="config"/> parameter can /// be any string value; it is up to the custom wallet type implementer to interpret the value. /// </para> /// <para>The <paramref name="credentials"/> parameter is unused in the default wallet at present, /// however the value can be used by custom wallet implementations; it is up to the custom wallet /// type implementer to interpret the value.</para> /// </remarks> /// <param name="poolName">The name of the pool the wallet is associated with.</param> /// <param name="name">The name of the wallet.</param> /// <param name="type">The type of the wallet. </param> /// <param name="config">The wallet configuration JSON.</param> /// <param name="credentials">The wallet credentials JSON or null to use the default credentials.</param> /// <returns>An asynchronous <see cref="Task"/> with no return value the completes when the operation has finished.</returns> public static Task CreateWalletAsync(string poolName, string name, string type, string config, string credentials) { ParamGuard.NotNullOrWhiteSpace(poolName, "poolName"); ParamGuard.NotNullOrWhiteSpace(name, "name"); var taskCompletionSource = new TaskCompletionSource <bool>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = IndyNativeMethods.indy_create_wallet( commandHandle, poolName, name, type, config, credentials, CallbackHelper.TaskCompletingNoValueCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }
/// <summary> /// Parses an encrypted message prepared by another party. /// </summary> /// <param name="wallet">The wallet containing the keys.</param> /// <param name="recipientKey">The verification key of the recipient.</param> /// <param name="encryptedMsg">The encrypted message to parse.</param> /// <returns>An asynchronous <see cref="Task{T}"/> that resolves to a <see cref="ParseMsgResult"/> containing the sender key and the parsed message /// content.</returns> /// <exception cref="InvalidStructureException">Thrown if the value passed to the <paramref name="recipientKey"/> parameter is malformed or the <paramref name="encryptedMsg"/> is invalid.</exception> /// <exception cref="WalletValueNotFoundException">Thrown if the <paramref name="recipientKey"/> does not exist in the <paramref name="wallet"/>.</exception> public static Task <ParseMsgResult> ParseMsgAsync(Wallet wallet, string recipientKey, byte[] encryptedMsg) { ParamGuard.NotNull(wallet, "wallet"); ParamGuard.NotNullOrWhiteSpace(recipientKey, "recipientKey"); ParamGuard.NotNull(encryptedMsg, "encryptedMsg"); var taskCompletionSource = new TaskCompletionSource <ParseMsgResult>(); var commandHandle = PendingCommands.Add(taskCompletionSource); var result = NativeMethods.indy_parse_msg( commandHandle, wallet.Handle, recipientKey, encryptedMsg, encryptedMsg.Length, _agentMessageParsedCallback); CallbackHelper.CheckResult(result); return(taskCompletionSource.Task); }