@deserialize/multi-vm-wallet 1.0.0

package/dist/utils/evm/utils.d.ts

@@ -0,0 +1,92 @@
+import { Balance } from '../types';
+import { JsonRpcProvider, Wallet, TransactionReceipt } from 'ethers';
+interface TransactionParams {
+    to: string;
+    value?: string | bigint;
+    data?: string;
+    gasLimit?: string | bigint;
+    gasPrice?: string | bigint;
+    maxFeePerGas?: string | bigint;
+    maxPriorityFeePerGas?: string | bigint;
+    nonce?: number;
+}
+interface TransactionResult {
+    hash: string;
+    receipt: TransactionReceipt | null;
+    success: boolean;
+    gasUsed?: bigint;
+    effectiveGasPrice?: bigint;
+    blockNumber?: number;
+    confirmations: number;
+}
+export declare const getNativeBalance: (address: string, provider: JsonRpcProvider) => Promise<Balance>;
+export declare const getTokenBalance: (tokenAddress: string, walletAddress: string, provider: JsonRpcProvider) => Promise<Balance>;
+/**
+ * Sign, send, and confirm any EVM transaction
+ */
+export declare const signSendAndConfirm: (wallet: Wallet, transactionParams: TransactionParams, confirmations?: number, timeout?: number) => Promise<TransactionResult>;
+/**
+ * Send native token (ETH, BNB, MATIC, etc.)
+ */
+export declare const sendNativeToken: (wallet: Wallet, to: string, amount: string | bigint, gasLimit?: string | bigint, confirmations?: number) => Promise<TransactionResult>;
+/**
+ * Send ERC-20 token
+ */
+export declare const sendERC20Token: (wallet: Wallet, tokenAddress: string, to: string, amount: string | bigint, gasLimit?: string | bigint, confirmations?: number) => Promise<TransactionResult>;
+/**
+ * Execute any contract method
+ */
+export declare const executeContractMethod: (wallet: Wallet, contractAddress: string, abi: any[], methodName: string, methodParams?: any[], value?: string | bigint, gasLimit?: string | bigint, confirmations?: number) => Promise<TransactionResult>;
+/**
+ * Get current gas prices (both legacy and EIP-1559)
+ */
+export declare const getGasPrices: (provider: JsonRpcProvider) => Promise<{
+    gasPrice: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+}>;
+/**
+ * Estimate gas for a transaction
+ */
+export declare const estimateGas: (provider: JsonRpcProvider, transactionParams: TransactionParams) => Promise<bigint>;
+/**
+ * Check ERC-20 token allowance
+ */
+export declare const checkAllowance: (tokenAddress: string, owner: string, spender: string, provider: JsonRpcProvider) => Promise<{
+    allowance: bigint;
+    formatted: string;
+    decimals: number;
+}>;
+/**
+ * Check if allowance is sufficient for a transaction
+ */
+export declare const isAllowanceSufficient: (tokenAddress: string, owner: string, spender: string, requiredAmount: string | bigint, provider: JsonRpcProvider) => Promise<boolean>;
+/**
+ * Approve ERC-20 token spending
+ */
+export declare const approveToken: (wallet: Wallet, tokenAddress: string, spender: string, amount: string | bigint, gasLimit?: string | bigint, confirmations?: number) => Promise<TransactionResult>;
+/**
+ * Approve unlimited token spending (MaxUint256)
+ */
+export declare const approveTokenUnlimited: (wallet: Wallet, tokenAddress: string, spender: string, gasLimit?: string | bigint, confirmations?: number) => Promise<TransactionResult>;
+/**
+ * Check allowance and approve if necessary
+ */
+export declare const checkAndApprove: (wallet: Wallet, tokenAddress: string, spender: string, requiredAmount: string | bigint, approvalAmount?: string | bigint, gasLimit?: string | bigint, confirmations?: number) => Promise<{
+    approvalNeeded: boolean;
+    currentAllowance: bigint;
+    approvalResult?: TransactionResult;
+}>;
+/**
+ * Reset token allowance to zero (security best practice before setting new allowance)
+ */
+export declare const resetAllowance: (wallet: Wallet, tokenAddress: string, spender: string, gasLimit?: string | bigint, confirmations?: number) => Promise<TransactionResult>;
+/**
+ * Safe approve: Reset to zero first, then approve the desired amount
+ * (Some tokens like USDT require this)
+ */
+export declare const safeApprove: (wallet: Wallet, tokenAddress: string, spender: string, amount: string | bigint, gasLimit?: string | bigint, confirmations?: number) => Promise<{
+    resetResult: TransactionResult;
+    approveResult: TransactionResult;
+}>;
+export {};

