@fystack/sdk 0.1.7 → 0.1.8

package/dist/index.cjs

@@ -182,7 +182,7 @@ exports.WalletRole = void 0;
     WalletRole["Viewer"] = "wallet_viewer";
 })(exports.WalletRole || (exports.WalletRole = {}));
 
-async function composeAPIHeaders(credentials, httpMethod, apiEndpoint, body = {}) {
+async function composeAPIHeaders(credentials, httpMethod, apiEndpoint, body = {}, headers) {
     if (!credentials.apiSecret || credentials.apiSecret === '') {
         // If APISecret is not provided, use authToken
         if (credentials.authToken) {
@@ -204,12 +204,13 @@ async function composeAPIHeaders(credentials, httpMethod, apiEndpoint, body = {}
         body: Object.keys(body).length ? JSON.stringify(body) : ''
     };
     const digest = await computeHMAC(credentials.apiSecret, params);
-    const headers = {
+    const combinedHeaders = {
         'ACCESS-API-KEY': credentials.apiKey,
         'ACCESS-TIMESTAMP': String(currentTimestampInSeconds),
-        'ACCESS-SIGN': btoa(digest) // convert to base64
+        'ACCESS-SIGN': btoa(digest),
+        ...headers ?? {}
     };
-    return headers;
+    return combinedHeaders;
 }
 class APIService {
     async getWallets(workspaceId) {
@@ -225,9 +226,9 @@ class APIService {
         const resp = await get(endpoint + `?address_type=${addressType}`, headers);
         return transformWalletDetail(resp.data);
     }
-    async requestSign(walletId, params) {
+    async requestSign(walletId, params, options) {
         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;
     }
@@ -237,10 +238,10 @@ class APIService {
         const response = await get(endpoint, headers);
         return response.data;
     }
-    async signTransaction(walletId, body) {
+    async signTransaction(walletId, body, options) {
         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;
         console.log(`[WalletSDK] Sign transaction completed in ${elapsedTime}ms`);
@@ -677,14 +678,14 @@ class EtherSigner extends ethers.AbstractSigner {
             }
             return result.status === exports.TxStatus.Rejected;
         });
-        console.log('reulst', result);
+        console.log('result', result);
         if (!result.hash) {
             throw new TransactionError('Transaction hash not found in successful response', 'TRANSACTION_HASH_MISSING', result.transaction_id);
         }
         return result.hash;
     }
     // Copied and editted from ethers.js -> Wallet -> BaseWallet
-    async signTransaction(tx) {
+    async signTransaction(tx, options) {
         const startTime = new Date();
         console.log(`[WalletSDK] Transaction started at: ${startTime.toLocaleString()}`);
         if (!this.address) {
@@ -724,7 +725,7 @@ class EtherSigner extends ethers.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();
         const elapsedTimeMs = endTime.getTime() - startTime.getTime();
@@ -733,7 +734,7 @@ class EtherSigner extends ethers.AbstractSigner {
         console.log('[WalletSDK] Transaction succeed!');
         return txHash;
     }
-    async sendTransaction(tx) {
+    async sendTransaction(tx, options) {
         const startTime = new Date();
         console.log(`[WalletSDK] sendTransaction started at: ${startTime.toLocaleString()}`);
         if (!this.address) {
@@ -761,7 +762,7 @@ class EtherSigner extends ethers.AbstractSigner {
         const resolvedTx = await ethers.resolveProperties(populatedTx);
         const txObj = ethers.Transaction.from(resolvedTx);
         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();
         const totalElapsedMs = endTime.getTime() - startTime.getTime();
@@ -810,7 +811,7 @@ class EtherSigner extends ethers.AbstractSigner {
         // Let the provider create the TransactionResponse using the txHash
         return new ethers.TransactionResponse(txResponse, this.provider);
     }
-    async signMessage(message) {
+    async signMessage(message, options) {
         if (!this.provider) {
             throw new Error('Provider is required for signing operations');
         }
@@ -826,10 +827,10 @@ class EtherSigner extends ethers.AbstractSigner {
             method: 'eth_sign',
             message: messageStr,
             chain_id: chainId
-        });
+        }, options);
         return this.waitForSignature(this.walletDetail.WalletID, response.transaction_id);
     }
-    async signTypedData(domain, types, value) {
+    async signTypedData(domain, types, value, options) {
         if (!this.provider) {
             throw new Error('Provider is required for signing operations');
         }
@@ -850,7 +851,7 @@ class EtherSigner extends ethers.AbstractSigner {
             message: '',
             chain_id: chainId,
             typed_data: typedData
-        });
+        }, options);
         return this.waitForSignature(this.walletDetail.WalletID, response.transaction_id);
     }
     constructor(credentials, environment, provider, pollerOptions){
@@ -929,7 +930,7 @@ class SolanaSigner {
    * Signs a Solana transaction
    * @param transaction Base64 encoded serialized transaction
    * @returns Signature as a base58 encoded string
-   */ async signTransaction(transaction) {
+   */ async signTransaction(transaction, options) {
         if (!this.address) {
             await this.getAddress();
         }
@@ -944,7 +945,7 @@ class SolanaSigner {
                 tx_method: 'solana_signTransaction'
             },
             chainId: '1399811149'
-        });
+        }, options);
         // Wait for the signature
         return this.waitForTransactionStatus(response.transaction_id);
     }
@@ -952,7 +953,7 @@ class SolanaSigner {
    * Signs a Solana message
    * @param message The message to sign (string or Uint8Array)
    * @returns Signature as a base58 encoded string
-   */ async signMessage(message) {
+   */ async signMessage(message, options) {
         if (!this.address) {
             await this.getAddress();
         }
@@ -961,14 +962,14 @@ class SolanaSigner {
             method: 'solana_signMessage',
             message: messageStr,
             chain_id: 0 // Not used for Solana but required by API
-        });
+        }, options);
         return this.waitForTransactionStatus(response.transaction_id);
     }
     /**
    * Signs and sends a Solana transaction
    * @param transaction Base64 encoded serialized transaction
    * @returns Transaction signature
-   */ async signAndSendTransaction(transaction) {
+   */ async signAndSendTransaction(transaction, options) {
         if (!this.address) {
             await this.getAddress();
         }
@@ -977,7 +978,7 @@ class SolanaSigner {
             from: this.address,
             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!');
         return txHash;
@@ -986,14 +987,14 @@ class SolanaSigner {
    * Signs multiple Solana transactions
    * @param transactions Array of base64 encoded serialized transactions
    * @returns Array of signatures as base58 encoded strings
-   */ async signAllTransactions(transactions) {
+   */ async signAllTransactions(transactions, options) {
         if (!this.address) {
             await this.getAddress();
         }
         // 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
             // based on your Solana transaction structure

package/dist/index.d.cts

@@ -361,9 +361,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>;
@@ -646,10 +646,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,25 +676,33 @@ 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;

package/dist/index.d.mts

@@ -361,9 +361,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>;
@@ -646,10 +646,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,25 +676,33 @@ 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;

package/dist/index.esm.d.ts

@@ -361,9 +361,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>;
@@ -646,10 +646,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,25 +676,33 @@ 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;

package/dist/index.esm.js

@@ -174,7 +174,7 @@ var WalletRole;
     WalletRole["Viewer"] = "wallet_viewer";
 })(WalletRole || (WalletRole = {}));
 
-async function composeAPIHeaders(credentials, httpMethod, apiEndpoint, body = {}) {
+async function composeAPIHeaders(credentials, httpMethod, apiEndpoint, body = {}, headers) {
     if (!credentials.apiSecret || credentials.apiSecret === '') {
         // If APISecret is not provided, use authToken
         if (credentials.authToken) {
@@ -196,12 +196,13 @@ async function composeAPIHeaders(credentials, httpMethod, apiEndpoint, body = {}
         body: Object.keys(body).length ? JSON.stringify(body) : ''
     };
     const digest = await computeHMAC(credentials.apiSecret, params);
-    const headers = {
+    const combinedHeaders = {
         'ACCESS-API-KEY': credentials.apiKey,
         'ACCESS-TIMESTAMP': String(currentTimestampInSeconds),
-        'ACCESS-SIGN': btoa(digest) // convert to base64
+        'ACCESS-SIGN': btoa(digest),
+        ...headers ?? {}
     };
-    return headers;
+    return combinedHeaders;
 }
 class APIService {
     async getWallets(workspaceId) {
@@ -217,9 +218,9 @@ class APIService {
         const resp = await get(endpoint + `?address_type=${addressType}`, headers);
         return transformWalletDetail(resp.data);
     }
-    async requestSign(walletId, params) {
+    async requestSign(walletId, params, options) {
         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;
     }
@@ -229,10 +230,10 @@ class APIService {
         const response = await get(endpoint, headers);
         return response.data;
     }
-    async signTransaction(walletId, body) {
+    async signTransaction(walletId, body, options) {
         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;
         console.log(`[WalletSDK] Sign transaction completed in ${elapsedTime}ms`);
@@ -669,14 +670,14 @@ class EtherSigner extends AbstractSigner {
             }
             return result.status === TxStatus.Rejected;
         });
-        console.log('reulst', result);
+        console.log('result', result);
         if (!result.hash) {
             throw new TransactionError('Transaction hash not found in successful response', 'TRANSACTION_HASH_MISSING', result.transaction_id);
         }
         return result.hash;
     }
     // Copied and editted from ethers.js -> Wallet -> BaseWallet
-    async signTransaction(tx) {
+    async signTransaction(tx, options) {
         const startTime = new Date();
         console.log(`[WalletSDK] Transaction started at: ${startTime.toLocaleString()}`);
         if (!this.address) {
@@ -716,7 +717,7 @@ 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();
         const elapsedTimeMs = endTime.getTime() - startTime.getTime();
@@ -725,7 +726,7 @@ class EtherSigner extends AbstractSigner {
         console.log('[WalletSDK] Transaction succeed!');
         return txHash;
     }
-    async sendTransaction(tx) {
+    async sendTransaction(tx, options) {
         const startTime = new Date();
         console.log(`[WalletSDK] sendTransaction started at: ${startTime.toLocaleString()}`);
         if (!this.address) {
@@ -753,7 +754,7 @@ class EtherSigner extends AbstractSigner {
         const resolvedTx = await resolveProperties(populatedTx);
         const txObj = Transaction.from(resolvedTx);
         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();
         const totalElapsedMs = endTime.getTime() - startTime.getTime();
@@ -802,7 +803,7 @@ class EtherSigner extends AbstractSigner {
         // Let the provider create the TransactionResponse using the txHash
         return new TransactionResponse(txResponse, this.provider);
     }
-    async signMessage(message) {
+    async signMessage(message, options) {
         if (!this.provider) {
             throw new Error('Provider is required for signing operations');
         }
@@ -818,10 +819,10 @@ class EtherSigner extends AbstractSigner {
             method: 'eth_sign',
             message: messageStr,
             chain_id: chainId
-        });
+        }, options);
         return this.waitForSignature(this.walletDetail.WalletID, response.transaction_id);
     }
-    async signTypedData(domain, types, value) {
+    async signTypedData(domain, types, value, options) {
         if (!this.provider) {
             throw new Error('Provider is required for signing operations');
         }
@@ -842,7 +843,7 @@ class EtherSigner extends AbstractSigner {
             message: '',
             chain_id: chainId,
             typed_data: typedData
-        });
+        }, options);
         return this.waitForSignature(this.walletDetail.WalletID, response.transaction_id);
     }
     constructor(credentials, environment, provider, pollerOptions){
@@ -921,7 +922,7 @@ class SolanaSigner {
    * Signs a Solana transaction
    * @param transaction Base64 encoded serialized transaction
    * @returns Signature as a base58 encoded string
-   */ async signTransaction(transaction) {
+   */ async signTransaction(transaction, options) {
         if (!this.address) {
             await this.getAddress();
         }
@@ -936,7 +937,7 @@ class SolanaSigner {
                 tx_method: 'solana_signTransaction'
             },
             chainId: '1399811149'
-        });
+        }, options);
         // Wait for the signature
         return this.waitForTransactionStatus(response.transaction_id);
     }
@@ -944,7 +945,7 @@ class SolanaSigner {
    * Signs a Solana message
    * @param message The message to sign (string or Uint8Array)
    * @returns Signature as a base58 encoded string
-   */ async signMessage(message) {
+   */ async signMessage(message, options) {
         if (!this.address) {
             await this.getAddress();
         }
@@ -953,14 +954,14 @@ class SolanaSigner {
             method: 'solana_signMessage',
             message: messageStr,
             chain_id: 0 // Not used for Solana but required by API
-        });
+        }, options);
         return this.waitForTransactionStatus(response.transaction_id);
     }
     /**
    * Signs and sends a Solana transaction
    * @param transaction Base64 encoded serialized transaction
    * @returns Transaction signature
-   */ async signAndSendTransaction(transaction) {
+   */ async signAndSendTransaction(transaction, options) {
         if (!this.address) {
             await this.getAddress();
         }
@@ -969,7 +970,7 @@ class SolanaSigner {
             from: this.address,
             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!');
         return txHash;
@@ -978,14 +979,14 @@ class SolanaSigner {
    * Signs multiple Solana transactions
    * @param transactions Array of base64 encoded serialized transactions
    * @returns Array of signatures as base58 encoded strings
-   */ async signAllTransactions(transactions) {
+   */ async signAllTransactions(transactions, options) {
         if (!this.address) {
             await this.getAddress();
         }
         // 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
             // based on your Solana transaction structure

package/dist/index.mjs

@@ -174,7 +174,7 @@ var WalletRole;
     WalletRole["Viewer"] = "wallet_viewer";
 })(WalletRole || (WalletRole = {}));
 
-async function composeAPIHeaders(credentials, httpMethod, apiEndpoint, body = {}) {
+async function composeAPIHeaders(credentials, httpMethod, apiEndpoint, body = {}, headers) {
     if (!credentials.apiSecret || credentials.apiSecret === '') {
         // If APISecret is not provided, use authToken
         if (credentials.authToken) {
@@ -196,12 +196,13 @@ async function composeAPIHeaders(credentials, httpMethod, apiEndpoint, body = {}
         body: Object.keys(body).length ? JSON.stringify(body) : ''
     };
     const digest = await computeHMAC(credentials.apiSecret, params);
-    const headers = {
+    const combinedHeaders = {
         'ACCESS-API-KEY': credentials.apiKey,
         'ACCESS-TIMESTAMP': String(currentTimestampInSeconds),
-        'ACCESS-SIGN': btoa(digest) // convert to base64
+        'ACCESS-SIGN': btoa(digest),
+        ...headers ?? {}
     };
-    return headers;
+    return combinedHeaders;
 }
 class APIService {
     async getWallets(workspaceId) {
@@ -217,9 +218,9 @@ class APIService {
         const resp = await get(endpoint + `?address_type=${addressType}`, headers);
         return transformWalletDetail(resp.data);
     }
-    async requestSign(walletId, params) {
+    async requestSign(walletId, params, options) {
         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;
     }
@@ -229,10 +230,10 @@ class APIService {
         const response = await get(endpoint, headers);
         return response.data;
     }
-    async signTransaction(walletId, body) {
+    async signTransaction(walletId, body, options) {
         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;
         console.log(`[WalletSDK] Sign transaction completed in ${elapsedTime}ms`);
@@ -669,14 +670,14 @@ class EtherSigner extends AbstractSigner {
             }
             return result.status === TxStatus.Rejected;
         });
-        console.log('reulst', result);
+        console.log('result', result);
         if (!result.hash) {
             throw new TransactionError('Transaction hash not found in successful response', 'TRANSACTION_HASH_MISSING', result.transaction_id);
         }
         return result.hash;
     }
     // Copied and editted from ethers.js -> Wallet -> BaseWallet
-    async signTransaction(tx) {
+    async signTransaction(tx, options) {
         const startTime = new Date();
         console.log(`[WalletSDK] Transaction started at: ${startTime.toLocaleString()}`);
         if (!this.address) {
@@ -716,7 +717,7 @@ 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();
         const elapsedTimeMs = endTime.getTime() - startTime.getTime();
@@ -725,7 +726,7 @@ class EtherSigner extends AbstractSigner {
         console.log('[WalletSDK] Transaction succeed!');
         return txHash;
     }
-    async sendTransaction(tx) {
+    async sendTransaction(tx, options) {
         const startTime = new Date();
         console.log(`[WalletSDK] sendTransaction started at: ${startTime.toLocaleString()}`);
         if (!this.address) {
@@ -753,7 +754,7 @@ class EtherSigner extends AbstractSigner {
         const resolvedTx = await resolveProperties(populatedTx);
         const txObj = Transaction.from(resolvedTx);
         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();
         const totalElapsedMs = endTime.getTime() - startTime.getTime();
@@ -802,7 +803,7 @@ class EtherSigner extends AbstractSigner {
         // Let the provider create the TransactionResponse using the txHash
         return new TransactionResponse(txResponse, this.provider);
     }
-    async signMessage(message) {
+    async signMessage(message, options) {
         if (!this.provider) {
             throw new Error('Provider is required for signing operations');
         }
@@ -818,10 +819,10 @@ class EtherSigner extends AbstractSigner {
             method: 'eth_sign',
             message: messageStr,
             chain_id: chainId
-        });
+        }, options);
         return this.waitForSignature(this.walletDetail.WalletID, response.transaction_id);
     }
-    async signTypedData(domain, types, value) {
+    async signTypedData(domain, types, value, options) {
         if (!this.provider) {
             throw new Error('Provider is required for signing operations');
         }
@@ -842,7 +843,7 @@ class EtherSigner extends AbstractSigner {
             message: '',
             chain_id: chainId,
             typed_data: typedData
-        });
+        }, options);
         return this.waitForSignature(this.walletDetail.WalletID, response.transaction_id);
     }
     constructor(credentials, environment, provider, pollerOptions){
@@ -921,7 +922,7 @@ class SolanaSigner {
    * Signs a Solana transaction
    * @param transaction Base64 encoded serialized transaction
    * @returns Signature as a base58 encoded string
-   */ async signTransaction(transaction) {
+   */ async signTransaction(transaction, options) {
         if (!this.address) {
             await this.getAddress();
         }
@@ -936,7 +937,7 @@ class SolanaSigner {
                 tx_method: 'solana_signTransaction'
             },
             chainId: '1399811149'
-        });
+        }, options);
         // Wait for the signature
         return this.waitForTransactionStatus(response.transaction_id);
     }
@@ -944,7 +945,7 @@ class SolanaSigner {
    * Signs a Solana message
    * @param message The message to sign (string or Uint8Array)
    * @returns Signature as a base58 encoded string
-   */ async signMessage(message) {
+   */ async signMessage(message, options) {
         if (!this.address) {
             await this.getAddress();
         }
@@ -953,14 +954,14 @@ class SolanaSigner {
             method: 'solana_signMessage',
             message: messageStr,
             chain_id: 0 // Not used for Solana but required by API
-        });
+        }, options);
         return this.waitForTransactionStatus(response.transaction_id);
     }
     /**
    * Signs and sends a Solana transaction
    * @param transaction Base64 encoded serialized transaction
    * @returns Transaction signature
-   */ async signAndSendTransaction(transaction) {
+   */ async signAndSendTransaction(transaction, options) {
         if (!this.address) {
             await this.getAddress();
         }
@@ -969,7 +970,7 @@ class SolanaSigner {
             from: this.address,
             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!');
         return txHash;
@@ -978,14 +979,14 @@ class SolanaSigner {
    * Signs multiple Solana transactions
    * @param transactions Array of base64 encoded serialized transactions
    * @returns Array of signatures as base58 encoded strings
-   */ async signAllTransactions(transactions) {
+   */ async signAllTransactions(transactions, options) {
         if (!this.address) {
             await this.getAddress();
         }
         // 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
             // based on your Solana transaction structure

package/dist/types/index.d.ts

@@ -361,9 +361,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>;
@@ -646,10 +646,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,25 +676,33 @@ 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;

package/package.json

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

package/src/api.ts

@@ -69,7 +69,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 +95,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 +131,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 +149,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
 

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

package/src/types.ts

@@ -1,5 +1,12 @@
 import { SweepTaskParams } from './api'
-import { TxApprovalStatus, TxStatus, WalletCreationStatus, WalletPurpose, WalletRole, WalletType } from './enum'
+import {
+  TxApprovalStatus,
+  TxStatus,
+  WalletCreationStatus,
+  WalletPurpose,
+  WalletRole,
+  WalletType
+} from './enum'
 
 export class TransactionError extends Error {
   constructor(