@fystack/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,962 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fetch = require('cross-fetch');
+var CryptoJS = require('crypto-js');
+var ethers = require('ethers');
+var web3_js = require('@solana/web3.js');
+var bs58 = require('bs58');
+var buffer = require('buffer');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fetch__default = /*#__PURE__*/_interopDefault(fetch);
+var CryptoJS__default = /*#__PURE__*/_interopDefault(CryptoJS);
+var bs58__default = /*#__PURE__*/_interopDefault(bs58);
+
+exports.Environment = void 0;
+(function(Environment) {
+    Environment["Local"] = "local";
+    Environment["Sandbox"] = "sandbox";
+    Environment["Production"] = "production";
+})(exports.Environment || (exports.Environment = {}));
+const getBaseURL = (env)=>{
+    switch(env){
+        case "local":
+            return 'http://localhost:8150';
+        case "sandbox":
+            return 'https://apex.void.exchange';
+        case "production":
+            return 'https://api.fystack.io';
+    }
+};
+const createAPI = (env)=>{
+    const baseURL = `${getBaseURL(env)}/api/v1`;
+    const withBaseURL = (path)=>`${baseURL}${path}`;
+    return {
+        baseURL,
+        endpoints: {
+            signTransaction: (walletId)=>withBaseURL(`/web3/transaction/${walletId}/signRaw`),
+            getWalletDetail: (walletId)=>walletId ? withBaseURL(`/web3/wallet-detail/${walletId}`) : withBaseURL('/web3/wallet-detail'),
+            createWallet: ()=>withBaseURL('/wallets'),
+            createCheckout: ()=>withBaseURL('/checkouts'),
+            getCheckout: (checkoutId)=>withBaseURL(`/checkouts/${checkoutId}`),
+            createCheckoutPayment: (checkoutId)=>withBaseURL(`/checkouts/${checkoutId}/payment`),
+            getCheckoutPayment: (checkoutId)=>withBaseURL(`/checkouts/payment/${checkoutId}`),
+            // New endpoints for signing and transaction status
+            requestSign: (walletId)=>withBaseURL(`/web3/${walletId}/sign`),
+            getSignStatus: (walletId, transactionId)=>withBaseURL(`/web3/${walletId}/sign/${transactionId}`),
+            getTransactionStatus: (walletId, transactionId)=>withBaseURL(`/web3/transaction/${walletId}/${transactionId}`),
+            getWalletCreationStatus: (walletId)=>withBaseURL(`/wallets/creation-status/${walletId}`),
+            getWalletAssets: (walletId)=>withBaseURL(`/wallets/${walletId}/assets`),
+            getDepositAddress: (walletId, addressType)=>withBaseURL(`/wallets/${walletId}/deposit-address?address_type=${addressType}`)
+        }
+    };
+};
+
+async function computeHMAC(apiSecret, params) {
+    const encodedParams = Object.entries(params).map(([key, value])=>`${key}=${value}`).join('&');
+    const digest = CryptoJS__default.default.HmacSHA256(encodedParams, apiSecret);
+    return digest.toString(CryptoJS__default.default.enc.Hex);
+}
+async function computeHMACForWebhook(apiSecret, event) {
+    const eventStr = canonicalizeJSON(event);
+    console.log('eventStr', eventStr);
+    const digest = CryptoJS__default.default.HmacSHA256(eventStr, apiSecret);
+    return digest.toString(CryptoJS__default.default.enc.Hex);
+}
+/**
+ * Canonicalizes a TypeScript object by sorting its keys recursively.
+ *
+ * @param inputObject - The input object to canonicalize.
+ * @returns A canonicalized JSON string with sorted keys.
+ * @throws Error if the input is not a valid object.
+ */ function canonicalizeJSON(inputObject) {
+    if (typeof inputObject !== 'object' || inputObject === null) {
+        throw new Error('Input must be a non-null object.');
+    }
+    /**
+   * Recursively sorts the keys of an object or processes arrays.
+   *
+   * @param value - The value to sort (can be an object, array, or primitive).
+   * @returns The sorted value.
+   */ const sortKeys = (value)=>{
+        if (Array.isArray(value)) {
+            // Recursively sort each element in the array
+            return value.map(sortKeys);
+        }
+        if (value && typeof value === 'object' && value.constructor === Object) {
+            // Sort object keys and recursively sort their values
+            return Object.keys(value).sort().reduce((sortedObj, key)=>{
+                sortedObj[key] = sortKeys(value[key]);
+                return sortedObj;
+            }, {});
+        }
+        // Return primitive values as-is
+        return value;
+    };
+    // Sort the keys recursively
+    const sortedObject = sortKeys(inputObject);
+    // Convert the sorted object back into a JSON string
+    return JSON.stringify(sortedObject);
+}
+/**
+ * Validates if a string is a valid UUID v4
+ * @param uuid The string to validate
+ * @returns boolean indicating if the string is a valid UUID
+ */ function isValidUUID(uuid) {
+    if (!uuid || typeof uuid !== 'string') {
+        return false;
+    }
+    // UUID v4 pattern:
+    // 8-4-4-4-12 where third group starts with 4 and fourth group starts with 8, 9, a, or b
+    const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidV4Regex.test(uuid);
+}
+/**
+ * Validates if a string is a valid UUID and throws an error if not
+ * @param uuid The string to validate
+ * @param paramName The name of the parameter being validated (for error message)
+ * @throws Error if the UUID is invalid
+ */ function validateUUID(uuid, paramName) {
+    if (!uuid || typeof uuid !== 'string') {
+        throw new Error(`${paramName} is required and must be a string`);
+    }
+    if (!isValidUUID(uuid)) {
+        throw new Error(`Invalid ${paramName} format. Must be a valid UUID v4`);
+    }
+}
+
+exports.WalletAddressType = void 0;
+(function(WalletAddressType) {
+    WalletAddressType["Evm"] = "evm";
+    WalletAddressType["Sol"] = "sol";
+})(exports.WalletAddressType || (exports.WalletAddressType = {}));
+async function composeAPIHeaders(credentials, httpMethod, apiEndpoint, body = {}) {
+    if (credentials.apiSecret == '') {
+        // If APISecret is not provided, fallback to cookie mode with no headers
+        return {};
+    }
+    const currentTimestampInSeconds = Math.floor(Date.now() / 1000);
+    const url = new URL(apiEndpoint);
+    const path = url.pathname // Extract the path
+    ;
+    const params = {
+        method: httpMethod,
+        path,
+        timestamp: String(currentTimestampInSeconds),
+        body: Object.keys(body).length ? JSON.stringify(body) : ''
+    };
+    const digest = await computeHMAC(credentials.apiSecret, params);
+    const headers = {
+        'ACCESS-API-KEY': credentials.apiKey,
+        'ACCESS-TIMESTAMP': String(currentTimestampInSeconds),
+        'ACCESS-SIGN': btoa(digest) // convert to base64
+    };
+    return headers;
+}
+class APIService {
+    async getWalletDetail(addressType = "evm", walletId) {
+        const endpoint = this.API.endpoints.getWalletDetail(walletId);
+        const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint);
+        console.info('headers', headers);
+        const resp = await get(endpoint + `?address_type=${addressType}`, headers);
+        return transformWalletDetail(resp.data);
+    }
+    async requestSign(walletId, params) {
+        const endpoint = this.API.endpoints.requestSign(walletId);
+        const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, params);
+        const response = await post(endpoint, params, headers);
+        return response.data;
+    }
+    async getSignStatus(walletId, transactionId) {
+        const endpoint = this.API.endpoints.getSignStatus(walletId, transactionId);
+        const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint);
+        const response = await get(endpoint, headers);
+        return response.data;
+    }
+    async signTransaction(walletId, body) {
+        const startTime = Date.now();
+        const endpoint = this.API.endpoints.signTransaction(walletId);
+        const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, body);
+        const response = await post(endpoint, body, headers);
+        const elapsedTime = Date.now() - startTime;
+        console.log(`[WalletSDK] Sign transaction completed in ${elapsedTime}ms`);
+        console.log('[WalletSDK] Sign transaction response:', response);
+        return response.data;
+    }
+    async getTransactionStatus(walletId, transactionId) {
+        const endpoint = this.API.endpoints.getTransactionStatus(walletId, transactionId);
+        const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint);
+        const response = await get(endpoint, headers);
+        return response.data;
+    }
+    async createWallet(payload) {
+        const endpoint = this.API.endpoints.createWallet();
+        const transformedPayload = transformCreateWalletPayload(payload);
+        const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, transformedPayload);
+        const resp = await post(endpoint, transformedPayload, headers);
+        return resp.data;
+    }
+    async createCheckout(payload) {
+        const endpoint = this.API.endpoints.createCheckout();
+        const headers = await composeAPIHeaders(this.credentials, 'POST', endpoint, payload);
+        const response = await post(endpoint, payload, headers);
+        return response.data;
+    }
+    async getWalletCreationStatus(walletId) {
+        const endpoint = this.API.endpoints.getWalletCreationStatus(walletId);
+        const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint);
+        const response = await get(endpoint, headers);
+        return response.data;
+    }
+    async getWalletAssets(walletId) {
+        const endpoint = this.API.endpoints.getWalletAssets(walletId);
+        const headers = await composeAPIHeaders(this.credentials, 'GET', endpoint);
+        const response = await get(endpoint, headers);
+        return response.data;
+    }
+    /**
+   * Gets deposit address for a wallet by address type
+   * @param walletId The wallet ID
+   * @param addressType The type of address (evm, sol)
+   * @returns Deposit address response
+   */ async getDepositAddress(walletId, addressType) {
+        const endpoint = this.API.endpoints.getDepositAddress(walletId, addressType);
+        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);
+        this.API = createAPI(environment);
+    }
+}
+class PaymentService {
+    async createCheckout(payload) {
+        const endpoint = this.API.endpoints.createCheckout();
+        const headers = {
+            'ACCESS-API-KEY': this.apiKey
+        };
+        const response = await post(endpoint, payload, headers);
+        return response.data;
+    }
+    async getCheckout(checkoutId) {
+        const endpoint = this.API.endpoints.getCheckout(checkoutId);
+        const response = await get(endpoint);
+        return response.data;
+    }
+    async createCheckoutPayment(checkoutId, payload) {
+        const endpoint = this.API.endpoints.createCheckoutPayment(checkoutId);
+        const response = await post(endpoint, payload);
+        return response.data;
+    }
+    async getCheckoutPayment(checkoutId) {
+        const endpoint = this.API.endpoints.getCheckoutPayment(checkoutId);
+        const response = await get(endpoint);
+        return response.data;
+    }
+    constructor(params){
+        this.apiKey = params.apiKey;
+        this.API = createAPI(params.environment);
+    }
+}
+class WebhookService {
+    // Implement verify webhook here
+    async verifyEvent(event, signature) {
+        // Recompute HMAC
+        const computedHMAC = await computeHMACForWebhook(this.credentials.apiSecret, event);
+        const isValid = signature === computedHMAC;
+        return isValid;
+    }
+    constructor(credentials){
+        this.credentials = credentials;
+    }
+}
+// Simplified GET request function
+async function get(endpoint, headers = {}) {
+    const request = {
+        method: 'GET',
+        headers: {
+            ...headers
+        }
+    };
+    // Only include credentials if we're in cookie mode (no API key in headers)
+    if (!headers['ACCESS-API-KEY']) {
+        request.credentials = 'include';
+    }
+    const response = await fetch__default.default(`${endpoint}`, request);
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+        console.error('Status Code', response.status);
+        throw new Error(data.message || 'Failed to fetch data');
+    }
+    return data;
+}
+// Simplified POST request function
+async function post(endpoint, body, headers = {}) {
+    const request = {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...headers
+        },
+        body: JSON.stringify(body)
+    };
+    // Only include credentials if we're in cookie mode (no API key in headers)
+    if (!headers['ACCESS-API-KEY']) {
+        request.credentials = 'include';
+    }
+    const response = await fetch__default.default(`${endpoint}`, request);
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+        console.error('Status Code', response.status);
+        throw new Error(data.message || 'Failed to fetch data');
+    }
+    return data;
+}
+function transformWalletDetail(data) {
+    return {
+        APIKey: data?.ap_key,
+        WalletID: data?.wallet_id,
+        Name: data?.name,
+        AddressType: data?.address_type,
+        Address: data?.address
+    };
+}
+function transformCreateWalletPayload(data) {
+    return {
+        name: data.name,
+        wallet_type: data.walletType
+    };
+}
+BigInt.prototype.toJSON = function() {
+    return this.toString();
+};
+
+const DEFAULT_POLLER_OPTIONS = {
+    maxAttempts: 10,
+    interval: 1000,
+    backoffFactor: 1.5,
+    maxInterval: 10000,
+    timeoutMs: 10 * 60 * 1000 // 10 minutes totla
+};
+class StatusPoller {
+    async wait() {
+        await new Promise((resolve)=>setTimeout(resolve, this.currentInterval));
+        // Implement exponential backoff
+        this.currentInterval = Math.min(this.currentInterval * this.options.backoffFactor, this.options.maxInterval);
+    }
+    shouldContinue() {
+        const timeElapsed = Date.now() - this.startTime;
+        if (timeElapsed >= this.options.timeoutMs) {
+            throw new Error(`Status polling timed out after ${timeElapsed}ms`);
+        }
+        if (this.attempts >= this.options.maxAttempts) {
+            throw new Error(`Maximum polling attempts (${this.options.maxAttempts}) exceeded`);
+        }
+        return true;
+    }
+    async poll(pollingFn, successCondition, errorCondition) {
+        while(this.shouldContinue()){
+            this.attempts++;
+            const result = await pollingFn();
+            // Check for error condition first
+            if (errorCondition) {
+                const shouldError = errorCondition(result);
+                if (shouldError) {
+                    throw new Error('Status polling failed');
+                }
+            }
+            // Check for success condition
+            if (successCondition(result)) {
+                return result;
+            }
+            // If neither condition is met, wait and continue polling
+            await this.wait();
+        }
+        throw new Error('Polling ended without meeting success condition');
+    }
+    constructor(options = {}){
+        this.options = {
+            ...DEFAULT_POLLER_OPTIONS,
+            ...options
+        };
+        this.startTime = Date.now();
+        this.attempts = 0;
+        this.currentInterval = this.options.interval;
+    }
+}
+
+class TransactionError extends Error {
+    constructor(message, code, transactionId, originalError){
+        super(message);
+        this.code = code;
+        this.transactionId = transactionId;
+        this.originalError = originalError;
+        this.name = 'TransactionError';
+    }
+}
+exports.TxStatus = void 0;
+(function(TxStatus) {
+    TxStatus["Pending"] = "pending";
+    TxStatus["Completed"] = "completed";
+    TxStatus["Confirmed"] = "confirmed";
+    TxStatus["Failed"] = "failed";
+    TxStatus["PendingApproval"] = "pending_approval";
+    TxStatus["Rejected"] = "rejected";
+})(exports.TxStatus || (exports.TxStatus = {}));
+exports.TxApprovalStatus = void 0;
+(function(TxApprovalStatus) {
+    TxApprovalStatus["Pending"] = "pending";
+    TxApprovalStatus["Approved"] = "approved";
+    TxApprovalStatus["Rejected"] = "rejected";
+})(exports.TxApprovalStatus || (exports.TxApprovalStatus = {}));
+exports.WalletType = void 0;
+(function(WalletType) {
+    WalletType["Standard"] = "standard";
+    WalletType["MPC"] = "mpc";
+})(exports.WalletType || (exports.WalletType = {}));
+exports.WalletCreationStatus = void 0;
+(function(WalletCreationStatus) {
+    WalletCreationStatus["Pending"] = "pending";
+    WalletCreationStatus["Success"] = "success";
+    WalletCreationStatus["Error"] = "error";
+})(exports.WalletCreationStatus || (exports.WalletCreationStatus = {}));
+exports.AddressType = void 0;
+(function(AddressType) {
+    AddressType["Evm"] = "evm";
+    AddressType["Solana"] = "sol";
+})(exports.AddressType || (exports.AddressType = {}));
+
+class FystackSDK {
+    log(message) {
+        if (this.enableLogging) {
+            console.log(`[FystackSDK] ${message}`);
+        }
+    }
+    /**
+   * Creates a new wallet
+   * @param options Wallet creation options
+   * @param waitForCompletion Whether to wait for the wallet creation to complete
+   * @returns Promise with wallet ID and status
+   */ async createWallet(options, waitForCompletion = true) {
+        const { name, walletType = exports.WalletType.Standard } = options;
+        const response = await this.apiService.createWallet({
+            name,
+            walletType
+        });
+        if (waitForCompletion && response.status === exports.WalletCreationStatus.Pending) {
+            return this.waitForWalletCreation(response.wallet_id);
+        }
+        return response;
+    }
+    /**
+   * Gets the current status of a wallet creation process
+   * @param walletId The ID of the wallet being created
+   * @returns Promise with wallet creation status details
+   */ async getWalletCreationStatus(walletId) {
+        const response = await this.apiService.getWalletCreationStatus(walletId);
+        return response;
+    }
+    /**
+   * Waits for a wallet to be created and returns the final status
+   * @param walletId The ID of the wallet being created
+   * @returns Promise with wallet ID and final status
+   */ async waitForWalletCreation(walletId) {
+        const poller = new StatusPoller();
+        // Poll for wallet creation status
+        const result = await poller.poll(// Polling function
+        async ()=>{
+            this.log('Polling wallet creation status...');
+            const response = await this.apiService.getWalletCreationStatus(walletId);
+            return response;
+        }, // Success condition - when status is either success or error
+        (result)=>[
+                exports.WalletCreationStatus.Success,
+                exports.WalletCreationStatus.Error
+            ].includes(result.status), // Error condition - no specific error condition needed, as we're polling until final state
+        undefined);
+        this.log(`Wallet creation completed with status: ${result.status}`);
+        return {
+            wallet_id: result.wallet_id,
+            status: result.status
+        };
+    }
+    /**
+   * Gets assets associated with a wallet
+   * @param walletId The ID of the wallet
+   * @returns Promise with wallet assets
+   */ async getWalletAssets(walletId) {
+        if (!walletId || walletId.trim() === '') {
+            throw new Error('Invalid wallet ID provided');
+        }
+        const data = await this.apiService.getWalletAssets(walletId);
+        return data;
+    }
+    /**
+   * Gets deposit address for a wallet by address type
+   * @param walletId The wallet ID
+   * @param addressType The type of address (evm, sol)
+   * @returns Promise with deposit address information
+   */ async getDepositAddress(walletId, addressType) {
+        validateUUID(walletId, 'walletId');
+        if (!Object.values(exports.AddressType).includes(addressType)) {
+            throw new Error(`Invalid address type: ${addressType}. Must be one of: ${Object.values(exports.AddressType).join(', ')}`);
+        }
+        const depositAddressInfo = await this.apiService.getDepositAddress(walletId, addressType);
+        return depositAddressInfo;
+    }
+    constructor(options){
+        const { credentials, environment = exports.Environment.Production, logger = false } = options;
+        this.apiService = new APIService(credentials, environment);
+        this.enableLogging = logger;
+    }
+}
+
+class ApexSigner extends ethers.AbstractSigner {
+    setWallet(walletId) {
+        if (!walletId || walletId.trim() === '') {
+            throw new Error('Invalid wallet ID provided');
+        }
+        // Set walletId in walletDetail with default values for required properties
+        this.walletDetail = {
+            WalletID: walletId,
+            APIKey: '',
+            Name: '',
+            AddressType: '',
+            Address: ''
+        };
+        // Reset address cache since we're changing wallets
+        this.address = '';
+    }
+    async getAddress() {
+        if (this.address) {
+            return this.address;
+        }
+        if (!this.APICredentials.apiKey && !this.walletDetail.WalletID) {
+            throw new Error('Wallet detail not found, use setWallet(walletId) to set wallet first!');
+        }
+        const detail = await this.APIService.getWalletDetail(exports.WalletAddressType.Evm, this.walletDetail?.WalletID);
+        this.walletDetail = detail;
+        if (detail?.Address) {
+            // cache the address
+            this.address = detail.Address;
+        }
+        if (!this.address) {
+            throw new Error('Address not found');
+        }
+        return this.address;
+    }
+    async getChainId() {
+        if (!this.provider) {
+            throw new Error('Provider is required for signing operations');
+        }
+        try {
+            const network = await this.provider.getNetwork();
+            return Number(network.chainId);
+        } catch (error) {
+            throw new Error('Failed to get chainId from provider: ' + error);
+        }
+    }
+    connect(provider) {
+        return new ApexSigner(this.APICredentials, this.environment, provider);
+    }
+    async waitForSignature(walletId, transactionId) {
+        const poller = new StatusPoller(this.pollerOptions);
+        const status = await poller.poll(// Polling function
+        ()=>this.APIService.getSignStatus(walletId, transactionId), // Success condition
+        (result)=>result.status === exports.TxStatus.Confirmed && result.signature != null, // Error condition
+        (result)=>[
+                exports.TxStatus.Failed,
+                exports.TxStatus.Rejected
+            ].includes(result.status));
+        if (!status.signature) {
+            throw new Error('Signature not found in successful response');
+        }
+        return status.signature;
+    }
+    async waitForTransactonStatus(transactionId) {
+        const poller = new StatusPoller(this.pollerOptions);
+        // Poll for transaction status using signaturePoller
+        const result = await poller.poll(// Polling function
+        ()=>{
+            console.log('Polling status');
+            return this.APIService.getTransactionStatus(this.walletDetail.WalletID, transactionId);
+        }, // Success condition
+        (result)=>(result.status === exports.TxStatus.Confirmed || result.status === exports.TxStatus.Completed) && !!result.hash, // Error condition
+        (result)=>{
+            if (result.status === exports.TxStatus.Failed) {
+                throw new TransactionError(result.failed_reason || 'Transaction failed', 'TRANSACTION_FAILED', result.transaction_id);
+            }
+            return result.status === exports.TxStatus.Rejected;
+        });
+        console.log('reulst', 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) {
+        const startTime = new Date();
+        console.log(`[WalletSDK] Transaction started at: ${startTime.toLocaleString()}`);
+        // Replace any Addressable or ENS name with an address
+        const { to, from } = await ethers.resolveProperties({
+            to: tx.to ? ethers.resolveAddress(tx.to, this.provider) : undefined,
+            from: tx.from ? ethers.resolveAddress(tx.from, this.provider) : undefined
+        });
+        if (to != null) {
+            tx.to = to;
+        }
+        if (from != null) {
+            tx.from = from;
+        }
+        if (tx.from != null) {
+            ethers.assertArgument(ethers.getAddress(tx.from) === this.address, 'transaction from address mismatch', 'tx.from', tx.from);
+            delete tx.from;
+        }
+        const fromAddress = this.address;
+        // Build the transaction
+        const btx = ethers.Transaction.from(tx);
+        const data = {
+            maxFeePerGas: btx.maxFeePerGas,
+            maxPriorityFeePerGas: btx.maxPriorityFeePerGas,
+            to: btx.to,
+            from: fromAddress,
+            nonce: btx.nonce,
+            gasLimit: btx.gasLimit,
+            data: btx.data,
+            value: btx.value,
+            chainId: btx.chainId,
+            accessList: btx.accessList
+        };
+        // return unseralized as API signTransaction is an asynchoronous action
+        const response = await this.APIService.signTransaction(this.walletDetail.WalletID, data);
+        const txHash = await this.waitForTransactonStatus(response.transaction_id);
+        const endTime = new Date();
+        const elapsedTimeMs = endTime.getTime() - startTime.getTime();
+        console.log(`[WalletSDK] Transaction completed at: ${endTime.toLocaleString()}`);
+        console.log(`[WalletSDK] Transaction took ${elapsedTimeMs}ms (${(elapsedTimeMs / 1000).toFixed(2)}s)`);
+        console.log('[WalletSDK] Transaction succeed!');
+        return txHash;
+    }
+    async sendTransaction(tx) {
+        const startTime = new Date();
+        console.log(`[WalletSDK] sendTransaction started at: ${startTime.toLocaleString()}`);
+        if (!this.address) {
+            await this.getAddress();
+        }
+        checkProvider(this, 'sendTransaction');
+        // Only populate if gas fees are not set
+        const hasGasFees = tx.gasPrice != null || tx.maxFeePerGas != null && tx.maxPriorityFeePerGas != null;
+        let populatedTx = tx;
+        if (!hasGasFees) {
+            const populateStartTime = new Date();
+            console.log(`[WalletSDK] populateTransaction started at: ${populateStartTime.toLocaleString()}`);
+            populatedTx = await this.populateTransaction(tx);
+            const populateEndTime = new Date();
+            const populateElapsedMs = populateEndTime.getTime() - populateStartTime.getTime();
+            console.log(`[WalletSDK] populateTransaction completed in ${(populateElapsedMs / 1000).toFixed(2)}s`);
+        } else {
+            console.log(`[WalletSDK] Skipping transaction population as gas fees are already set`);
+        }
+        delete populatedTx.from;
+        // Ensure all properties are properly resolved to their string representations
+        const resolvedTx = await ethers.resolveProperties(populatedTx);
+        const txObj = ethers.Transaction.from(resolvedTx);
+        console.log('txObj', txObj);
+        const txHash = await this.signTransaction(txObj);
+        // Instead of creating a mock response, get the actual transaction from the provider
+        const endTime = new Date();
+        const totalElapsedMs = endTime.getTime() - startTime.getTime();
+        console.log(`[WalletSDK] sendTransaction completed at: ${endTime.toLocaleString()}`);
+        console.log(`[WalletSDK] sendTransaction took ${(totalElapsedMs / 1000).toFixed(2)}s`);
+        console.log('[WalletSDK] Transaction sent successfully!');
+        const txResponse = {
+            blockNumber: 0,
+            blockHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            hash: txHash,
+            index: 0,
+            type: 0,
+            to: tx.to,
+            from: this.address,
+            /**
+       *
+       */ nonce: txObj.nonce,
+            /**
+       *  The maximum amount of gas this transaction is authorized to consume.
+       */ gasLimit: txObj.gasLimit,
+            /**
+       *  For legacy transactions, this is the gas price per gas to pay.
+       */ gasPrice: txObj.gasPrice ? txObj.gasPrice : BigInt(0),
+            /**
+       *  For [[link-eip-1559]] transactions, this is the maximum priority
+       *  fee to allow a producer to claim.
+       */ maxPriorityFeePerGas: txObj.maxPriorityFeePerGas,
+            /**
+       *  For [[link-eip-1559]] transactions, this is the maximum fee that
+       *  will be paid.
+       */ maxFeePerGas: txObj.maxFeePerGas,
+            /**
+       *  The transaction data.
+       */ data: txObj.data,
+            /**
+       *  The transaction value (in wei).
+       */ value: txObj.value,
+            /**
+       *  The chain ID this transaction is valid on.
+       */ chainId: txObj.chainId,
+            signature: ethers.Signature.from('0x' + '0'.repeat(130)),
+            /**
+       *  The transaction access list.
+       */ accessList: txObj.accessList
+        };
+        // Let the provider create the TransactionResponse using the txHash
+        return new ethers.TransactionResponse(txResponse, this.provider);
+    }
+    async signMessage(message) {
+        if (!this.provider) {
+            throw new Error('Provider is required for signing operations');
+        }
+        if (!this.address) {
+            await this.getAddress();
+        }
+        if (!this.walletDetail) {
+            this.walletDetail = await this.APIService.getWalletDetail();
+        }
+        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
+        });
+        return this.waitForSignature(this.walletDetail.WalletID, response.transaction_id);
+    }
+    async signTypedData(domain, types, value) {
+        if (!this.provider) {
+            throw new Error('Provider is required for signing operations');
+        }
+        if (!this.address) {
+            await this.getAddress();
+        }
+        if (!this.walletDetail) {
+            this.walletDetail = await this.APIService.getWalletDetail();
+        }
+        const chainId = await this.getChainId();
+        const typedData = JSON.stringify({
+            domain,
+            types,
+            message: value
+        });
+        const response = await this.APIService.requestSign(this.walletDetail.WalletID, {
+            method: 'eth_signTypedData_v4',
+            message: '',
+            chain_id: chainId,
+            typed_data: typedData
+        });
+        return this.waitForSignature(this.walletDetail.WalletID, response.transaction_id);
+    }
+    constructor(credentials, environment, provider, pollerOptions){
+        super(provider);
+        this.APICredentials = credentials;
+        this.APIService = new APIService(credentials, environment);
+        this.environment = environment;
+        this.pollerOptions = pollerOptions;
+    }
+}
+function checkProvider(signer, operation) {
+    if (signer.provider) {
+        return signer.provider;
+    }
+    ethers.assert(false, 'missing provider', 'UNSUPPORTED_OPERATION', {
+        operation
+    });
+}
+
+class SolanaSigner {
+    setWallet(walletId) {
+        if (!walletId || walletId.trim() === '') {
+            throw new Error('Invalid wallet ID provided');
+        }
+        // Set walletId in walletDetail with default values for required properties
+        this.walletDetail = {
+            WalletID: walletId,
+            APIKey: '',
+            Name: '',
+            AddressType: '',
+            Address: ''
+        };
+        // Reset address cache since we're changing wallets
+        this.address = '';
+    }
+    async getAddress() {
+        if (this.address) {
+            return this.address;
+        }
+        if (!this.APIKey && !this.walletDetail?.WalletID) {
+            throw new Error('Wallet detail not found, use setWallet(walletId) to set wallet first!');
+        }
+        const detail = await this.APIService.getWalletDetail(exports.WalletAddressType.Sol, this.walletDetail?.WalletID);
+        this.walletDetail = detail;
+        if (detail?.Address) {
+            // cache the address
+            this.address = detail.Address;
+        }
+        if (!this.address) {
+            throw new Error('Address not found');
+        }
+        return this.address;
+    }
+    async waitForTransactionStatus(transactionId) {
+        const poller = new StatusPoller(this.pollerOptions);
+        // Poll for transaction status using signaturePoller
+        const result = await poller.poll(// Polling function
+        ()=>{
+            console.log('Polling status');
+            return this.APIService.getTransactionStatus(this.walletDetail.WalletID, transactionId);
+        }, // Success condition
+        (result)=>(result.status === exports.TxStatus.Confirmed || result.status === exports.TxStatus.Completed) && !!result.hash, // Error condition
+        (result)=>{
+            if (result.status === exports.TxStatus.Failed) {
+                throw new TransactionError(result.failed_reason || 'Transaction failed', 'TRANSACTION_FAILED', result.transaction_id);
+            }
+            return result.status === exports.TxStatus.Rejected;
+        });
+        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;
+    }
+    /**
+   * Signs a Solana transaction
+   * @param transaction Base64 encoded serialized transaction
+   * @returns Signature as a base58 encoded string
+   */ async signTransaction(transaction) {
+        if (!this.address) {
+            await this.getAddress();
+        }
+        const data = {
+            data: transaction,
+            from: this.address
+        };
+        // Call the signRaw API similar to ApexSigner
+        const response = await this.APIService.signTransaction(this.walletDetail.WalletID, {
+            ...data,
+            meta: {
+                tx_method: 'solana_signTransaction'
+            },
+            chainId: '1399811149'
+        });
+        console.log('respnpse', response);
+        // Wait for the signature
+        return this.waitForTransactionStatus(response.transaction_id);
+    }
+    /**
+   * Signs a Solana message
+   * @param message The message to sign (string or Uint8Array)
+   * @returns Signature as a base58 encoded string
+   */ async signMessage(message) {
+        if (!this.address) {
+            await this.getAddress();
+        }
+        const messageStr = typeof message === 'string' ? message : buffer.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
+        });
+        console.log('Respnse', response);
+        return this.waitForTransactionStatus(response.transaction_id);
+    }
+    /**
+   * Signs and sends a Solana transaction
+   * @param transaction Base64 encoded serialized transaction
+   * @returns Transaction signature
+   */ async signAndSendTransaction(transaction) {
+        if (!this.address) {
+            await this.getAddress();
+        }
+        const data = {
+            transaction,
+            from: this.address,
+            method: 'solana_signAndSendTransaction'
+        };
+        const response = await this.APIService.signTransaction(this.walletDetail.WalletID, data);
+        const txHash = await this.waitForTransactionStatus(response.transaction_id);
+        console.log('transaction succeed!');
+        return txHash;
+    }
+    /**
+   * Signs multiple Solana transactions
+   * @param transactions Array of base64 encoded serialized transactions
+   * @returns Array of signatures as base58 encoded strings
+   */ async signAllTransactions(transactions) {
+        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);
+            // 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
+            const signedTransaction = this.incorporateSignatureIntoTransaction(transaction, signature);
+            return signedTransaction;
+        });
+        // Wait for all transactions to be signed in parallel
+        const signedTransactions = await Promise.all(signaturePromises);
+        return {
+            transactions: signedTransactions
+        };
+    }
+    incorporateSignatureIntoTransaction(transaction, signature) {
+        // Decode base64 transaction to buffer
+        const transactionBuffer = buffer.Buffer.from(transaction, 'base64');
+        try {
+            // First try with legacy transaction format
+            const tx = web3_js.Transaction.from(transactionBuffer);
+            // Decode the base58 signature
+            const signatureBuffer = bs58__default.default.decode(signature);
+            // Add the signature to the transaction
+            tx.addSignature(new web3_js.PublicKey(this.address), buffer.Buffer.from(signatureBuffer));
+            // Serialize and encode back to base64
+            return buffer.Buffer.from(tx.serialize()).toString('base64');
+        } catch (error) {
+            if (error.message.includes('Versioned messages')) {
+                // Deserialize as a versioned transaction
+                const versionedTx = web3_js.VersionedTransaction.deserialize(transactionBuffer);
+                // Add the signature (convert from base58)
+                const signatureBuffer = bs58__default.default.decode(signature);
+                versionedTx.signatures[0] = buffer.Buffer.from(signatureBuffer);
+                // Serialize and encode back to base64
+                return buffer.Buffer.from(versionedTx.serialize()).toString('base64');
+            }
+            // If it's another type of error, rethrow it
+            throw error;
+        }
+    }
+    constructor(credentials, environment, pollerOptions){
+        this.APIKey = credentials.apiKey;
+        this.APIService = new APIService(credentials, environment);
+        this.pollerOptions = pollerOptions;
+    }
+}
+
+exports.APIService = APIService;
+exports.ApexSigner = ApexSigner;
+exports.DEFAULT_POLLER_OPTIONS = DEFAULT_POLLER_OPTIONS;
+exports.FystackSDK = FystackSDK;
+exports.PaymentService = PaymentService;
+exports.SolanaSigner = SolanaSigner;
+exports.StatusPoller = StatusPoller;
+exports.TransactionError = TransactionError;
+exports.WebhookService = WebhookService;
+exports.createAPI = createAPI;
+exports.get = get;
+exports.post = post;
+exports.transformCreateWalletPayload = transformCreateWalletPayload;
+exports.transformWalletDetail = transformWalletDetail;