package/dist/utils/evm/utils.js

@@ -0,0 +1,346 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeApprove = exports.resetAllowance = exports.checkAndApprove = exports.approveTokenUnlimited = exports.approveToken = exports.isAllowanceSufficient = exports.checkAllowance = exports.estimateGas = exports.getGasPrices = exports.executeContractMethod = exports.sendERC20Token = exports.sendNativeToken = exports.signSendAndConfirm = exports.getTokenBalance = exports.getNativeBalance = void 0;
+const ethers_1 = require("ethers");
+const bn_js_1 = __importDefault(require("bn.js"));
+// ERC-20 ABI
+const ERC20_ABI = [
+    "function balanceOf(address owner) view returns (uint256)",
+    "function decimals() view returns (uint8)",
+    "function symbol() view returns (string)",
+    "function name() view returns (string)",
+    "function transfer(address to, uint256 amount) returns (bool)",
+    "function transferFrom(address from, address to, uint256 amount) returns (bool)",
+    "function approve(address spender, uint256 amount) returns (bool)",
+    "function allowance(address owner, address spender) view returns (uint256)"
+];
+const getNativeBalance = async (address, provider) => {
+    const balance = await provider.getBalance(address);
+    return {
+        balance: new bn_js_1.default(balance),
+        formatted: Number(balance / 10n ** 18n),
+        decimal: 18
+    };
+};
+exports.getNativeBalance = getNativeBalance;
+const getTokenBalance = async (tokenAddress, walletAddress, provider) => {
+    try {
+        // Create contract instance
+        const tokenContract = new ethers_1.Contract(tokenAddress, ERC20_ABI, provider);
+        // Get balance (returns BigNumber)
+        const balance = await tokenContract.balanceOf(walletAddress);
+        // Get decimals to format the balance properly
+        const decimals = await tokenContract.decimals();
+        // Format balance by dividing by 10^decimals
+        const formattedBalance = balance / (10n ** BigInt(decimals));
+        return {
+            balance: new bn_js_1.default(balance.toString()), // Raw balance as BigNumber
+            formatted: Number(formattedBalance.toString()),
+            decimal: decimals
+        };
+    }
+    catch (error) {
+        console.error('Error fetching token balance:', error);
+        throw error;
+    }
+};
+exports.getTokenBalance = getTokenBalance;
+/**
+ * Sign, send, and confirm any EVM transaction
+ */
+const signSendAndConfirm = async (wallet, // Connected wallet (private key + provider)
+transactionParams, confirmations = 1, // Number of confirmations to wait for
+timeout = 300000 // 5 minutes timeout
+) => {
+    try {
+        // Prepare transaction object
+        const tx = {
+            to: transactionParams.to,
+            value: transactionParams.value || 0,
+            data: transactionParams.data || '0x',
+        };
+        // Set gas parameters
+        if (transactionParams.gasLimit) {
+            tx.gasLimit = transactionParams.gasLimit;
+        }
+        // Handle gas pricing (EIP-1559 vs legacy)
+        if (transactionParams.maxFeePerGas && transactionParams.maxPriorityFeePerGas) {
+            // EIP-1559 transaction
+            tx.maxFeePerGas = transactionParams.maxFeePerGas;
+            tx.maxPriorityFeePerGas = transactionParams.maxPriorityFeePerGas;
+        }
+        else if (transactionParams.gasPrice) {
+            // Legacy transaction
+            tx.gasPrice = transactionParams.gasPrice;
+        }
+        // Set nonce if provided
+        if (transactionParams.nonce !== undefined) {
+            tx.nonce = transactionParams.nonce;
+        }
+        // Estimate gas if not provided
+        if (!tx.gasLimit) {
+            tx.gasLimit = await wallet.estimateGas(tx);
+        }
+        console.log('Sending transaction:', tx);
+        // Sign and send transaction
+        const txResponse = await wallet.sendTransaction(tx);
+        console.log(`Transaction sent with hash: ${txResponse.hash}`);
+        // Wait for confirmation with timeout
+        const receipt = await Promise.race([
+            txResponse.wait(confirmations),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Transaction confirmation timeout')), timeout))
+        ]);
+        const result = {
+            hash: txResponse.hash,
+            receipt: receipt,
+            success: receipt?.status === 1,
+            gasUsed: receipt?.gasUsed,
+            effectiveGasPrice: receipt?.gasPrice,
+            blockNumber: receipt?.blockNumber,
+            confirmations: confirmations
+        };
+        console.log(`Transaction ${result.success ? 'successful' : 'failed'}:`, result);
+        return result;
+    }
+    catch (error) {
+        console.error('Transaction failed:', error);
+        throw error;
+    }
+};
+exports.signSendAndConfirm = signSendAndConfirm;
+/**
+ * Send native token (ETH, BNB, MATIC, etc.)
+ */
+const sendNativeToken = async (wallet, to, amount, // Amount in wei
+gasLimit, confirmations = 1) => {
+    return await (0, exports.signSendAndConfirm)(wallet, {
+        to,
+        value: (Number(amount) * 10 ** 18).toString(),
+        gasLimit
+    }, confirmations);
+};
+exports.sendNativeToken = sendNativeToken;
+/**
+ * Send ERC-20 token
+ */
+const sendERC20Token = async (wallet, tokenAddress, to, amount, // Amount in token's smallest unit
+gasLimit, confirmations = 1) => {
+    try {
+        // Create contract instance
+        const tokenContract = new ethers_1.Contract(tokenAddress, ERC20_ABI, wallet);
+        // Encode transfer function call
+        const data = tokenContract.interface.encodeFunctionData('transfer', [to, amount]);
+        return await (0, exports.signSendAndConfirm)(wallet, {
+            to: tokenAddress,
+            data,
+            gasLimit
+        }, confirmations);
+    }
+    catch (error) {
+        console.error('ERC-20 transfer failed:', error);
+        throw error;
+    }
+};
+exports.sendERC20Token = sendERC20Token;
+/**
+ * Execute any contract method
+ */
+const executeContractMethod = async (wallet, contractAddress, abi, methodName, methodParams = [], value, // For payable methods
+gasLimit, confirmations = 1) => {
+    try {
+        // Create contract instance
+        const contract = new ethers_1.Contract(contractAddress, abi, wallet);
+        // Encode method call
+        const data = contract.interface.encodeFunctionData(methodName, methodParams);
+        return await (0, exports.signSendAndConfirm)(wallet, {
+            to: contractAddress,
+            data,
+            value,
+            gasLimit
+        }, confirmations);
+    }
+    catch (error) {
+        console.error('Contract method execution failed:', error);
+        throw error;
+    }
+};
+exports.executeContractMethod = executeContractMethod;
+/**
+ * Get current gas prices (both legacy and EIP-1559)
+ */
+const getGasPrices = async (provider) => {
+    try {
+        const feeData = await provider.getFeeData();
+        return {
+            // Legacy
+            gasPrice: feeData.gasPrice,
+            // EIP-1559
+            maxFeePerGas: feeData.maxFeePerGas,
+            maxPriorityFeePerGas: feeData.maxPriorityFeePerGas
+        };
+    }
+    catch (error) {
+        console.error('Error fetching gas prices:', error);
+        throw error;
+    }
+};
+exports.getGasPrices = getGasPrices;
+/**
+ * Estimate gas for a transaction
+ */
+const estimateGas = async (provider, transactionParams) => {
+    try {
+        const tx = {
+            to: transactionParams.to,
+            value: transactionParams.value || 0,
+            data: transactionParams.data || '0x'
+        };
+        return await provider.estimateGas(tx);
+    }
+    catch (error) {
+        console.error('Gas estimation failed:', error);
+        throw error;
+    }
+};
+exports.estimateGas = estimateGas;
+/**
+ * Check ERC-20 token allowance
+ */
+const checkAllowance = async (tokenAddress, owner, spender, provider) => {
+    try {
+        const tokenContract = new ethers_1.Contract(tokenAddress, ERC20_ABI, provider);
+        // Get allowance and decimals
+        const [allowance, decimals] = await Promise.all([
+            tokenContract.allowance(owner, spender),
+            tokenContract.decimals()
+        ]);
+        // Format allowance for display
+        const formattedAllowance = allowance / (10n ** BigInt(decimals));
+        return {
+            allowance,
+            formatted: formattedAllowance.toString(),
+            decimals
+        };
+    }
+    catch (error) {
+        console.error('Error checking allowance:', error);
+        throw error;
+    }
+};
+exports.checkAllowance = checkAllowance;
+/**
+ * Check if allowance is sufficient for a transaction
+ */
+const isAllowanceSufficient = async (tokenAddress, owner, spender, requiredAmount, provider) => {
+    try {
+        const { allowance } = await (0, exports.checkAllowance)(tokenAddress, owner, spender, provider);
+        const required = typeof requiredAmount === 'string' ? BigInt(requiredAmount) : requiredAmount;
+        return allowance >= required;
+    }
+    catch (error) {
+        console.error('Error checking allowance sufficiency:', error);
+        throw error;
+    }
+};
+exports.isAllowanceSufficient = isAllowanceSufficient;
+/**
+ * Approve ERC-20 token spending
+ */
+const approveToken = async (wallet, tokenAddress, spender, amount, // Amount to approve, use MaxUint256 for unlimited
+gasLimit, confirmations = 1) => {
+    try {
+        const tokenContract = new ethers_1.Contract(tokenAddress, ERC20_ABI, wallet);
+        // Encode approve function call
+        const data = tokenContract.interface.encodeFunctionData('approve', [spender, amount]);
+        return await (0, exports.signSendAndConfirm)(wallet, {
+            to: tokenAddress,
+            data,
+            gasLimit
+        }, confirmations);
+    }
+    catch (error) {
+        console.error('Token approval failed:', error);
+        throw error;
+    }
+};
+exports.approveToken = approveToken;
+/**
+ * Approve unlimited token spending (MaxUint256)
+ */
+const approveTokenUnlimited = async (wallet, tokenAddress, spender, gasLimit, confirmations = 1) => {
+    // MaxUint256 = 2^256 - 1
+    const MAX_UINT256 = "115792089237316195423570985008687907853269984665640564039457584007913129639935";
+    return await (0, exports.approveToken)(wallet, tokenAddress, spender, MAX_UINT256, gasLimit, confirmations);
+};
+exports.approveTokenUnlimited = approveTokenUnlimited;
+/**
+ * Check allowance and approve if necessary
+ */
+const checkAndApprove = async (wallet, tokenAddress, spender, requiredAmount, approvalAmount, // If not provided, will approve exactly the required amount
+gasLimit, confirmations = 1) => {
+    try {
+        const owner = await wallet.getAddress();
+        const provider = wallet.provider;
+        // Check current allowance
+        const { allowance } = await (0, exports.checkAllowance)(tokenAddress, owner, spender, provider);
+        const required = typeof requiredAmount === 'string' ? BigInt(requiredAmount) : requiredAmount;
+        const approvalNeeded = allowance < required;
+        if (!approvalNeeded) {
+            return {
+                approvalNeeded: false,
+                currentAllowance: allowance
+            };
+        }
+        console.log(`Approval needed. Current: ${allowance}, Required: ${required}`);
+        // Determine approval amount
+        const amountToApprove = approvalAmount || required;
+        // Execute approval
+        const approvalResult = await (0, exports.approveToken)(wallet, tokenAddress, spender, amountToApprove, gasLimit, confirmations);
+        return {
+            approvalNeeded: true,
+            currentAllowance: allowance,
+            approvalResult
+        };
+    }
+    catch (error) {
+        console.error('Check and approve failed:', error);
+        throw error;
+    }
+};
+exports.checkAndApprove = checkAndApprove;
+/**
+ * Reset token allowance to zero (security best practice before setting new allowance)
+ */
+const resetAllowance = async (wallet, tokenAddress, spender, gasLimit, confirmations = 1) => {
+    return await (0, exports.approveToken)(wallet, tokenAddress, spender, "0", gasLimit, confirmations);
+};
+exports.resetAllowance = resetAllowance;
+/**
+ * Safe approve: Reset to zero first, then approve the desired amount
+ * (Some tokens like USDT require this)
+ */
+const safeApprove = async (wallet, tokenAddress, spender, amount, gasLimit, confirmations = 1) => {
+    try {
+        console.log('Performing safe approve: reset then approve');
+        // First reset to zero
+        const resetResult = await (0, exports.resetAllowance)(wallet, tokenAddress, spender, gasLimit, confirmations);
+        if (!resetResult.success) {
+            throw new Error('Failed to reset allowance to zero');
+        }
+        // Then approve the desired amount
+        const approveResult = await (0, exports.approveToken)(wallet, tokenAddress, spender, amount, gasLimit, confirmations);
+        return {
+            resetResult,
+            approveResult
+        };
+    }
+    catch (error) {
+        console.error('Safe approve failed:', error);
+        throw error;
+    }
+};
+exports.safeApprove = safeApprove;
+//swaps

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./bip32";
+export * from "./evm/evm";
+export * from "./types";
+export * from "./vm";
+export * from "./evm";
+export * from "./svm";

