@avacuscc/sdk 0.1.0 → 0.2.0

package/packages/sdk/dist/index.d.ts

@@ -1,17 +1,381 @@
-import { H as HttpAdapter, S as SnsService, B as BaseClientOptions } from './sns-D0rtlsZp.js';
-export { A as AVACUS_ENDPOINTS, a as AuthState, b as AvacusEnvironment, D as DEFAULT_BASE_SIGNED_MESSAGE, R as RequestOptions, c as ResolvedClientSettings, d as SNS_SERVICE_PATH, e as SignMessageFn, f as SnsAuthClient, g as SnsAuthClientOptions, h as SnsAuthTokenPayload, i as SnsAuthenticateParams, j as SnsAvatar, k as SnsCreateUserDeviceParams, l as SnsCreateUserParams, m as SnsCreateUserPayload, n as SnsCreateUserResult, o as SnsCreateUserWithSignatureParams, p as SnsDevice, q as SnsGetNonceParams, r as SnsGetProfilesParams, s as SnsLoginParams, t as SnsLoginResult, u as SnsNonceResponse, v as SnsProfile, w as SnsServiceOptions, x as isKnownAvacusBaseUrl, y as loginWithSns, z as resolveAvacusBaseUrl, C as resolveClientSettings, E as resolveServiceUrl } from './sns-D0rtlsZp.js';
+import { H as HttpAdapter, S as SnsService, B as BaseClientOptions } from './sns-Zwan9DNM.js';
+export { A as AVACUS_ENDPOINTS, a as AuthState, b as AvacusEnvironment, c as BASE_CONNECT_SIGNED_MSG, d as BASE_GAS_SPONSOR_SIGNED_MSG, e as BASE_REDIRECT_SIGNED_MSG, D as DEFAULT_BASE_SIGNED_MESSAGE, R as RequestOptions, f as ResolvedClientSettings, g as SNS_SERVICE_PATH, h as SignMessageFn, i as SnsAuthClient, j as SnsAuthClientOptions, k as SnsAuthTokenPayload, l as SnsAuthenticateParams, m as SnsAvatar, n as SnsCreateUserDeviceParams, o as SnsCreateUserParams, p as SnsCreateUserPayload, q as SnsCreateUserResult, r as SnsCreateUserWithSignatureParams, s as SnsDevice, t as SnsGetNonceParams, u as SnsGetProfilesParams, v as SnsLoginParams, w as SnsLoginResult, x as SnsNonceResponse, y as SnsProfile, z as SnsServiceName, C as SnsServiceOptions, E as isKnownAvacusBaseUrl, F as loginWithSns, G as resolveAvacusBaseUrl, I as resolveClientSettings, J as resolveServiceUrl } from './sns-Zwan9DNM.js';
 
 declare class BalancerService {
     private readonly http;
     constructor(http: HttpAdapter);
+    /**
+     * Returns the list of balancer pools.
+     *
+     * @example
+     * ```ts
+     * const pools = await client.balancer.getPools();
+     * ```
+     */
     getPools(): Promise<unknown>;
 }
 
