dfns-sdk-rust 0.2.0

// Code generated by rust-sdk-generator. DO NOT EDIT.

#[allow(unused_imports)]
use super::types::*;

/// Delegated client for wallets operations. Signed operations are split into
/// init/complete pairs so the challenge can be signed on the user side.
#[derive(Clone)]
pub struct DelegatedWalletsClient {
    client: crate::client::Client,
}

impl DelegatedWalletsClient {
    pub fn new(client: crate::client::Client) -> Self {
        DelegatedWalletsClient { client }
    }

    /// Starts delegated signing for abortTransaction: returns the challenge to sign.
    /// Pass the signed assertion to abort_transaction_complete with the same arguments.
    pub async fn abort_transaction_init(
        &self,
        wallet_id: String,
        transaction_id: String,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transactions/{}/abort",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transaction_id)
        );
        self.client
            .create_user_action_challenge(reqwest::Method::PUT, &path, None)
            .await
    }

    /// Finishes delegated signing for abortTransaction: submits the signed challenge
    /// and issues the request.
    pub async fn abort_transaction_complete(
        &self,
        wallet_id: String,
        transaction_id: String,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<AbortTransactionResponse, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transactions/{}/abort",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transaction_id)
        );
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<AbortTransactionResponse>(
                reqwest::Method::PUT,
                &path,
                None,
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for abortTransfer: returns the challenge to sign.
    /// Pass the signed assertion to abort_transfer_complete with the same arguments.
    pub async fn abort_transfer_init(
        &self,
        wallet_id: String,
        transfer_id: String,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transfers/{}/abort",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transfer_id)
        );
        self.client
            .create_user_action_challenge(reqwest::Method::PUT, &path, None)
            .await
    }

    /// Finishes delegated signing for abortTransfer: submits the signed challenge
    /// and issues the request.
    pub async fn abort_transfer_complete(
        &self,
        wallet_id: String,
        transfer_id: String,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<AbortTransferResponse, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transfers/{}/abort",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transfer_id)
        );
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<AbortTransferResponse>(
                reqwest::Method::PUT,
                &path,
                None,
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for activateWallet: returns the challenge to sign.
    /// Pass the signed assertion to activate_wallet_complete with the same arguments.
    pub async fn activate_wallet_init(
        &self,
        wallet_id: String,
        body: ActivateWalletRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/wallets/{}/activate", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for activateWallet: submits the signed challenge
    /// and issues the request.
    pub async fn activate_wallet_complete(
        &self,
        wallet_id: String,
        body: ActivateWalletRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<ActivateWalletResponse, crate::error::Error> {
        let path = format!("/wallets/{}/activate", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<ActivateWalletResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Retrieves a list of transactions requests for the specified wallet.
    pub async fn list_transactions(
        &self,
        wallet_id: String,
        query: Option<ListTransactionsQuery>,
    ) -> Result<ListTransactionsResponse, crate::error::Error> {
        let mut path = format!("/wallets/{}/transactions", urlencoding::encode(&wallet_id));
        if let Some(query) = &query {
            let mut q: Vec<String> = Vec::new();
            if let Some(v) = &query.limit {
                q.push(format!("limit={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.pagination_token {
                q.push(format!(
                    "paginationToken={}",
                    urlencoding::encode(&v.to_string())
                ));
            }
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<ListTransactionsResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for signAndBroadcastTransaction: returns the challenge to sign.
    /// Pass the signed assertion to sign_and_broadcast_transaction_complete with the same arguments.
    pub async fn sign_and_broadcast_transaction_init(
        &self,
        wallet_id: String,
        body: SignAndBroadcastTransactionRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/wallets/{}/transactions", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for signAndBroadcastTransaction: submits the signed challenge
    /// and issues the request.
    pub async fn sign_and_broadcast_transaction_complete(
        &self,
        wallet_id: String,
        body: SignAndBroadcastTransactionRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<SignAndBroadcastTransactionResponse, crate::error::Error> {
        let path = format!("/wallets/{}/transactions", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<SignAndBroadcastTransactionResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for cancelTransaction: returns the challenge to sign.
    /// Pass the signed assertion to cancel_transaction_complete with the same arguments.
    pub async fn cancel_transaction_init(
        &self,
        wallet_id: String,
        transaction_id: String,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transactions/{}/cancel",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transaction_id)
        );
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, None)
            .await
    }

    /// Finishes delegated signing for cancelTransaction: submits the signed challenge
    /// and issues the request.
    pub async fn cancel_transaction_complete(
        &self,
        wallet_id: String,
        transaction_id: String,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<CancelTransactionResponse, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transactions/{}/cancel",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transaction_id)
        );
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<CancelTransactionResponse>(
                reqwest::Method::POST,
                &path,
                None,
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for cancelTransfer: returns the challenge to sign.
    /// Pass the signed assertion to cancel_transfer_complete with the same arguments.
    pub async fn cancel_transfer_init(
        &self,
        wallet_id: String,
        transfer_id: String,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transfers/{}/cancel",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transfer_id)
        );
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, None)
            .await
    }

    /// Finishes delegated signing for cancelTransfer: submits the signed challenge
    /// and issues the request.
    pub async fn cancel_transfer_complete(
        &self,
        wallet_id: String,
        transfer_id: String,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<CancelTransferResponse, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transfers/{}/cancel",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transfer_id)
        );
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<CancelTransferResponse>(
                reqwest::Method::POST,
                &path,
                None,
                &user_action,
            )
            .await
    }

    /// Proxies a request to the Canton Ledger API associated with this wallet, using the validator's OAuth2 credentials. Restricted to a curated allow-list of read-style resources. Used to satisfy the Canton WalletConnect `canton_ledgerApi` method.
    pub async fn proxy_arequest_to_the_canton_ledger_api(
        &self,
        wallet_id: String,
        body: ProxyARequestToTheCantonLedgerApiRequest,
    ) -> Result<serde_json::Value, crate::error::Error> {
        let path = format!(
            "/wallets/{}/canton/ledger-api",
            urlencoding::encode(&wallet_id)
        );
        let body = serde_json::to_value(&body)?;
        self.client
            .request::<serde_json::Value>(reqwest::Method::POST, &path, Some(&body), false)
            .await
    }

    /// Starts delegated signing for speedUpTransaction: returns the challenge to sign.
    /// Pass the signed assertion to speed_up_transaction_complete with the same arguments.
    pub async fn speed_up_transaction_init(
        &self,
        wallet_id: String,
        transaction_id: String,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transactions/{}/speed-up",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transaction_id)
        );
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, None)
            .await
    }

    /// Finishes delegated signing for speedUpTransaction: submits the signed challenge
    /// and issues the request.
    pub async fn speed_up_transaction_complete(
        &self,
        wallet_id: String,
        transaction_id: String,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<SpeedUpTransactionResponse, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transactions/{}/speed-up",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transaction_id)
        );
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<SpeedUpTransactionResponse>(
                reqwest::Method::POST,
                &path,
                None,
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for speedUpTransfer: returns the challenge to sign.
    /// Pass the signed assertion to speed_up_transfer_complete with the same arguments.
    pub async fn speed_up_transfer_init(
        &self,
        wallet_id: String,
        transfer_id: String,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transfers/{}/speed-up",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transfer_id)
        );
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, None)
            .await
    }

    /// Finishes delegated signing for speedUpTransfer: submits the signed challenge
    /// and issues the request.
    pub async fn speed_up_transfer_complete(
        &self,
        wallet_id: String,
        transfer_id: String,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<SpeedUpTransferResponse, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transfers/{}/speed-up",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transfer_id)
        );
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<SpeedUpTransferResponse>(
                reqwest::Method::POST,
                &path,
                None,
                &user_action,
            )
            .await
    }

    /// Retrieves the list of Wallets in your organization. You can filter the results by owner (either by owner id or owner username). Pagination is supported via limit and paginationToken parameters.
    pub async fn list_wallets(
        &self,
        query: Option<ListWalletsQuery>,
    ) -> Result<ListWalletsResponse, crate::error::Error> {
        let mut path = String::from("/wallets");
        if let Some(query) = &query {
            let mut q: Vec<String> = Vec::new();
            if let Some(v) = &query.limit {
                q.push(format!("limit={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.pagination_token {
                q.push(format!(
                    "paginationToken={}",
                    urlencoding::encode(&v.to_string())
                ));
            }
            if let Some(v) = &query.owner {
                q.push(format!("owner={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.owner_id {
                q.push(format!("ownerId={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.owner_username {
                q.push(format!(
                    "ownerUsername={}",
                    urlencoding::encode(&v.to_string())
                ));
            }
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<ListWalletsResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for createWallet: returns the challenge to sign.
    /// Pass the signed assertion to create_wallet_complete with the same arguments.
    pub async fn create_wallet_init(
        &self,
        body: CreateWalletRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = String::from("/wallets");
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for createWallet: submits the signed challenge
    /// and issues the request.
    pub async fn create_wallet_complete(
        &self,
        body: CreateWalletRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<CreateWalletResponse, crate::error::Error> {
        let path = String::from("/wallets");
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<CreateWalletResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Retrieve information about a specific transaction.
    pub async fn get_transaction(
        &self,
        wallet_id: String,
        transaction_id: String,
    ) -> Result<GetTransactionResponse, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transactions/{}",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transaction_id)
        );
        self.client
            .request::<GetTransactionResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Retrieves a Wallet Transfer Request by its ID.
    pub async fn get_transfer(
        &self,
        wallet_id: String,
        transfer_id: String,
    ) -> Result<GetTransferResponse, crate::error::Error> {
        let path = format!(
            "/wallets/{}/transfers/{}",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&transfer_id)
        );
        self.client
            .request::<GetTransferResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Retrieves a Wallet information by its ID.
    pub async fn get_wallet(
        &self,
        wallet_id: String,
    ) -> Result<GetWalletResponse, crate::error::Error> {
        let path = format!("/wallets/{}", urlencoding::encode(&wallet_id));
        self.client
            .request::<GetWalletResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for updateWallet: returns the challenge to sign.
    /// Pass the signed assertion to update_wallet_complete with the same arguments.
    pub async fn update_wallet_init(
        &self,
        wallet_id: String,
        body: UpdateWalletRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/wallets/{}", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::PUT, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for updateWallet: submits the signed challenge
    /// and issues the request.
    pub async fn update_wallet_complete(
        &self,
        wallet_id: String,
        body: UpdateWalletRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<UpdateWalletResponse, crate::error::Error> {
        let path = format!("/wallets/{}", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<UpdateWalletResponse>(
                reqwest::Method::PUT,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Retrieves a list of assets owned by the specified wallet.  Return values vary by chain as shown below.
    pub async fn get_wallet_assets(
        &self,
        wallet_id: String,
        query: Option<GetWalletAssetsQuery>,
    ) -> Result<GetWalletAssetsResponse, crate::error::Error> {
        let mut path = format!("/wallets/{}/assets", urlencoding::encode(&wallet_id));
        if let Some(query) = &query {
            let mut q: Vec<String> = Vec::new();
            if let Some(v) = &query.net_worth {
                q.push(format!("netWorth={}", urlencoding::encode(&v.to_string())));
            }
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<GetWalletAssetsResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Retrieves a list of historical on chain activities for the specified wallet.
    ///
    /// The list reflects the indexed on-chain activity: it includes confirmed transactions only.
    ///
    pub async fn get_wallet_history(
        &self,
        wallet_id: String,
        query: Option<GetWalletHistoryQuery>,
    ) -> Result<GetWalletHistoryResponse, crate::error::Error> {
        let mut path = format!("/wallets/{}/history", urlencoding::encode(&wallet_id));
        if let Some(query) = &query {
            let mut q: Vec<String> = Vec::new();
            if let Some(v) = &query.limit {
                q.push(format!("limit={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.pagination_token {
                q.push(format!(
                    "paginationToken={}",
                    urlencoding::encode(&v.to_string())
                ));
            }
            if let Some(v) = &query.direction {
                q.push(format!("direction={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.kind {
                q.push(format!("kind={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.contract {
                q.push(format!("contract={}", urlencoding::encode(&v.to_string())));
            }
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<GetWalletHistoryResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Retrieves a list of NFTs owned by the specified Wallet.
    pub async fn get_wallet_nfts(
        &self,
        wallet_id: String,
    ) -> Result<GetWalletNftsResponse, crate::error::Error> {
        let path = format!("/wallets/{}/nfts", urlencoding::encode(&wallet_id));
        self.client
            .request::<GetWalletNftsResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for importWallet: returns the challenge to sign.
    /// Pass the signed assertion to import_wallet_complete with the same arguments.
    pub async fn import_wallet_init(
        &self,
        body: ImportWalletRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = String::from("/wallets/import");
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for importWallet: submits the signed challenge
    /// and issues the request.
    pub async fn import_wallet_complete(
        &self,
        body: ImportWalletRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<ImportWalletResponse, crate::error::Error> {
        let path = String::from("/wallets/import");
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<ImportWalletResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Retrieves a list of transfer requests for the specified wallet.
    pub async fn list_transfers(
        &self,
        wallet_id: String,
        query: Option<ListTransfersQuery>,
    ) -> Result<ListTransfersResponse, crate::error::Error> {
        let mut path = format!("/wallets/{}/transfers", urlencoding::encode(&wallet_id));
        if let Some(query) = &query {
            let mut q: Vec<String> = Vec::new();
            if let Some(v) = &query.limit {
                q.push(format!("limit={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.pagination_token {
                q.push(format!(
                    "paginationToken={}",
                    urlencoding::encode(&v.to_string())
                ));
            }
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<ListTransfersResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for transferAsset: returns the challenge to sign.
    /// Pass the signed assertion to transfer_asset_complete with the same arguments.
    pub async fn transfer_asset_init(
        &self,
        wallet_id: String,
        body: TransferAssetRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/wallets/{}/transfers", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::POST, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for transferAsset: submits the signed challenge
    /// and issues the request.
    pub async fn transfer_asset_complete(
        &self,
        wallet_id: String,
        body: TransferAssetRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<TransferAssetResponse, crate::error::Error> {
        let path = format!("/wallets/{}/transfers", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<TransferAssetResponse>(
                reqwest::Method::POST,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for tagWallet: returns the challenge to sign.
    /// Pass the signed assertion to tag_wallet_complete with the same arguments.
    pub async fn tag_wallet_init(
        &self,
        wallet_id: String,
        body: TagWalletRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/wallets/{}/tags", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::PUT, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for tagWallet: submits the signed challenge
    /// and issues the request.
    pub async fn tag_wallet_complete(
        &self,
        wallet_id: String,
        body: TagWalletRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<TagWalletResponse, crate::error::Error> {
        let path = format!("/wallets/{}/tags", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<TagWalletResponse>(
                reqwest::Method::PUT,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for untagWallet: returns the challenge to sign.
    /// Pass the signed assertion to untag_wallet_complete with the same arguments.
    pub async fn untag_wallet_init(
        &self,
        wallet_id: String,
        body: UntagWalletRequest,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!("/wallets/{}/tags", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        self.client
            .create_user_action_challenge(reqwest::Method::DELETE, &path, Some(&body))
            .await
    }

    /// Finishes delegated signing for untagWallet: submits the signed challenge
    /// and issues the request.
    pub async fn untag_wallet_complete(
        &self,
        wallet_id: String,
        body: UntagWalletRequest,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<UntagWalletResponse, crate::error::Error> {
        let path = format!("/wallets/{}/tags", urlencoding::encode(&wallet_id));
        let body = serde_json::to_value(&body)?;
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<UntagWalletResponse>(
                reqwest::Method::DELETE,
                &path,
                Some(&body),
                &user_action,
            )
            .await
    }

    /// Retrieve information about a specific offer received on your wallet.
    pub async fn get_offer(
        &self,
        wallet_id: String,
        offer_id: String,
    ) -> Result<GetOfferResponse, crate::error::Error> {
        let path = format!(
            "/wallets/{}/offers/{}",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&offer_id)
        );
        self.client
            .request::<GetOfferResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// List all offers received on a specific wallet.
    pub async fn list_offers(
        &self,
        wallet_id: String,
        query: Option<ListOffersQuery>,
    ) -> Result<ListOffersResponse, crate::error::Error> {
        let mut path = format!("/wallets/{}/offers", urlencoding::encode(&wallet_id));
        if let Some(query) = &query {
            let mut q: Vec<String> = Vec::new();
            if let Some(v) = &query.limit {
                q.push(format!("limit={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.pagination_token {
                q.push(format!(
                    "paginationToken={}",
                    urlencoding::encode(&v.to_string())
                ));
            }
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<ListOffersResponse>(reqwest::Method::GET, &path, None, false)
            .await
    }

    /// Starts delegated signing for acceptOffer: returns the challenge to sign.
    /// Pass the signed assertion to accept_offer_complete with the same arguments.
    pub async fn accept_offer_init(
        &self,
        wallet_id: String,
        offer_id: String,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!(
            "/wallets/{}/offers/{}/accept",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&offer_id)
        );
        self.client
            .create_user_action_challenge(reqwest::Method::PUT, &path, None)
            .await
    }

    /// Finishes delegated signing for acceptOffer: submits the signed challenge
    /// and issues the request.
    pub async fn accept_offer_complete(
        &self,
        wallet_id: String,
        offer_id: String,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<AcceptOfferResponse, crate::error::Error> {
        let path = format!(
            "/wallets/{}/offers/{}/accept",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&offer_id)
        );
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<AcceptOfferResponse>(
                reqwest::Method::PUT,
                &path,
                None,
                &user_action,
            )
            .await
    }

    /// Starts delegated signing for rejectOffer: returns the challenge to sign.
    /// Pass the signed assertion to reject_offer_complete with the same arguments.
    pub async fn reject_offer_init(
        &self,
        wallet_id: String,
        offer_id: String,
    ) -> Result<crate::signer::UserActionChallenge, crate::error::Error> {
        let path = format!(
            "/wallets/{}/offers/{}/reject",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&offer_id)
        );
        self.client
            .create_user_action_challenge(reqwest::Method::PUT, &path, None)
            .await
    }

    /// Finishes delegated signing for rejectOffer: submits the signed challenge
    /// and issues the request.
    pub async fn reject_offer_complete(
        &self,
        wallet_id: String,
        offer_id: String,
        challenge_identifier: String,
        assertion: crate::signer::CredentialAssertion,
    ) -> Result<RejectOfferResponse, crate::error::Error> {
        let path = format!(
            "/wallets/{}/offers/{}/reject",
            urlencoding::encode(&wallet_id),
            urlencoding::encode(&offer_id)
        );
        let user_action = self
            .client
            .complete_user_action_signing(challenge_identifier, &assertion)
            .await?;
        self.client
            .request_with_user_action::<RejectOfferResponse>(
                reqwest::Method::PUT,
                &path,
                None,
                &user_action,
            )
            .await
    }

    /// Retrieve the transaction history across all wallets within a specified timeframe. The time range is unbounded, but the CSV export is capped at 100,000 rows.
    pub async fn list_org_wallet_history(
        &self,
        query: Option<ListOrgWalletHistoryQuery>,
    ) -> Result<serde_json::Value, crate::error::Error> {
        let mut path = String::from("/wallets/all/history");
        if let Some(query) = &query {
            let mut q: Vec<String> = Vec::new();
            if let Some(v) = &query.limit {
                q.push(format!("limit={}", urlencoding::encode(&v.to_string())));
            }
            if let Some(v) = &query.pagination_token {
                q.push(format!(
                    "paginationToken={}",
                    urlencoding::encode(&v.to_string())
                ));
            }
            q.push(format!(
                "startTime={}",
                urlencoding::encode(&query.start_time.to_string())
            ));
            q.push(format!(
                "endTime={}",
                urlencoding::encode(&query.end_time.to_string())
            ));
            if !q.is_empty() {
                path.push('?');
                path.push_str(&q.join("&"));
            }
        }
        self.client
            .request::<serde_json::Value>(reqwest::Method::GET, &path, None, false)
            .await
    }
}