package/dist/utils/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bip32"), exports);
+__exportStar(require("./evm/evm"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./vm"), exports);
+__exportStar(require("./evm"), exports);
+__exportStar(require("./svm"), exports);

package/dist/utils/svm/index.d.ts

@@ -0,0 +1 @@
+export * from "./svm";

package/dist/utils/svm/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./svm"), exports);

package/dist/utils/svm/svm.d.ts

@@ -0,0 +1,24 @@
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import { VM } from "../vm";
+import { ChainWallet } from "../IChainWallet";
+import { Balance, ChainWalletConfig, TokenInfo, TransactionResult } from "../types";
+export declare class SVMVM extends VM<PublicKey, Keypair, Connection> {
+    derivationPath: string;
+    constructor(mnemonic: string);
+    static validateAddress(address: PublicKey): boolean;
+    static getNativeBalance(address: PublicKey, connection: Connection): Promise<Balance>;
+    static getTokenBalance(address: PublicKey, tokenAddress: PublicKey, connection: Connection): Promise<Balance>;
+    static signAndSendTransaction: (transaction: import("@solana/web3.js").VersionedTransaction, connection: Connection, signers: Keypair[]) => Promise<string>;
+    generatePrivateKey(index: number, seedPhrase?: string, derivationPath?: string): {
+        privateKey: Keypair;
+        index: number;
+    };
+}
+export declare class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection> {
+    constructor(config: ChainWalletConfig, privateKey: Keypair, index: number);
+    generateAddress(): PublicKey;
+    getNativeBalance(): Promise<Balance>;
+    getTokenBalance(tokenAddress: PublicKey): Promise<Balance>;
+    transferNative(to: PublicKey, amount: number): Promise<TransactionResult>;
+    transferToken(token: TokenInfo, to: PublicKey, amount: number): Promise<TransactionResult>;
+}

package/dist/utils/svm/svm.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SVMChainWallet = exports.SVMVM = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const bip32_1 = require("../bip32");
+const vm_1 = require("../vm");
+const IChainWallet_1 = require("../IChainWallet");
+const utils_1 = require("./utils");
+const bn_js_1 = __importDefault(require("bn.js"));
+class SVMVM extends vm_1.VM {
+    constructor(mnemonic) {
+        super(mnemonic, "SVM");
+        this.derivationPath = "m/44'/501'/"; // Default EVM derivation path
+    }
+    static validateAddress(address) {
+        return web3_js_1.PublicKey.isOnCurve(address.toBuffer());
+    }
+    static getNativeBalance(address, connection) {
+        return (0, utils_1.getSvmNativeBalance)(address, connection);
+    }
+    static async getTokenBalance(address, tokenAddress, connection) {
+        const balance = await (0, utils_1.getTokenBalance)(address, tokenAddress, connection);
+        if (balance === 0) {
+            return { balance: new bn_js_1.default(0), formatted: 0, decimal: 0 };
+        }
+        return { balance: new bn_js_1.default(balance.amount), formatted: balance.uiAmount || parseInt(balance.amount) / 10 ** balance.decimals, decimal: balance.decimals };
+    }
+    generatePrivateKey(index, seedPhrase = this.mnemonic, derivationPath = this.derivationPath) {
+        const seed = this.mnemonicToSeed(seedPhrase);
+        const privateKey = (0, bip32_1.SVMDeriveChildPrivateKey)(seed, index, derivationPath);
+        return { privateKey, index };
+    }
+}
+exports.SVMVM = SVMVM;
+SVMVM.signAndSendTransaction = utils_1.signAndSendTransaction;
+class SVMChainWallet extends IChainWallet_1.ChainWallet {
+    constructor(config, privateKey, index) {
+        super(config, privateKey, index);
+        this.address = privateKey.publicKey;
+        this.privateKey = privateKey;
+        this.connection = new web3_js_1.Connection(config.rpcUrl);
+    }
+    generateAddress() {
+        return this.address;
+    }
+    async getNativeBalance() {
+        // Implement native balance retrieval logic here
+        return await SVMVM.getNativeBalance(this.address, this.connection);
+    }
+    async getTokenBalance(tokenAddress) {
+        // Implement token balance retrieval logic here
+        return await SVMVM.getTokenBalance(this.address, (tokenAddress), this.connection);
+    }
+    async transferNative(to, amount) {
+        // Implement native transfer logic here
+        const transaction = await (0, utils_1.getTransferNativeTransaction)(this.privateKey, to, amount, this.connection);
+        const hash = await SVMVM.signAndSendTransaction(transaction, this.connection, [this.privateKey]);
+        return { success: true, hash }; // Placeholder
+    }
+    async transferToken(token, to, amount) {
+        // Implement token transfer logic here
+        const transaction = await (0, utils_1.getTransferTokenTransaction)(this.privateKey, new web3_js_1.PublicKey(to), token, (amount), this.connection);
+        const hash = await SVMVM.signAndSendTransaction(transaction, this.connection, [this.privateKey]);
+        return { success: true, hash }; // Placeholder
+    }
+}
+exports.SVMChainWallet = SVMChainWallet;
+//swaps jupiter swap here

package/dist/utils/svm/transactionSender.d.ts

@@ -0,0 +1,8 @@
+import { BlockhashWithExpiryBlockHeight, Connection, VersionedTransactionResponse } from "@solana/web3.js";
+type TransactionSenderAndConfirmationWaiterArgs = {
+    connection: Connection;
+    serializedTransaction: Buffer;
+    blockhashWithExpiryBlockHeight: BlockhashWithExpiryBlockHeight;
+};
+export declare function transactionSenderAndConfirmationWaiter({ connection, serializedTransaction, blockhashWithExpiryBlockHeight, }: TransactionSenderAndConfirmationWaiterArgs): Promise<VersionedTransactionResponse | null>;
+export {};

package/dist/utils/svm/transactionSender.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactionSenderAndConfirmationWaiter = transactionSenderAndConfirmationWaiter;
+const web3_js_1 = require("@solana/web3.js");
+const promise_retry_1 = __importDefault(require("promise-retry"));
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const SEND_OPTIONS = {
+    skipPreflight: false,
+};
+async function transactionSenderAndConfirmationWaiter({ connection, serializedTransaction, blockhashWithExpiryBlockHeight, }) {
+    const txid = await connection.sendRawTransaction(serializedTransaction, SEND_OPTIONS);
+    const controller = new AbortController();
+    const abortSignal = controller.signal;
+    const abortableResender = async () => {
+        while (true) {
+            await wait(2000);
+            if (abortSignal.aborted)
+                return;
+            try {
+                await connection.sendRawTransaction(serializedTransaction, SEND_OPTIONS);
+            }
+            catch (e) {
+                console.warn(`Failed to resend transaction: ${e}`);
+            }
+        }
+    };
+    try {
+        abortableResender();
+        const lastValidBlockHeight = blockhashWithExpiryBlockHeight.lastValidBlockHeight - 150;
+        // this would throw TransactionExpiredBlockheightExceededError
+        await Promise.race([
+            connection.confirmTransaction({
+                ...blockhashWithExpiryBlockHeight,
+                lastValidBlockHeight,
+                signature: txid,
+                abortSignal,
+            }, "confirmed"),
+            new Promise(async (resolve) => {
+                // in case ws socket died
+                while (!abortSignal.aborted) {
+                    await wait(2000);
+                    const tx = await connection.getSignatureStatus(txid, {
+                        searchTransactionHistory: false,
+                    });
+                    if (tx?.value?.confirmationStatus === "confirmed") {
+                        resolve(tx);
+                    }
+                }
+            }),
+        ]);
+    }
+    catch (e) {
+        if (e instanceof web3_js_1.TransactionExpiredBlockheightExceededError) {
+            // we consume this error and getTransaction would return null
+            return null;
+        }
+        else {
+            // invalid state from web3.js
+            throw e;
+        }
+    }
+    finally {
+        controller.abort();
+    }
+    // in case rpc is not synced yet, we add some retries
+    const response = (0, promise_retry_1.default)(async (retry) => {
+        const response = await connection.getTransaction(txid, {
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0,
+        });
+        if (!response) {
+            retry(response);
+        }
+        return response;
+    }, {
+        retries: 5,
+        minTimeout: 1e3,
+    });
+    return response;
+}