Partner Accounts

use limitless_exchange_rust_sdk::{Client, HmacCredentials};

let http = Client::builder()
    .hmac_credentials(HmacCredentials {
        token_id: token_id.to_string(),
        secret: secret.to_string(),
    })
    .build()?;

let client = Client::from_http_client(http)?;

// Use client.partner_accounts.*

use limitless_exchange_rust_sdk::CreatePartnerAccountInput;

let account = client
    .partner_accounts
    .create_account(
        &CreatePartnerAccountInput {
            display_name: Some("user-alice".to_string()),
            create_server_wallet: Some(true),
        },
        None,
    )
    .await?;

println!("{}", account.profile_id);
println!("{}", account.account);

use limitless_exchange_rust_sdk::ListPartnerAccountsParams;

let accounts = client
    .partner_accounts
    .list_accounts(&ListPartnerAccountsParams {
        limit: Some(25),
        page: Some(1),
        ..Default::default()
    })
    .await?;

for account in accounts.data {
    println!("{} {} {:?}", account.profile_id, account.account, account.display_name);
}

let recovered = client
    .partner_accounts
    .list_accounts(&ListPartnerAccountsParams {
        account: Some("0x1676716Ef7F19B5C5d690631CB57cf0bFD900A3d".to_string()),
        limit: Some(25),
        page: Some(1),
    })
    .await?;

let profile_id = recovered.data.first().map(|account| account.profile_id);

use limitless_exchange_rust_sdk::{
    LimitlessError, PARTNER_ACCOUNT_ALLOWANCE_STATUS_FAILED,
    PARTNER_ACCOUNT_ALLOWANCE_STATUS_MISSING, PARTNER_ACCOUNT_ALLOWANCE_STATUS_SUBMITTED,
};

let mut allowances = client
    .partner_accounts
    .check_allowances(account.profile_id)
    .await?;

if !allowances.ready {
    let retryable = allowances.targets.iter().any(|target| {
        target.retryable
            && matches!(
                target.status.as_str(),
                PARTNER_ACCOUNT_ALLOWANCE_STATUS_MISSING
                    | PARTNER_ACCOUNT_ALLOWANCE_STATUS_FAILED
            )
    });

    if retryable {
        match client
            .partner_accounts
            .retry_allowances(account.profile_id)
            .await
        {
            Ok(retried) => allowances = retried,
            Err(LimitlessError::Api(err)) if err.status == 429 => {
                println!("retryAfterSeconds is in err.data");
            }
            Err(LimitlessError::Api(err)) if err.status == 409 => {
                println!("Retry already running; poll check_allowances again shortly.");
            }
            Err(err) => return Err(err.into()),
        }
    }
}

if allowances
    .targets
    .iter()
    .any(|target| target.status == PARTNER_ACCOUNT_ALLOWANCE_STATUS_SUBMITTED)
{
    // A sponsored tx/user operation was submitted by this retry request.
    // Poll check_allowances again after a short delay to observe confirmed chain state.
}

use limitless_exchange_rust_sdk::PartnerWithdrawalAddressInput;

let identity_token = std::env::var("PRIVY_IDENTITY_TOKEN")?;
let treasury_address = "0x0F3262730c909408042F9Da345a916dc0e1F9787";

let entry = client
    .partner_accounts
    .add_withdrawal_address(
        &identity_token,
        &PartnerWithdrawalAddressInput {
            address: treasury_address.to_string(),
            label: Some("treasury".to_string()),
        },
    )
    .await?;

println!("{}", entry.destination_address);

client
    .partner_accounts
    .delete_withdrawal_address(&identity_token, treasury_address)
    .await?;

use limitless_exchange_rust_sdk::{
    CreatePartnerAccountEoaHeaders, CreatePartnerAccountInput,
};

let account = client
    .partner_accounts
    .create_account(
        &CreatePartnerAccountInput {
            display_name: Some("user-bob".to_string()),
            create_server_wallet: Some(false),
        },
        Some(&CreatePartnerAccountEoaHeaders {
            account: "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed".to_string(),
            signing_message: "0x...".to_string(),
            signature: "0x...".to_string(),
        }),
    )
    .await?;