+type GasAccountTransactionType = 'DEPOSIT' | 'WITHDRAW' | 'USAGE' | 'TRANSFER_SPONSOR' | 'PAYMASTER_PAYMENT';
+type GasAccountTransactionStatus = 'PENDING' | 'CONFIRMED' | 'CANCELLED' | 'FAILED';
+type SponsorType = 'ADMIN' | 'USER';
+interface ApiEnvelope<TData> {
+    status: boolean;
+    data: TData;
+    code: number;
+}
+interface ApiEnvelopeWithMeta<TData, TMeta> extends ApiEnvelope<TData> {
+    meta: TMeta;
+}
+interface StableTokenImage {
+    thumb: string;
+    small: string;
+    large: string;
+}
+interface StableToken {
+    id: string;
+    chainId: number;
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    image: StableTokenImage;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+type StableTokenListResult = ApiEnvelope<StableToken[]>;
+interface GasAccountEntity {
+    id: string;
+    address: string;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface PendingBreakdown {
+    deposit: string;
+    withdraw: string;
+    usage: string;
+    transferSponsor: string;
+}
+interface PendingTotals extends PendingBreakdown {
+    total: string;
+}
+interface ComputedBalance {
+    effectiveBalance: string;
+    projectedBalance: string;
+}
+interface GasAccountBalanceSnapshot {
+    availableBalance: string;
+    totalDeposited: string;
+    totalWithdrawn: string;
+    totalUsed: string;
+    totalTransferSponsor: string;
+    pending: PendingTotals;
+    computed: ComputedBalance;
+    lastUpdatedAt: string;
+}
+type GetMultipleBalancesParams = {
+    addresses: string[];
+};
+type GetMultipleBalancesResult = ApiEnvelope<Record<string, GasAccountBalanceSnapshot>>;
+interface PendingTransactions {
+    deposits: unknown[];
+    withdraws: unknown[];
+    usages: unknown[];
+    transactions: unknown[];
+}
+interface NetworkRef {
+    chainId: number;
+    name?: string;
+    nodeUrls?: string[];
+    nodeUrl?: string | null;
+    isActive?: boolean;
+    blockTime?: number;
+    nativeCurrency?: string;
+    explorerUrl?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface GasAccountTransaction {
+    id: string;
+    gasAccountId: string;
+    transactionType: GasAccountTransactionType;
+    amount: string;
+    chainId: number;
+    toAddress: string;
+    txHash: string | null;
+    status: GasAccountTransactionStatus;
+    blockNumber?: number | null;
+    confirmations?: number;
+    logIndex?: number | null;
+    notes?: string | null;
+    actor?: string | null;
+    tokenAddress?: string | null;
+    details?: unknown;
+    parentId?: string | null;
+    sponsorType?: SponsorType | null;
+    sponsorGasAccountId?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    network?: NetworkRef;
+    gasAccount?: GasAccountEntity;
+    sponsorshipMetadata?: unknown;
+}
+interface GasAccountSummaryData {
+    account: GasAccountEntity;
+    balance: {
+        totalDeposited: string;
+        totalWithdrawn: string;
+        totalUsed: string;
+        totalTransferSponsor: string;
+        availableBalance: string;
+        effectiveBalance: string;
+        projectedBalance: string;
+        totalPending: string;
+        pendingBreakdown: PendingBreakdown;
+    };
+    recentTransactions: GasAccountTransaction[];
+    pendingTransactions: PendingTransactions;
+    summary: {
+        totalTransactions: number;
+        pendingCount: number;
+        hasBalance: boolean;
+    };
+}
+type GasAccountSummaryResult = ApiEnvelope<GasAccountSummaryData>;
+interface GasAccountWhitelistEntry {
+    address: string;
+    expiresAt: string | null;
+}
+interface GasAccountWhitelistData {
+    whitelist: GasAccountWhitelistEntry[];
+    nonce: number;
+}
+type GasAccountWhitelistResult = ApiEnvelope<GasAccountWhitelistData>;
+interface RegisterWhitelistSpenderEntry {
+    address: string;
+    expiresAt: number;
+}
+interface RegisterWhitelistSpendersParams {
+    spenders: RegisterWhitelistSpenderEntry[];
+    signature: string;
+    nonce: number;
+    deadline: number;
+}
+interface RegisterWhitelistSpendersTypedDataDomain {
+    name: 'AvacusGasAccount';
+    version: string;
+}
+interface RegisterWhitelistSpendersTypedDataMessage {
+    owner: string;
+    spenders: RegisterWhitelistSpenderEntry[];
+    nonce: number;
+    deadline: number;
+}
+interface RegisterWhitelistSpendersTypedData {
+    domain: RegisterWhitelistSpendersTypedDataDomain;
+    types: {
+        SpenderEntry: readonly [
+            {
+                name: 'address';
+                type: 'address';
+            },
+            {
+                name: 'expiresAt';
+                type: 'uint256';
+            }
+        ];
+        RegisterSpenders: readonly [
+            {
+                name: 'owner';
+                type: 'address';
+            },
+            {
+                name: 'spenders';
+                type: 'SpenderEntry[]';
+            },
+            {
+                name: 'nonce';
+                type: 'uint256';
+            },
+            {
+                name: 'deadline';
+                type: 'uint256';
+            }
+        ];
+    };
+    primaryType: 'RegisterSpenders';
+    message: RegisterWhitelistSpendersTypedDataMessage;
+}
+type SignRegisterWhitelistSpendersTypedDataFn = (typedData: RegisterWhitelistSpendersTypedData) => Promise<string>;
+interface RegisterWhitelistSpendersWithSignatureParams {
+    owner: string;
+    spenders: RegisterWhitelistSpenderEntry[];
+    version?: string;
+    deadline?: number;
+    signTypedData: SignRegisterWhitelistSpendersTypedDataFn;
+}
+interface EthersLikeTypedDataSigner {
+    signTypedData(domain: RegisterWhitelistSpendersTypedData['domain'], types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>, value: RegisterWhitelistSpendersTypedData['message']): Promise<string>;
+}
+interface RegisterWhitelistSpendersWithEthersParams {
+    owner: string;
+    spenders: RegisterWhitelistSpenderEntry[];
+    version?: string;
+    deadline?: number;
+    signer: EthersLikeTypedDataSigner;
+}
+interface BuildRegisterWhitelistSpendersTypedDataParams {
+    owner: string;
+    spenders: RegisterWhitelistSpenderEntry[];
+    version?: string;
+    nonce: number;
+    deadline: number;
+}
+interface RegisterWhitelistSpendersData extends GasAccountWhitelistData {
+    upserted: string[];
+}
+type RegisterWhitelistSpendersResult = ApiEnvelope<RegisterWhitelistSpendersData>;
+interface RemoveWhitelistSpendersParams {
+    spenders: string[];
+}
+interface RemoveWhitelistSpendersData {
+    removed: string[];
+    whitelist: GasAccountWhitelistEntry[];
+}
+type RemoveWhitelistSpendersResult = ApiEnvelope<RemoveWhitelistSpendersData>;
+type GasAccountBalanceResult = ApiEnvelope<GasAccountBalanceSnapshot>;
+interface GasAccountBalanceDetailedSnapshot extends GasAccountBalanceSnapshot {
+    pendingTransactions: PendingTransactions;
+}
+type GasAccountBalanceDetailedResult = ApiEnvelope<GasAccountBalanceDetailedSnapshot>;
+interface GasAccountBalanceStatsData {
+    address: string;
+    stats: {
+        totalDeposited: string;
+        totalWithdrawn: string;
+        totalUsed: string;
+        totalTransferSponsor: string;
+        availableBalance: string;
+        effectiveBalance: string;
+        projectedBalance: string;
+        totalPending: string;
+        pendingBreakdown: PendingBreakdown;
+    };
+    timestamp: string;
+}
+type GasAccountBalanceStatsResult = ApiEnvelope<GasAccountBalanceStatsData>;
+interface GasAccountTransactionListParams {
+    page?: number;
+    per?: number;
+    type?: Exclude<GasAccountTransactionType, 'PAYMASTER_PAYMENT'>;
+    status?: GasAccountTransactionStatus;
+}
+interface GasAccountTransactionListData {
+    address: string;
+    transactions: GasAccountTransaction[];
+    filters: {
+        type: GasAccountTransactionListParams['type'] | null;
+        status: GasAccountTransactionStatus | null;
+    };
+}
+interface PaginationMeta {
+    current_page: number;
+    next_page: number | null;
+    prev_page: number | null;
+    total_pages: number;
+    total_count: number;
+}
+type GasAccountTransactionListResult = ApiEnvelopeWithMeta<GasAccountTransactionListData, PaginationMeta>;
+interface GasAccountTransactionDetailData {
+    address: string;
+    transaction: GasAccountTransaction;
+    timestamp: string;
+}
+type GasAccountTransactionDetailResult = ApiEnvelope<GasAccountTransactionDetailData>;
+interface CreateDepositParams {
+    chainId: number;
+    amount: string;
+    tokenAddress: string;
+    txHash: string;
+    actor: string;
+    notes?: string;
+}
+interface CreateDepositData {
+    transaction: GasAccountTransaction;
+    timestamp: string;
+}
+type CreateDepositResult = ApiEnvelope<CreateDepositData>;
+interface UseBalanceParams {
+    toAddress: string;
+    chainId: number;
+    gasLimit: number;
+    gasPrice?: number;
+    maxFeePerGas?: number;
+    maxPriorityFeePerGas?: number;
+    notes?: string;
+    sourceAddress?: string;
+}
+interface UseBalanceData {
+    transaction: GasAccountTransaction;
+    balance: {
+        availableBalance: string;
+        effectiveBalance: string;
+        projectedBalance: string;
+        pendingUsage: string;
+    };
+    message: string;
+    timestamp: string;
+}
+type UseBalanceResult = ApiEnvelope<UseBalanceData>;
+interface SponsoredTransferAuthorization {
+    tokenAddress: string;
+    from: string;
+    to: string;
+    value: string;
+    validBefore: number;
+    validAfter: number;
+    nonce: string;
+    signature: string;
+}
+interface SponsoredTransferParams {
+    transactions: SponsoredTransferAuthorization[];
+    chainId: number;
+    type: SponsorType;
+    sponsorGasAccountId?: string;
+    notes?: string;
+}
+interface SponsoredTransferData {
+    transaction: GasAccountTransaction;
+    timestamp: string;
+}
+type SponsoredTransferResult = ApiEnvelope<SponsoredTransferData>;
+interface CancelGasAccountTransactionData {
+    transaction: GasAccountTransaction;
+    timestamp: string;
+}
+type CancelGasAccountTransactionResult = ApiEnvelope<CancelGasAccountTransactionData>;
+interface CreateFundingRequestParams {
+    sourceAddress: string;
+    toAddress: string;
+    chainId: number;
+    gasLimit: number;
+    gasPrice?: number;
+    maxFeePerGas?: number;
+    maxPriorityFeePerGas?: number;
+    notes?: string;
+}
+type CreateFundingRequestResult = ApiEnvelope<UseBalanceData>;
+
 /**
  * Base path for gas-account endpoints. The client resolves this path against the
  * selected environment host before creating the service adapter.
  */
 declare const GAS_ACCOUNT_SERVICE_PATH = "1/gas-account/";
+declare const DEFAULT_REGISTER_WHITELIST_SPENDERS_VERSION = "1";
 declare class GasAccountService {
     private readonly http;
     /**
@@ -23,13 +387,305 @@ declare class GasAccountService {
     /**
      * Returns the deposit vault address mapping keyed by chain ID.
      * Requires a JWT token from a successful SNS login.
+     *
+     * @example
+     * ```ts
+     * await client.sns.login({
+     *   walletAddress,
+     *   signMessage,
+     * });
+     *
+     * const vaults = await client.gasAccount.getDepositVaults();
+     * ```
      */
-    getDepositVaults(): Promise<unknown>;
+    getDepositVaults(): Promise<Record<string, string>>;
     /**
-     * Returns the authenticated gas-account service status payload.
-     * Requires a JWT token from a successful SNS login.
+     * Returns the authenticated user's gas account summary, including balances,
+     * recent transactions, and pending transactions.
+     *
+     * @example
+     * ```ts
+     * const summary = await client.gasAccount.getSummary();
+     * ```
+     */
+    getSummary(): Promise<GasAccountSummaryResult>;
+    /**
+     * Returns supported stable tokens, optionally filtered by chain ID.
+     *
+     * @param chainId Optional network chain ID used to filter supported tokens.
+      *
+      * @example
+      * ```ts
+      * const tokens = await client.gasAccount.getStableTokens();
+      * const bscTestnetTokens = await client.gasAccount.getStableTokens(97);
+      * ```
+     */
+    getStableTokens(chainId?: number): Promise<StableTokenListResult>;
+    /**
+     * Returns the authenticated user's current whitelist spender entries and nonce.
+      *
+      * @example
+      * ```ts
+      * const whitelist = await client.gasAccount.getWhitelistSpenders();
+      * ```
+     */
+    getWhitelistSpenders(): Promise<GasAccountWhitelistResult>;
+    /**
+     * Adds or updates whitelist spender entries using a signed EIP-712 payload.
+     *
+     * @param params Spenders, signature, nonce, and deadline for registration.
+      *
+      * @example
+      * ```ts
+      * const { data } = await client.gasAccount.getWhitelistSpenders();
+      * const typedData = client.gasAccount.buildRegisterWhitelistSpendersTypedData({
+      *   owner: wallet.address,
+      *   spenders,
+      *   nonce: data.nonce,
+      *   deadline: Math.floor(Date.now() / 1000) + 600,
+      * });
+      *
+      * const signature = await wallet.signTypedData(
+      *   typedData.domain,
+      *   typedData.types,
+      *   typedData.message,
+      * );
+      *
+      * await client.gasAccount.registerWhitelistSpenders({
+      *   spenders,
+      *   nonce: data.nonce,
+      *   deadline: typedData.message.deadline,
+      *   signature,
+      * });
+      * ```
+     */
+    registerWhitelistSpenders(params: RegisterWhitelistSpendersParams): Promise<RegisterWhitelistSpendersResult>;
+    /**
+     * Convenience helper that fetches the current whitelist nonce, builds the
+     * typed-data payload, asks the caller to sign it, and submits the request.
+     *
+     * @param params Owner address, spender entries, optional deadline, and a typed-data signer.
+      *
+      * @example
+      * ```ts
+      * await client.gasAccount.registerWhitelistSpendersWithSignature({
+      *   owner: wallet.address,
+      *   spenders,
+      *   signTypedData: (typedData) =>
+      *     wallet.signTypedData(
+      *       typedData.domain,
+      *       typedData.types,
+      *       typedData.message,
+      *     ),
+      * });
+      * ```
+     */
+    registerWhitelistSpendersWithSignature(params: RegisterWhitelistSpendersWithSignatureParams): Promise<RegisterWhitelistSpendersResult>;
+    /**
+     * Convenience helper for ethers-compatible signers.
+     *
+     * @param params Owner address, spender entries, optional domain version/deadline, and an ethers-compatible signer.
+     *
+     * @example
+     * ```ts
+     * await client.gasAccount.registerWhitelistSpendersWithEthers({
+     *   owner: wallet.address,
+     *   spenders,
+     *   signer: wallet,
+     * });
+     * ```
+     */
+    registerWhitelistSpendersWithEthers(params: RegisterWhitelistSpendersWithEthersParams): Promise<RegisterWhitelistSpendersResult>;
+    /**
+     * Builds the EIP-712 typed-data payload required by whitelist registration.
+     *
+     * @param params Owner, spenders, nonce, and deadline used in the signature payload.
+      *
+      * @example
+      * ```ts
+      * const typedData = client.gasAccount.buildRegisterWhitelistSpendersTypedData({
+      *   owner: wallet.address,
+      *   spenders,
+      *   nonce: 0,
+      *   deadline: Math.floor(Date.now() / 1000) + 600,
+      * });
+      * ```
+     */
+    buildRegisterWhitelistSpendersTypedData(params: BuildRegisterWhitelistSpendersTypedDataParams): RegisterWhitelistSpendersTypedData;
+    /**
+     * Removes one or more whitelist spender addresses from the authenticated account.
+     *
+     * @param params Spender addresses to revoke.
+      *
+      * @example
+      * ```ts
+      * await client.gasAccount.removeWhitelistSpenders({
+      *   spenders: ['0x9876543210987654321098765432109876543210'],
+      * });
+      * ```
+     */
+    removeWhitelistSpenders(params: RemoveWhitelistSpendersParams): Promise<RemoveWhitelistSpendersResult>;
+    /**
+     * Returns the authenticated user's balance summary.
+      *
+      * @example
+      * ```ts
+      * const balance = await client.gasAccount.getBalance();
+      * ```
+     */
+    getBalance(): Promise<GasAccountBalanceResult>;
+    /**
+     * Returns the authenticated user's balance summary with pending transaction lists.
+      *
+      * @example
+      * ```ts
+      * const detailedBalance = await client.gasAccount.getDetailedBalance();
+      * ```
+     */
+    getDetailedBalance(): Promise<GasAccountBalanceDetailedResult>;
+    /**
+     * Returns balance statistics for the authenticated user's gas account.
+      *
+      * @example
+      * ```ts
+      * const stats = await client.gasAccount.getBalanceStats();
+      * ```
+     */
+    getBalanceStats(): Promise<GasAccountBalanceStatsResult>;
+    /**
+     * Returns balances for a batch of addresses through the public balances endpoint.
+     *
+     * @param params Address batch to query.
+      *
+      * @example
+      * ```ts
+      * const balances = await client.gasAccount.getBalances({
+      *   addresses: [
+      *     '0x3a0430580303f4De9C5320aC013f14cd92192bfA',
+      *     '0x610b463d2f57d2e0d9e785a7ff423fbae36f0624',
+      *   ],
+      * });
+      * ```
+     */
+    getBalances(params: GetMultipleBalancesParams): Promise<GetMultipleBalancesResult>;
+    /**
+     * Returns a paginated transaction list for the authenticated user's gas account.
+     *
+     * @param params Optional pagination and filter parameters.
+      *
+      * @example
+      * ```ts
+      * const transactions = await client.gasAccount.listTransactions({
+      *   page: 1,
+      *   per: 10,
+      *   type: 'DEPOSIT',
+      *   status: 'CONFIRMED',
+      * });
+      * ```
+     */
+    listTransactions(params?: GasAccountTransactionListParams): Promise<GasAccountTransactionListResult>;
+    /**
+     * Returns detailed data for a specific transaction ID.
+     *
+     * @param transactionId Transaction UUID.
+      *
+      * @example
+      * ```ts
+      * const transaction = await client.gasAccount.getTransactionById(transactionId);
+      * ```
+     */
+    getTransactionById(transactionId: string): Promise<GasAccountTransactionDetailResult>;
+    /**
+     * Creates a pending deposit transaction for the authenticated user.
+     *
+     * @param params Deposit payload.
+      *
+      * @example
+      * ```ts
+      * await client.gasAccount.createDeposit({
+      *   chainId: 97,
+      *   amount: '100.00000000',
+      *   tokenAddress: '0x5bF5121A17e3329D07Ba43f758dEC271D9105132',
+      *   txHash: '0xe3844e7bc420b2d409058e6bf5534fdba69b917907d691abf65862654df749d7',
+      *   actor: walletAddress,
+      *   notes: 'Deposit from wallet',
+      * });
+      * ```
+     */
+    createDeposit(params: CreateDepositParams): Promise<CreateDepositResult>;
+    /**
+     * Creates a gas-usage request against the caller's balance or a whitelisted source address.
+     *
+     * @param params Usage request payload.
+      *
+      * @example
+      * ```ts
+      * await client.gasAccount.useBalance({
+      *   toAddress: '0x9876543210987654321098765432109876543210',
+      *   chainId: 97,
+      *   gasLimit: 21000,
+      *   gasPrice: 5,
+      *   notes: 'Gas for token transfer',
+      * });
+      * ```
+     */
+    useBalance(params: UseBalanceParams): Promise<UseBalanceResult>;
+    /**
+     * Creates a sponsored transfer request.
+     *
+     * @param params Sponsored transfer payload.
+      *
+      * @example
+      * ```ts
+      * await client.gasAccount.createSponsoredTransfer({
+      *   transactions: [
+      *     {
+      *       tokenAddress: '0x409E7b65eF7B243529e3F97be2A122123c55DE63',
+      *       from: '0x1234567890123456789012345678901234567890',
+      *       to: '0x9876543210987654321098765432109876543210',
+      *       value: '1000000000000000000',
+      *       validBefore: 1735689600,
+      *       validAfter: 0,
+      *       nonce: '0x0000000000000000000000000000000000000000000000000000000000000001',
+      *       signature: '0x...',
+      *     },
+      *   ],
+      *   chainId: 97,
+      *   type: 'ADMIN',
+      *   notes: 'JPYC transfer sponsorship',
+      * });
+      * ```
+     */
+    createSponsoredTransfer(params: SponsoredTransferParams): Promise<SponsoredTransferResult>;
+    /**
+     * Cancels a pending gas-account transaction that has not yet been broadcast.
+     *
+     * @param transactionId Transaction UUID.
+      *
+      * @example
+      * ```ts
+      * await client.gasAccount.cancelTransaction(transactionId);
+      * ```
+     */
+    cancelTransaction(transactionId: string): Promise<CancelGasAccountTransactionResult>;
+    /**
+     * Creates an internal funding request on behalf of another service.
+     *
+     * @param params Funding request payload.
+      *
+      * @example
+      * ```ts
+      * await client.gasAccount.createFundingRequest({
+      *   sourceAddress: '0x610b463d2f57d2e0d9e785a7ff423fbae36f0624',
+      *   toAddress: '0x9876543210987654321098765432109876543210',
+      *   chainId: 97,
+      *   gasLimit: 21000,
+      *   gasPrice: 5,
+      *   notes: 'Gas for token transfer',
+      * });
+      * ```
      */
-    getStatus(): Promise<unknown>;
+    createFundingRequest(params: CreateFundingRequestParams): Promise<CreateFundingRequestResult>;
 }
 
 interface AvacusClientOptions extends BaseClientOptions {
@@ -50,4 +706,4 @@ declare class AvacusClient {
     constructor(options?: AvacusClientOptions);
 }
 
-export { AvacusClient, type AvacusClientOptions, BalancerService, BaseClientOptions, GAS_ACCOUNT_SERVICE_PATH, GasAccountService, HttpAdapter, SnsService };
+export { type ApiEnvelope, type ApiEnvelopeWithMeta, AvacusClient, type AvacusClientOptions, BalancerService, BaseClientOptions, type BuildRegisterWhitelistSpendersTypedDataParams, type CancelGasAccountTransactionData, type CancelGasAccountTransactionResult, type ComputedBalance, type CreateDepositData, type CreateDepositParams, type CreateDepositResult, type CreateFundingRequestParams, type CreateFundingRequestResult, DEFAULT_REGISTER_WHITELIST_SPENDERS_VERSION, type EthersLikeTypedDataSigner, GAS_ACCOUNT_SERVICE_PATH, type GasAccountBalanceDetailedResult, type GasAccountBalanceDetailedSnapshot, type GasAccountBalanceResult, type GasAccountBalanceSnapshot, type GasAccountBalanceStatsData, type GasAccountBalanceStatsResult, type GasAccountEntity, GasAccountService, type GasAccountSummaryData, type GasAccountSummaryResult, type GasAccountTransaction, type GasAccountTransactionDetailData, type GasAccountTransactionDetailResult, type GasAccountTransactionListData, type GasAccountTransactionListParams, type GasAccountTransactionListResult, type GasAccountTransactionStatus, type GasAccountTransactionType, type GasAccountWhitelistData, type GasAccountWhitelistEntry, type GasAccountWhitelistResult, type GetMultipleBalancesParams, type GetMultipleBalancesResult, HttpAdapter, type NetworkRef, type PaginationMeta, type PendingBreakdown, type PendingTotals, type PendingTransactions, type RegisterWhitelistSpenderEntry, type RegisterWhitelistSpendersData, type RegisterWhitelistSpendersParams, type RegisterWhitelistSpendersResult, type RegisterWhitelistSpendersTypedData, type RegisterWhitelistSpendersTypedDataDomain, type RegisterWhitelistSpendersTypedDataMessage, type RegisterWhitelistSpendersWithEthersParams, type RegisterWhitelistSpendersWithSignatureParams, type RemoveWhitelistSpendersData, type RemoveWhitelistSpendersParams, type RemoveWhitelistSpendersResult, type SignRegisterWhitelistSpendersTypedDataFn, SnsService, type SponsorType, type SponsoredTransferAuthorization, type SponsoredTransferData, type SponsoredTransferParams, type SponsoredTransferResult, type StableToken, type StableTokenImage, type StableTokenListResult, type UseBalanceData, type UseBalanceParams, type UseBalanceResult };