@fystack/sdk 0.1.7 → 0.1.9

package/dist/types/index.d.ts

@@ -22,6 +22,8 @@ interface APIEndpoints {
     getWalletAssets: (walletId: string) => string;
     getDepositAddress: (walletId: string, addressType: string) => string;
     rescanTransaction: () => string;
+    requestWithdrawal: (walletId: string) => string;
+    getWebhookPublicKey: (workspaceId: string) => string;
 }
 interface APIConfig {
     baseURL: string;
@@ -319,6 +321,15 @@ declare enum WalletRole {
     Signer = "wallet_signer",
     Viewer = "wallet_viewer"
 }
+declare enum WithdrawalStatus {
+    Pending = "pending",
+    PendingApproval = "pending_approval",
+    Approved = "approved",
+    Rejected = "rejected",
+    Processing = "processing",
+    Completed = "completed",
+    Failed = "failed"
+}
 
 interface APIResponse {
     data: any;
@@ -361,9 +372,9 @@ declare class APIService {
     constructor(credentials: APICredentials, environment: Environment);
     getWallets(workspaceId: string): Promise<WalletByWorkspaceResponse[]>;
     getWalletDetail(addressType?: AddressType, walletId?: string): Promise<WalletDetail>;
-    requestSign(walletId: string, params: SignRequestParams): Promise<SignResponse>;
+    requestSign(walletId: string, params: SignRequestParams, options?: Record<string, string>): Promise<SignResponse>;
     getSignStatus(walletId: string, transactionId: string): Promise<SignatureStatusResponse>;
-    signTransaction(walletId: string, body: Record<string, any>): Promise<SignResponse>;
+    signTransaction(walletId: string, body: Record<string, any>, options?: Record<string, string>): Promise<SignResponse>;
     getTransactionStatus(walletId: string, transactionId: string): Promise<TransactionStatusResponse>;
     createWallet(payload: CreateWalletPayload): Promise<CreateWalletResponse>;
     createCheckout(payload: CreateCheckoutPayload): Promise<CreateCheckoutResponse>;
@@ -382,6 +393,19 @@ declare class APIService {
      * @returns API response
      */
     rescanTransaction(params: RescanTransactionParams): Promise<void>;
+    /**
+     * Requests a withdrawal from a wallet
+     * @param walletId The wallet ID
+     * @param params Withdrawal parameters
+     * @returns Withdrawal response with auto_approved status and withdrawal details
+     */
+    requestWithdrawal(walletId: string, params: RequestWithdrawalParams): Promise<RequestWithdrawalResponse>;
+    /**
+     * Gets the webhook public key for a workspace
+     * @param workspaceId The workspace ID
+     * @returns Webhook public key response with base64 encoded ed25519 public key
+     */
+    getWebhookPublicKey(workspaceId: string): Promise<WebhookPublicKeyResponse>;
 }
 declare class PaymentService {
     private apiKey;
@@ -415,6 +439,13 @@ declare function transformRescanTransactionParams(data: RescanTransactionParams)
     tx_hash: string;
     network_id: string;
 };
+declare function transformRequestWithdrawalParams(data: RequestWithdrawalParams): {
+    skip_balance_check?: boolean | undefined;
+    notes?: string | undefined;
+    asset_id: string;
+    amount: string;
+    recipient_address: string;
+};
 
 declare class TransactionError extends Error {
     readonly code: string;
@@ -555,6 +586,57 @@ interface WalletByWorkspaceResponse {
     top_assets: TopAssets[];
     wallet_purpose: string;
 }
+interface RequestWithdrawalParams {
+    assetId: string;
+    amount: string;
+    recipientAddress: string;
+    notes?: string;
+    skipBalanceCheck?: boolean;
+}
+interface WithdrawalApproval {
+    id: string;
+    user_id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+}
+interface WithdrawalTransaction {
+    id: string;
+    hash?: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+}
+interface TxCategory {
+    id: string;
+    name: string;
+}
+interface Withdrawal {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    amount: string;
+    status: WithdrawalStatus;
+    recipient_address: string;
+    notes?: string;
+    withdrawal_approvals: WithdrawalApproval[];
+    creator_id: string;
+    asset_id: string;
+    asset?: WalletAssetDetail;
+    wallet_id: string;
+    transaction_id?: string;
+    transaction?: WithdrawalTransaction;
+    asset_hold_id: string;
+    error_reason?: string;
+    categories?: TxCategory[];
+}
+interface RequestWithdrawalResponse {
+    auto_approved: boolean;
+    withdrawal: Withdrawal;
+}
+interface WebhookPublicKeyResponse {
+    public_key: string;
+}
 
 interface SDKOptions {
     credentials: APICredentials;
@@ -611,6 +693,19 @@ declare class FystackSDK {
      * @returns Promise that resolves when the rescan is initiated
      */
     rescanTransaction(params: RescanTransactionParams): Promise<void>;
+    /**
+     * Requests a withdrawal from a wallet
+     * @param walletId The ID of the wallet to withdraw from
+     * @param params Withdrawal parameters including asset, amount, and recipient
+     * @returns Promise with withdrawal response including auto_approved status and withdrawal details
+     */
+    requestWithdrawal(walletId: string, params: RequestWithdrawalParams): Promise<RequestWithdrawalResponse>;
+    /**
+     * Gets the webhook public key for a workspace
+     * @param workspaceId The workspace ID
+     * @returns Promise with webhook public key (base64 encoded ed25519 public key)
+     */
+    getWebhookPublicKey(workspaceId: string): Promise<WebhookPublicKeyResponse>;
 }
 
 interface StatusPollerOptions {
@@ -646,10 +741,18 @@ declare class EtherSigner extends AbstractSigner {
     connect(provider: null | Provider): EtherSigner;
     private waitForSignature;
     private waitForTransactonStatus;
-    signTransaction(tx: TransactionRequest): Promise<string>;
-    sendTransaction(tx: TransactionRequest): Promise<TransactionResponse>;
-    signMessage(message: string | Uint8Array): Promise<string>;
-    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
+    signTransaction(tx: TransactionRequest, options?: {
+        idempotencyKey?: string;
+    }): Promise<string>;
+    sendTransaction(tx: TransactionRequest, options?: {
+        idempotencyKey?: string;
+    }): Promise<TransactionResponse>;
+    signMessage(message: string | Uint8Array, options?: {
+        idempotencyKey?: string;
+    }): Promise<string>;
+    signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>, options?: {
+        idempotencyKey?: string;
+    }): Promise<string>;
 }
 
 declare class SolanaSigner {
@@ -668,28 +771,36 @@ declare class SolanaSigner {
      * @param transaction Base64 encoded serialized transaction
      * @returns Signature as a base58 encoded string
      */
-    signTransaction(transaction: string): Promise<string>;
+    signTransaction(transaction: string, options?: {
+        idempotencyKey?: string;
+    }): Promise<string>;
     /**
      * Signs a Solana message
      * @param message The message to sign (string or Uint8Array)
      * @returns Signature as a base58 encoded string
      */
-    signMessage(message: string | Uint8Array): Promise<string>;
+    signMessage(message: string | Uint8Array, options?: {
+        idempotencyKey?: string;
+    }): Promise<string>;
     /**
      * Signs and sends a Solana transaction
      * @param transaction Base64 encoded serialized transaction
      * @returns Transaction signature
      */
-    signAndSendTransaction(transaction: string): Promise<string>;
+    signAndSendTransaction(transaction: string, options?: {
+        idempotencyKey?: string;
+    }): Promise<string>;
     /**
      * Signs multiple Solana transactions
      * @param transactions Array of base64 encoded serialized transactions
      * @returns Array of signatures as base58 encoded strings
      */
-    signAllTransactions(transactions: string[]): Promise<{
+    signAllTransactions(transactions: string[], options?: {
+        idempotencyKey?: string;
+    }): Promise<{
         transactions: string[];
     }>;
     private incorporateSignatureIntoTransaction;
 }
 
-export { type APIConfig, type APICredentials, type APIEndpoints, APIService, AddressType, type ApprovalInfo, type CreateWalletOptions, type CreateWalletPayload, type CreateWalletResponse, DEFAULT_POLLER_OPTIONS, type DepositAddressResponse, DestinationType, Environment, EtherSigner, FystackSDK, type HMACParams, PaymentService, type PaymentServiceParams, type RescanTransactionParams, type SDKOptions, type SignRequestParams, type SignResponse, type SignatureStatusResponse, SolanaSigner, StatusPoller, type StatusPollerOptions, type SweepTaskParams, type TopAssets, TransactionError, type TransactionStatusResponse, TxApprovalStatus, TxStatus, type WalletAsset, type WalletAssetDetail, type WalletAssetNetwork, type WalletByWorkspaceResponse, WalletCreationStatus, type WalletCreationStatusResponse, type WalletDetail, WalletPurpose, type WalletResponse, WalletRole, WalletType, type WebhookEvent, WebhookService, createAPI, get, post, transformCreateWalletPayload, transformRescanTransactionParams, transformWalletDetail };
+export { type APIConfig, type APICredentials, type APIEndpoints, APIService, AddressType, type ApprovalInfo, type CreateWalletOptions, type CreateWalletPayload, type CreateWalletResponse, DEFAULT_POLLER_OPTIONS, type DepositAddressResponse, DestinationType, Environment, EtherSigner, FystackSDK, type HMACParams, PaymentService, type PaymentServiceParams, type RequestWithdrawalParams, type RequestWithdrawalResponse, type RescanTransactionParams, type SDKOptions, type SignRequestParams, type SignResponse, type SignatureStatusResponse, SolanaSigner, StatusPoller, type StatusPollerOptions, type SweepTaskParams, type TopAssets, TransactionError, type TransactionStatusResponse, TxApprovalStatus, type TxCategory, TxStatus, type WalletAsset, type WalletAssetDetail, type WalletAssetNetwork, type WalletByWorkspaceResponse, WalletCreationStatus, type WalletCreationStatusResponse, type WalletDetail, WalletPurpose, type WalletResponse, WalletRole, WalletType, type WebhookEvent, type WebhookPublicKeyResponse, WebhookService, type Withdrawal, type WithdrawalApproval, WithdrawalStatus, type WithdrawalTransaction, createAPI, get, post, transformCreateWalletPayload, transformRequestWithdrawalParams, transformRescanTransactionParams, transformWalletDetail };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fystack/sdk",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Wallet SDK",
   "main": "dist/index.cjs",
   "types": "dist/types/index.d.ts",

package/src/api.ts

@@ -13,7 +13,10 @@ import {
   WalletAsset,
   DepositAddressResponse,
   RescanTransactionParams,
-  WalletByWorkspaceResponse
+  WalletByWorkspaceResponse,
+  RequestWithdrawalParams,
+  RequestWithdrawalResponse,
+  WebhookPublicKeyResponse
 } from './types'
 import {
   CreateCheckoutPayload,
@@ -69,7 +72,8 @@ async function composeAPIHeaders(
   credentials: APICredentials,
   httpMethod: string,
   apiEndpoint: string,
-  body: Record<string, any> = {}
+  body: Record<string, any> = {},
+  headers?: Record<string, string>
 ): Promise<Record<string, string>> {
   if (!credentials.apiSecret || credentials.apiSecret === '') {
     // If APISecret is not provided, use authToken
@@ -94,13 +98,14 @@ async function composeAPIHeaders(
 
   const digest = await computeHMAC(credentials.apiSecret, params as Record<string, any>)
 
-  const headers = {
+  const combinedHeaders = {
     'ACCESS-API-KEY': credentials.apiKey,
     'ACCESS-TIMESTAMP': String(currentTimestampInSeconds),
-    'ACCESS-SIGN': btoa(digest) // convert to base64
+    'ACCESS-SIGN': btoa(digest), // convert to base64
+    ...(headers ?? {})
   }
 
-  return headers
+  return combinedHeaders
 }
 
 export class APIService {
@@ -129,9 +134,13 @@ export class APIService {
     return transformWalletDetail(resp.data)
   }
 
-  async requestSign(walletId: string, params: SignRequestParams): Promise<SignResponse> {
+  async requestSign(
+    walletId: string,
+    params: SignRequestParams,
+    options?: Record<string, string>
+  ): Promise<SignResponse> {
     const endpoint = this.API.endpoints.requestSign(walletId)
-    const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, params)
+    const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, params, options)
     const response = await post(endpoint, params, headers)
     return response.data
   }
@@ -143,10 +152,14 @@ export class APIService {
     return response.data
   }
 
-  async signTransaction(walletId: string, body: Record<string, any>): Promise<SignResponse> {
+  async signTransaction(
+    walletId: string,
+    body: Record<string, any>,
+    options?: Record<string, string>
+  ): Promise<SignResponse> {
     const startTime = Date.now()
     const endpoint = this.API.endpoints.signTransaction(walletId)
-    const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, body)
+    const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, body, options)
     const response = await post(endpoint, body, headers)
     const elapsedTime = Date.now() - startTime
 
@@ -222,6 +235,35 @@ export class APIService {
     const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, transformedParams)
     await post(endpoint, transformedParams, headers)
   }
+
+  /**
+   * Requests a withdrawal from a wallet
+   * @param walletId The wallet ID
+   * @param params Withdrawal parameters
+   * @returns Withdrawal response with auto_approved status and withdrawal details
+   */
+  async requestWithdrawal(
+    walletId: string,
+    params: RequestWithdrawalParams
+  ): Promise<RequestWithdrawalResponse> {
+    const endpoint = this.API.endpoints.requestWithdrawal(walletId)
+    const transformedParams = transformRequestWithdrawalParams(params)
+    const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, transformedParams)
+    const response = await post(endpoint, transformedParams, headers)
+    return response.data
+  }
+
+  /**
+   * Gets the webhook public key for a workspace
+   * @param workspaceId The workspace ID
+   * @returns Webhook public key response with base64 encoded ed25519 public key
+   */
+  async getWebhookPublicKey(workspaceId: string): Promise<WebhookPublicKeyResponse> {
+    const endpoint = this.API.endpoints.getWebhookPublicKey(workspaceId)
+    const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint)
+    const response = await get(endpoint, headers)
+    return response.data
+  }
 }
 
 export class PaymentService {
@@ -370,6 +412,16 @@ export function transformRescanTransactionParams(data: RescanTransactionParams)
   }
 }
 
+export function transformRequestWithdrawalParams(data: RequestWithdrawalParams) {
+  return {
+    asset_id: data.assetId,
+    amount: data.amount,
+    recipient_address: data.recipientAddress,
+    ...(data.notes !== undefined && { notes: data.notes }),
+    ...(data.skipBalanceCheck !== undefined && { skip_balance_check: data.skipBalanceCheck })
+  }
+}
+
 ;(BigInt.prototype as any).toJSON = function () {
   return this.toString()
 }

package/src/config.ts

@@ -21,6 +21,8 @@ export interface APIEndpoints {
   getWalletAssets: (walletId: string) => string
   getDepositAddress: (walletId: string, addressType: string) => string
   rescanTransaction: () => string
+  requestWithdrawal: (walletId: string) => string
+  getWebhookPublicKey: (workspaceId: string) => string
 }
 
 const getBaseURL = (env: Environment): string => {
@@ -71,7 +73,9 @@ const createAPI = (env: Environment): APIConfig => {
       getWalletAssets: (walletId: string) => withBaseURL(`/wallets/${walletId}/assets`),
       getDepositAddress: (walletId: string, addressType: string) =>
         withBaseURL(`/wallets/${walletId}/deposit-address?address_type=${addressType}`),
-      rescanTransaction: () => withBaseURL('/networks/rescan-transaction')
+      rescanTransaction: () => withBaseURL('/networks/rescan-transaction'),
+      requestWithdrawal: (walletId: string) => withBaseURL(`/wallets/${walletId}/request-withdrawal`),
+      getWebhookPublicKey: (workspaceId: string) => withBaseURL(`/workspaces/${workspaceId}/webhook-verification-key`)
     }
   }
 }

package/src/enum.ts

@@ -50,3 +50,13 @@ export enum WalletRole {
   Signer = 'wallet_signer',
   Viewer = 'wallet_viewer'
 }
+
+export enum WithdrawalStatus {
+  Pending = 'pending',
+  PendingApproval = 'pending_approval',
+  Approved = 'approved',
+  Rejected = 'rejected',
+  Processing = 'processing',
+  Completed = 'completed',
+  Failed = 'failed'
+}

package/src/sdk.ts

@@ -9,7 +9,10 @@ import {
   APICredentials,
   CreateWalletOptions,
   RescanTransactionParams,
-  WalletByWorkspaceResponse
+  WalletByWorkspaceResponse,
+  RequestWithdrawalParams,
+  RequestWithdrawalResponse,
+  WebhookPublicKeyResponse
 } from './types'
 import { validateUUID } from './utils'
 import { AddressType, WalletCreationStatus, WalletType } from './enum'
@@ -183,4 +186,53 @@ export class FystackSDK {
 
     await this.apiService.rescanTransaction(params)
   }
+
+  /**
+   * Requests a withdrawal from a wallet
+   * @param walletId The ID of the wallet to withdraw from
+   * @param params Withdrawal parameters including asset, amount, and recipient
+   * @returns Promise with withdrawal response including auto_approved status and withdrawal details
+   */
+  async requestWithdrawal(
+    walletId: string,
+    params: RequestWithdrawalParams
+  ): Promise<RequestWithdrawalResponse> {
+    validateUUID(walletId, 'walletId')
+    validateUUID(params.assetId, 'assetId')
+
+    if (!params.amount || params.amount.trim() === '') {
+      throw new Error('Invalid amount provided')
+    }
+
+    if (!params.recipientAddress || params.recipientAddress.trim() === '') {
+      throw new Error('Invalid recipient address provided')
+    }
+
+    if (params.recipientAddress.length > 256) {
+      throw new Error('Recipient address exceeds maximum length of 256 characters')
+    }
+
+    if (params.notes && params.notes.length > 500) {
+      throw new Error('Notes exceed maximum length of 500 characters')
+    }
+
+    this.log(`Requesting withdrawal from wallet ${walletId}`)
+    const response = await this.apiService.requestWithdrawal(walletId, params)
+    this.log(`Withdrawal request completed, auto_approved: ${response.auto_approved}`)
+
+    return response
+  }
+
+  /**
+   * Gets the webhook public key for a workspace
+   * @param workspaceId The workspace ID
+   * @returns Promise with webhook public key (base64 encoded ed25519 public key)
+   */
+  async getWebhookPublicKey(workspaceId: string): Promise<WebhookPublicKeyResponse> {
+    validateUUID(workspaceId, 'workspaceId')
+
+    this.log(`Getting webhook public key for workspace ${workspaceId}`)
+    const response = await this.apiService.getWebhookPublicKey(workspaceId)
+    return response
+  }
 }

package/src/signer.ts

@@ -151,7 +151,7 @@ export class EtherSigner extends AbstractSigner {
         return result.status === TxStatus.Rejected
       }
     )
-    console.log('reulst', result)
+    console.log('result', result)
 
     if (!result.hash) {
       throw new TransactionError(
@@ -165,7 +165,10 @@ export class EtherSigner extends AbstractSigner {
   }
 
   // Copied and editted from ethers.js -> Wallet -> BaseWallet
-  async signTransaction(tx: TransactionRequest): Promise<string> {
+  async signTransaction(
+    tx: TransactionRequest,
+    options?: { idempotencyKey?: string }
+  ): Promise<string> {
     const startTime = new Date()
     console.log(`[WalletSDK] Transaction started at: ${startTime.toLocaleString()}`)
 
@@ -216,7 +219,11 @@ export class EtherSigner extends AbstractSigner {
       accessList: btx.accessList
     }
     // return unseralized as API signTransaction is an asynchoronous action
-    const response = await this.APIService.signTransaction(this.walletDetail.WalletID, data)
+    const response = await this.APIService.signTransaction(
+      this.walletDetail.WalletID,
+      data,
+      options
+    )
     const txHash = await this.waitForTransactonStatus(response.transaction_id)
 
     const endTime = new Date()
@@ -230,7 +237,10 @@ export class EtherSigner extends AbstractSigner {
     return txHash
   }
 
-  async sendTransaction(tx: TransactionRequest): Promise<TransactionResponse> {
+  async sendTransaction(
+    tx: TransactionRequest,
+    options?: { idempotencyKey?: string }
+  ): Promise<TransactionResponse> {
     const startTime = new Date()
     console.log(`[WalletSDK] sendTransaction started at: ${startTime.toLocaleString()}`)
 
@@ -272,7 +282,7 @@ export class EtherSigner extends AbstractSigner {
 
     console.log('[WalletSDK] Tx Data', txObj)
 
-    const txHash = await this.signTransaction(txObj)
+    const txHash = await this.signTransaction(txObj, options)
 
     // Instead of creating a mock response, get the actual transaction from the provider
     const endTime = new Date()
@@ -341,7 +351,10 @@ export class EtherSigner extends AbstractSigner {
     return new TransactionResponse(txResponse, this.provider as Provider)
   }
 
-  async signMessage(message: string | Uint8Array): Promise<string> {
+  async signMessage(
+    message: string | Uint8Array,
+    options?: { idempotencyKey?: string }
+  ): Promise<string> {
     if (!this.provider) {
       throw new Error('Provider is required for signing operations')
     }
@@ -357,11 +370,15 @@ export class EtherSigner extends AbstractSigner {
     const chainId = await this.getChainId()
     const messageStr = typeof message === 'string' ? message : Buffer.from(message).toString('hex')
 
-    const response = await this.APIService.requestSign(this.walletDetail.WalletID, {
-      method: 'eth_sign',
-      message: messageStr,
-      chain_id: chainId
-    })
+    const response = await this.APIService.requestSign(
+      this.walletDetail.WalletID,
+      {
+        method: 'eth_sign',
+        message: messageStr,
+        chain_id: chainId
+      },
+      options
+    )
 
     return this.waitForSignature(this.walletDetail.WalletID, response.transaction_id)
   }
@@ -369,7 +386,8 @@ export class EtherSigner extends AbstractSigner {
   async signTypedData(
     domain: TypedDataDomain,
     types: Record<string, Array<TypedDataField>>,
-    value: Record<string, any>
+    value: Record<string, any>,
+    options?: { idempotencyKey?: string }
   ): Promise<string> {
     if (!this.provider) {
       throw new Error('Provider is required for signing operations')
@@ -390,12 +408,16 @@ export class EtherSigner extends AbstractSigner {
       message: value
     })
 
-    const response = await this.APIService.requestSign(this.walletDetail.WalletID, {
-      method: 'eth_signTypedData_v4',
-      message: '',
-      chain_id: chainId,
-      typed_data: typedData
-    })
+    const response = await this.APIService.requestSign(
+      this.walletDetail.WalletID,
+      {
+        method: 'eth_signTypedData_v4',
+        message: '',
+        chain_id: chainId,
+        typed_data: typedData
+      },
+      options
+    )
 
     return this.waitForSignature(this.walletDetail.WalletID, response.transaction_id)
   }

package/src/solanaSigner.ts

@@ -117,7 +117,10 @@ export class SolanaSigner {
    * @param transaction Base64 encoded serialized transaction
    * @returns Signature as a base58 encoded string
    */
-  async signTransaction(transaction: string): Promise<string> {
+  async signTransaction(
+    transaction: string,
+    options?: { idempotencyKey?: string }
+  ): Promise<string> {
     if (!this.address) {
       await this.getAddress()
     }
@@ -128,13 +131,17 @@ export class SolanaSigner {
     }
 
     // Call the signRaw API similar to EtherSigner
-    const response = await this.APIService.signTransaction(this.walletDetail.WalletID, {
-      ...data,
-      meta: {
-        tx_method: 'solana_signTransaction'
+    const response = await this.APIService.signTransaction(
+      this.walletDetail.WalletID,
+      {
+        ...data,
+        meta: {
+          tx_method: 'solana_signTransaction'
+        },
+        chainId: '1399811149'
       },
-      chainId: '1399811149'
-    })
+      options
+    )
 
     // Wait for the signature
     return this.waitForTransactionStatus(response.transaction_id)
@@ -145,7 +152,10 @@ export class SolanaSigner {
    * @param message The message to sign (string or Uint8Array)
    * @returns Signature as a base58 encoded string
    */
-  async signMessage(message: string | Uint8Array): Promise<string> {
+  async signMessage(
+    message: string | Uint8Array,
+    options?: { idempotencyKey?: string }
+  ): Promise<string> {
     if (!this.address) {
       await this.getAddress()
     }
@@ -153,11 +163,15 @@ export class SolanaSigner {
     const messageStr =
       typeof message === 'string' ? message : Buffer.from(message).toString('base64')
 
-    const response = await this.APIService.requestSign(this.walletDetail.WalletID, {
-      method: 'solana_signMessage',
-      message: messageStr,
-      chain_id: 0 // Not used for Solana but required by API
-    })
+    const response = await this.APIService.requestSign(
+      this.walletDetail.WalletID,
+      {
+        method: 'solana_signMessage',
+        message: messageStr,
+        chain_id: 0 // Not used for Solana but required by API
+      },
+      options
+    )
 
     return this.waitForTransactionStatus(response.transaction_id)
   }
@@ -167,7 +181,10 @@ export class SolanaSigner {
    * @param transaction Base64 encoded serialized transaction
    * @returns Transaction signature
    */
-  async signAndSendTransaction(transaction: string): Promise<string> {
+  async signAndSendTransaction(
+    transaction: string,
+    options?: { idempotencyKey?: string }
+  ): Promise<string> {
     if (!this.address) {
       await this.getAddress()
     }
@@ -178,7 +195,11 @@ export class SolanaSigner {
       method: 'solana_signAndSendTransaction'
     }
 
-    const response = await this.APIService.signTransaction(this.walletDetail.WalletID, data)
+    const response = await this.APIService.signTransaction(
+      this.walletDetail.WalletID,
+      data,
+      options
+    )
     const txHash = await this.waitForTransactionStatus(response.transaction_id)
     console.log('transaction succeed!')
 
@@ -190,7 +211,10 @@ export class SolanaSigner {
    * @param transactions Array of base64 encoded serialized transactions
    * @returns Array of signatures as base58 encoded strings
    */
-  async signAllTransactions(transactions: string[]): Promise<{ transactions: string[] }> {
+  async signAllTransactions(
+    transactions: string[],
+    options?: { idempotencyKey?: string }
+  ): Promise<{ transactions: string[] }> {
     if (!this.address) {
       await this.getAddress()
     }
@@ -198,7 +222,7 @@ export class SolanaSigner {
     // We need to get the signatures and then incorporate them into the transactions
     const signaturePromises = transactions.map(async (transaction) => {
       // Get the signature
-      const signature = await this.signTransaction(transaction)
+      const signature = await this.signTransaction(transaction, options)
 
       // Here you would need to incorporate the signature into the transaction
       // This is a placeholder - you'll need to implement actual signature incorporation