@fystack/sdk 0.1.7 → 0.1.9

package/dist/index.cjs

@@ -50,7 +50,9 @@ const createAPI = (env)=>{
             getWalletCreationStatus: (walletId)=>withBaseURL(`/wallets/creation-status/${walletId}`),
             getWalletAssets: (walletId)=>withBaseURL(`/wallets/${walletId}/assets`),
             getDepositAddress: (walletId, addressType)=>withBaseURL(`/wallets/${walletId}/deposit-address?address_type=${addressType}`),
-            rescanTransaction: ()=>withBaseURL('/networks/rescan-transaction')
+            rescanTransaction: ()=>withBaseURL('/networks/rescan-transaction'),
+            requestWithdrawal: (walletId)=>withBaseURL(`/wallets/${walletId}/request-withdrawal`),
+            getWebhookPublicKey: (workspaceId)=>withBaseURL(`/workspaces/${workspaceId}/webhook-verification-key`)
         }
     };
 };
@@ -181,8 +183,18 @@ exports.WalletRole = void 0;
     WalletRole["Signer"] = "wallet_signer";
     WalletRole["Viewer"] = "wallet_viewer";
 })(exports.WalletRole || (exports.WalletRole = {}));
+exports.WithdrawalStatus = void 0;
+(function(WithdrawalStatus) {
+    WithdrawalStatus["Pending"] = "pending";
+    WithdrawalStatus["PendingApproval"] = "pending_approval";
+    WithdrawalStatus["Approved"] = "approved";
+    WithdrawalStatus["Rejected"] = "rejected";
+    WithdrawalStatus["Processing"] = "processing";
+    WithdrawalStatus["Completed"] = "completed";
+    WithdrawalStatus["Failed"] = "failed";
+})(exports.WithdrawalStatus || (exports.WithdrawalStatus = {}));
 
-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 +216,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 +238,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 +250,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`);
@@ -299,6 +312,28 @@ 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, params) {
+        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) {
+        const endpoint = this.API.endpoints.getWebhookPublicKey(workspaceId);
+        const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint);
+        const response = await get(endpoint, headers);
+        return response.data;
+    }
     constructor(credentials, environment){
         this.credentials = credentials;
         this.Webhook = new WebhookService(credentials);
@@ -422,6 +457,19 @@ function transformRescanTransactionParams(data) {
         network_id: data.networkId
     };
 }
+function transformRequestWithdrawalParams(data) {
+    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.toJSON = function() {
     return this.toString();
 };
@@ -582,6 +630,41 @@ 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, params) {
+        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) {
+        validateUUID(workspaceId, 'workspaceId');
+        this.log(`Getting webhook public key for workspace ${workspaceId}`);
+        const response = await this.apiService.getWebhookPublicKey(workspaceId);
+        return response;
+    }
     constructor(options){
         const { credentials, workspaceId, environment = exports.Environment.Production, logger = false } = options;
         this.apiService = new APIService(credentials, environment);
@@ -677,14 +760,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 +807,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 +816,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 +844,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 +893,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 +909,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 +933,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 +1012,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 +1027,7 @@ class SolanaSigner {
                 tx_method: 'solana_signTransaction'
             },
             chainId: '1399811149'
-        });
+        }, options);
         // Wait for the signature
         return this.waitForTransactionStatus(response.transaction_id);
     }
@@ -952,7 +1035,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 +1044,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 +1060,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 +1069,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
@@ -1053,5 +1136,6 @@ exports.createAPI = createAPI;
 exports.get = get;
 exports.post = post;
 exports.transformCreateWalletPayload = transformCreateWalletPayload;
+exports.transformRequestWithdrawalParams = transformRequestWithdrawalParams;
 exports.transformRescanTransactionParams = transformRescanTransactionParams;
 exports.transformWalletDetail = transformWalletDetail;

package/dist/index.d.cts

@@ -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 };