@deserialize/multi-vm-wallet 1.0.0 → 1.0.2

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

@@ -1,7 +1,7 @@
 /**
  *
  * @param phrase this is the pass phrase for this vm
- * this is a class that will be responsible for creating several evm wallets
+ * this is a class that will be responsible for creating several evm wallets code
  */
 import { ChainWallet } from "../IChainWallet";
 import { Balance, ChainWalletConfig, TokenInfo, TransactionResult } from "../types";
@@ -10,11 +10,12 @@ import { JsonRpcProvider, Wallet } from "ethers";
 export declare const createEvmVmPrivateKey: (phrase: string) => void;
 export declare class EVMVM extends VM<string, string, JsonRpcProvider> {
     derivationPath: string;
-    constructor(mnemonic: string);
-    generatePrivateKey(index: number, seedPhrase?: string, derivationPath?: string): {
+    constructor(seed: string);
+    generatePrivateKey(index: number, seed?: string, mnemonic?: string, derivationPath?: string): {
         privateKey: string;
         index: number;
     };
+    static fromMnemonic(seed: string): VM<string, string, JsonRpcProvider>;
     validateAddress(address: string): boolean;
     static getNativeBalance(address: string, connection: JsonRpcProvider): Promise<Balance>;
     static getTokenBalance(address: string, tokenAddress: string, connection: JsonRpcProvider): Promise<Balance>;
@@ -27,4 +28,12 @@ export declare class EVMChainWallet extends ChainWallet<string, string, JsonRpcP
     getTokenBalance(tokenAddress: string): Promise<Balance>;
     transferNative(to: string, amount: number): Promise<TransactionResult>;
     transferToken(tokenAddress: TokenInfo, to: string, amount: number): Promise<TransactionResult>;
+    swap(tokenAddress: TokenInfo, to: string, amount: number, slippage?: number): Promise<TransactionResult>;
+    performCompleteSwap(tokenIn: TokenInfo, tokenOut: TokenInfo, amount: number, slippage?: number, recipient?: string, deadline?: number): Promise<TransactionResult>;
+    getSwapQuote(tokenIn: TokenInfo, tokenOut: TokenInfo, amount: number): Promise<{
+        amountOut: string;
+        priceImpact: string;
+        gasEstimate: string;
+        route: string[];
+    }>;
 }

package/dist/utils/evm/evm.js

@@ -2,27 +2,43 @@
 /**
  *
  * @param phrase this is the pass phrase for this vm
- * this is a class that will be responsible for creating several evm wallets
+ * this is a class that will be responsible for creating several evm wallets code
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMChainWallet = exports.EVMVM = exports.createEvmVmPrivateKey = void 0;
 const bip32_1 = require("../bip32");
 const IChainWallet_1 = require("../IChainWallet");
 const vm_1 = require("../vm");
 const ethers_1 = require("ethers");
+const bn_js_1 = __importDefault(require("bn.js"));
 const utils_1 = require("./utils");
 const createEvmVmPrivateKey = (phrase) => { };
 exports.createEvmVmPrivateKey = createEvmVmPrivateKey;
 class EVMVM extends vm_1.VM {
-    constructor(mnemonic) {
-        super(mnemonic, "EVM");
+    constructor(seed) {
+        super(seed, "EVM");
         this.derivationPath = "m/44'/60'/0'/0/"; // Default EVM derivation path
     }
-    generatePrivateKey(index, seedPhrase = this.mnemonic, derivationPath = this.derivationPath) {
-        const seed = this.mnemonicToSeed(seedPhrase);
-        const privateKey = (0, bip32_1.EVMDeriveChildPrivateKey)(seed, index, derivationPath).privateKey;
+    generatePrivateKey(index, seed, mnemonic, derivationPath = this.derivationPath) {
+        let _seed;
+        if (seed) {
+            _seed = seed;
+        }
+        else if (mnemonic) {
+            _seed = vm_1.VM.mnemonicToSeed(mnemonic);
+        }
+        else {
+            _seed = this.seed;
+        }
+        const privateKey = (0, bip32_1.EVMDeriveChildPrivateKey)(_seed, index, derivationPath).privateKey;
         return { privateKey, index };
     }
+    static fromMnemonic(seed) {
+        return new EVMVM(seed);
+    }
     validateAddress(address) {
         return ethers_1.ethers.isAddress(address);
     }
@@ -45,7 +61,7 @@ class EVMChainWallet extends IChainWallet_1.ChainWallet {
         this.connection = new ethers_1.JsonRpcProvider(config.rpcUrl);
     }
     getWallet() {
-        return new ethers_1.Wallet(this.privateKey);
+        return new ethers_1.Wallet(this.privateKey, this.connection);
     }
     generateAddress() {
         return this.address;
@@ -68,5 +84,150 @@ class EVMChainWallet extends IChainWallet_1.ChainWallet {
         const wallet = this.getWallet();
         return await (0, utils_1.sendERC20Token)(wallet, tokenAddress.address, to, amount.toString(), undefined, this.config.confirmationNo || 5);
     }
+    // Updated swap method signature to match base class so created another method to use it inside swap
+    async swap(tokenAddress, to, amount, slippage = 50) {
+        if (amount <= 0) {
+            return {
+                success: false,
+                hash: "",
+                error: "Amount must be greater than 0"
+            };
+        }
+        const tokenOut = {
+            address: to,
+            name: '',
+            symbol: '',
+            decimals: 18
+        };
+        return await this.performCompleteSwap(tokenAddress, tokenOut, amount, slippage);
+    }
+    async performCompleteSwap(tokenIn, tokenOut, amount, slippage = 50, recipient, deadline) {
+        try {
+            const wallet = this.getWallet();
+            const chainId = (await this.connection.getNetwork()).chainId.toString();
+            console.log(` Starting swap on chain ${chainId}:`, {
+                from: tokenIn.symbol || tokenIn.address,
+                to: tokenOut.symbol || tokenOut.address,
+                amount: amount,
+                slippage: `${slippage / 100}%`
+            });
+            if (!(0, utils_1.isChainSupportedByKyber)(chainId)) {
+                throw new Error(`Chain ${chainId} is not supported by KyberSwap`);
+            }
+            const isNativeIn = tokenIn.address === 'native' ||
+                tokenIn.address.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+            const isNativeOut = tokenOut.address === 'native' ||
+                tokenOut.address.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+            let tokenInDecimals = 18;
+            if (!isNativeIn && tokenIn.decimals) {
+                tokenInDecimals = tokenIn.decimals;
+            }
+            else if (!isNativeIn) {
+                const tokenBalance = await this.getTokenBalance(tokenIn.address);
+                tokenInDecimals = tokenBalance.decimal;
+            }
+            const { tokenInAddress, tokenOutAddress, formattedAmountIn } = (0, utils_1.prepareSwapParams)(tokenIn.address, tokenOut.address, amount.toString(), tokenInDecimals, isNativeIn, isNativeOut);
+            console.log('Swap parameters:', {
+                tokenInAddress,
+                tokenOutAddress,
+                formattedAmountIn,
+                tokenInDecimals
+            });
+            if (isNativeIn) {
+                const nativeBalance = await this.getNativeBalance();
+                const requiredAmount = new bn_js_1.default(formattedAmountIn);
+                if (nativeBalance.balance.lt(requiredAmount)) {
+                    throw new Error(`Insufficient native balance. Required: ${amount}, Available: ${nativeBalance.formatted}`);
+                }
+            }
+            else {
+                const tokenBalance = await this.getTokenBalance(tokenIn.address);
+                const requiredAmount = new bn_js_1.default(formattedAmountIn);
+                if (tokenBalance.balance.lt(requiredAmount)) {
+                    throw new Error(`Insufficient token balance. Required: ${amount}, Available: ${tokenBalance.formatted}`);
+                }
+            }
+            const swapTx = await (0, utils_1.performSwap)({
+                chainId,
+                tokenIn: tokenInAddress,
+                tokenOut: tokenOutAddress,
+                amountIn: formattedAmountIn,
+                sender: this.address,
+                recipient: recipient || this.address,
+                slippageTolerance: slippage,
+                deadline: deadline ? Math.floor(Date.now() / 1000) + deadline : Math.floor(Date.now() / 1000) + 1200, // 20 minutes default
+                clientId: 'EVMChainWallet'
+            });
+            console.log('Swap transaction prepared:', {
+                to: swapTx.to,
+                dataLength: swapTx.data?.length || 0,
+                gasLimit: swapTx.gasLimit?.toString(),
+                value: swapTx.value?.toString()
+            });
+            if (!isNativeIn) {
+                console.log('Checking token approval...');
+                const approvalResult = await (0, utils_1.checkAndApprove)(wallet, tokenIn.address, swapTx.to, formattedAmountIn, undefined, undefined, this.config.confirmationNo || 1);
+                if (approvalResult.approvalNeeded && approvalResult.approvalResult) {
+                    if (!approvalResult.approvalResult.success) {
+                        throw new Error('Token approval failed');
+                    }
+                    console.log('Token approval successful');
+                }
+                else if (approvalResult.approvalNeeded) {
+                    throw new Error('Token approval was needed but failed');
+                }
+                else {
+                    console.log('Token approval not needed - sufficient allowance');
+                }
+            }
+            const result = await (0, utils_1.signSendAndConfirm)(wallet, {
+                to: swapTx.to,
+                data: swapTx.data,
+                value: swapTx.value || '0',
+                gasLimit: swapTx.gasLimit
+            }, this.config.confirmationNo || 1);
+            if (result.success) {
+                console.log(' Swap completed successfully:', {
+                    hash: result.hash,
+                    gasUsed: result.gasUsed?.toString(),
+                    blockNumber: result.blockNumber
+                });
+            }
+            else {
+                console.log(' Swap failed:', result);
+            }
+            return result;
+        }
+        catch (error) {
+            console.error('Swap failed:', error);
+            throw new Error(`Swap failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async getSwapQuote(tokenIn, tokenOut, amount) {
+        try {
+            const chainId = (await this.connection.getNetwork()).chainId.toString();
+            if (!(0, utils_1.isChainSupportedByKyber)(chainId)) {
+                throw new Error(`Chain ${chainId} is not supported by KyberSwap`);
+            }
+            const isNativeIn = tokenIn.address === 'native' ||
+                tokenIn.address.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+            const isNativeOut = tokenOut.address === 'native' ||
+                tokenOut.address.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+            let tokenInDecimals = 18;
+            if (!isNativeIn && tokenIn.decimals) {
+                tokenInDecimals = tokenIn.decimals;
+            }
+            else if (!isNativeIn) {
+                const tokenBalance = await this.getTokenBalance(tokenIn.address);
+                tokenInDecimals = tokenBalance.decimal;
+            }
+            const { tokenInAddress, tokenOutAddress, formattedAmountIn } = (0, utils_1.prepareSwapParams)(tokenIn.address, tokenOut.address, amount.toString(), tokenInDecimals, isNativeIn, isNativeOut);
+            throw new Error("Quote functionality requires direct API integration - use the swap method for full execution");
+        }
+        catch (error) {
+            console.error('Error getting swap quote:', error);
+            throw error;
+        }
+    }
 }
 exports.EVMChainWallet = EVMChainWallet;

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

@@ -1,6 +1,6 @@
 import { Balance } from '../types';
 import { JsonRpcProvider, Wallet, TransactionReceipt } from 'ethers';
-interface TransactionParams {
+export interface TransactionParams {
     to: string;
     value?: string | bigint;
     data?: string;
@@ -19,6 +19,92 @@ interface TransactionResult {
     blockNumber?: number;
     confirmations: number;
 }
+export interface SwapParams {
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: string;
+    slippageTolerance?: number;
+    recipient?: string;
+    deadline?: number;
+    feeAmount?: string;
+    feeReceiver?: string;
+    isInBps?: boolean;
+    chargeFeeBy?: 'currency_in' | 'currency_out';
+}
+export interface KyberRoute {
+    tokenIn: string;
+    amountIn: string;
+    tokenOut: string;
+    amountOut: string;
+    gas: string;
+    gasPrice: string;
+    gasUsd: number;
+    amountOutUsd: string;
+    receivedUsd: string;
+    swaps: Array<{
+        pool: string;
+        tokenIn: string;
+        tokenOut: string;
+        swapAmount: string;
+        amountOut: string;
+        limitReturnAmount: string;
+        maxPrice: string;
+        exchange: string;
+        poolLength: number;
+        poolType: string;
+    }>;
+    tokens: {
+        [address: string]: {
+            address: string;
+            symbol: string;
+            name: string;
+            decimals: number;
+            price: number;
+        };
+    };
+}
+export interface KyberSwapResponse {
+    code: number;
+    message: string;
+    data: {
+        routeSummary: KyberRoute;
+        routerAddress: string;
+    };
+}
+export interface KyberBuildResponse {
+    code: number;
+    message: string;
+    data: {
+        amountIn: string;
+        amountInUsd: string;
+        amountOut: string;
+        amountOutUsd: string;
+        gas: string;
+        gasUsd: string;
+        outputChange: {
+            amount: string;
+            percent: number;
+            level: number;
+        };
+        data: string;
+        routerAddress: string;
+    };
+}
+interface KyberSwapParams {
+    chainId: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: string;
+    slippageTolerance?: number;
+    recipient?: string;
+    sender?: string;
+    deadline?: number;
+    feeAmount?: string;
+    feeReceiver?: string;
+    isInBps?: boolean;
+    chargeFeeBy?: 'currency_in' | 'currency_out';
+    clientId?: string;
+}
 export declare const getNativeBalance: (address: string, provider: JsonRpcProvider) => Promise<Balance>;
 export declare const getTokenBalance: (tokenAddress: string, walletAddress: string, provider: JsonRpcProvider) => Promise<Balance>;
 /**
@@ -89,4 +175,33 @@ export declare const safeApprove: (wallet: Wallet, tokenAddress: string, spender
     resetResult: TransactionResult;
     approveResult: TransactionResult;
 }>;
+export declare function getKyberSwapRoute(params: KyberSwapParams): Promise<KyberSwapResponse>;
+export declare function buildKyberSwapTransaction(chainId: string, routeSummary: KyberRoute, sender: string, recipient: string, slippageTolerance?: number, deadline?: number, clientId?: string): Promise<KyberBuildResponse>;
+export declare function performSwap(params: {
+    chainId: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: string;
+    sender: string;
+    recipient?: string;
+    slippageTolerance?: number;
+    deadline?: number;
+    feeAmount?: string;
+    feeReceiver?: string;
+    isInBps?: boolean;
+    chargeFeeBy?: 'currency_in' | 'currency_out';
+    clientId?: string;
+}): Promise<TransactionParams>;
+export declare function getKyberSupportedChains(): {
+    [key: string]: string;
+};
+export declare function isChainSupportedByKyber(chainId: string): boolean;
+export declare function getNativeTokenAddress(): string;
+export declare function formatAmountToWei(amount: string, decimals: number): string;
+export declare function formatAmountFromWei(amountWei: string, decimals: number): string;
+export declare function prepareSwapParams(tokenIn: string, tokenOut: string, amountIn: string, tokenInDecimals: number, isNativeIn?: boolean, isNativeOut?: boolean): {
+    tokenInAddress: string;
+    tokenOutAddress: string;
+    formattedAmountIn: string;
+};
 export {};

package/dist/utils/evm/utils.js

@@ -4,8 +4,30 @@ var __importDefault = (this && this.__importDefault) || function (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;
+exports.getKyberSwapRoute = getKyberSwapRoute;
+exports.buildKyberSwapTransaction = buildKyberSwapTransaction;
+exports.performSwap = performSwap;
+exports.getKyberSupportedChains = getKyberSupportedChains;
+exports.isChainSupportedByKyber = isChainSupportedByKyber;
+exports.getNativeTokenAddress = getNativeTokenAddress;
+exports.formatAmountToWei = formatAmountToWei;
+exports.formatAmountFromWei = formatAmountFromWei;
+exports.prepareSwapParams = prepareSwapParams;
 const ethers_1 = require("ethers");
 const bn_js_1 = __importDefault(require("bn.js"));
+const KYBER_BASE_URL = 'https://aggregator-api.kyberswap.com';
+const KYBER_SUPPORTED_CHAINS = {
+    '1': 'ethereum',
+    '137': 'polygon',
+    '56': 'bsc',
+    '43114': 'avalanche',
+    '250': 'fantom',
+    '42161': 'arbitrum',
+    '10': 'optimism',
+    '8453': 'base',
+    '324': 'zksync',
+    '59144': 'linea'
+};
 // ERC-20 ABI
 const ERC20_ABI = [
     "function balanceOf(address owner) view returns (uint256)",
@@ -344,3 +366,172 @@ const safeApprove = async (wallet, tokenAddress, spender, amount, gasLimit, conf
 };
 exports.safeApprove = safeApprove;
 //swaps
+//kyber swap here
+//docs -. https://docs.kyberswap.com/kyberswap-solutions/kyberswap-aggregator/developer-guides/execute-a-swap-with-the-aggregator-api
+// the major constrain is that each function should return a transaction to sign, do not sign transaction or send transaction within util functions
+// let the ChainWalletClass be the one to sign and send,
+//so in you chainWallet.swap, you can have the futil swap function to get the transaction then another function to sign and send and confirm the transaction
+async function getKyberSwapRoute(params) {
+    const chainName = KYBER_SUPPORTED_CHAINS[params.chainId];
+    if (!chainName) {
+        throw new Error(`Unsupported chain ID: ${params.chainId}`);
+    }
+    const queryParams = new URLSearchParams({
+        tokenIn: params.tokenIn,
+        tokenOut: params.tokenOut,
+        amountIn: params.amountIn,
+    });
+    if (params.feeAmount)
+        queryParams.append('feeAmount', params.feeAmount);
+    if (params.feeReceiver)
+        queryParams.append('feeReceiver', params.feeReceiver);
+    if (params.isInBps !== undefined)
+        queryParams.append('isInBps', params.isInBps.toString());
+    if (params.chargeFeeBy)
+        queryParams.append('chargeFeeBy', params.chargeFeeBy);
+    const url = `${KYBER_BASE_URL}/${chainName}/api/v1/routes?${queryParams}`;
+    const headers = {};
+    if (params.clientId) {
+        headers['x-client-id'] = params.clientId;
+    }
+    try {
+        const response = await fetch(url, { headers });
+        const data = await response.json();
+        if (!response.ok) {
+            throw new Error(`KyberSwap API error: ${data.message || response.statusText}`);
+        }
+        return data;
+    }
+    catch (error) {
+        console.error('Error fetching KyberSwap route:', error);
+        throw error;
+    }
+}
+async function buildKyberSwapTransaction(chainId, routeSummary, sender, recipient, slippageTolerance = 50, deadline, clientId) {
+    const chainName = KYBER_SUPPORTED_CHAINS[chainId];
+    if (!chainName) {
+        throw new Error(`Unsupported chain ID: ${chainId}`);
+    }
+    const url = `${KYBER_BASE_URL}/${chainName}/api/v1/route/build`;
+    const txDeadline = deadline || Math.floor(Date.now() / 1000) + 1200;
+    const body = {
+        routeSummary,
+        sender,
+        recipient,
+        slippageTolerance,
+        deadline: txDeadline,
+        source: clientId || 'MyWalletApp'
+    };
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (clientId) {
+        headers['x-client-id'] = clientId;
+    }
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body)
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            throw new Error(`KyberSwap build API error: ${data.message || response.statusText}`);
+        }
+        return data;
+    }
+    catch (error) {
+        console.error('Error building KyberSwap transaction:', error);
+        throw error;
+    }
+}
+async function performSwap(params) {
+    try {
+        console.log('Starting KyberSwap aggregation...', {
+            tokenIn: params.tokenIn,
+            tokenOut: params.tokenOut,
+            amountIn: params.amountIn,
+            chainId: params.chainId
+        });
+        console.log('Fetching best swap route across all DEXs...');
+        const routeResponse = await getKyberSwapRoute({
+            chainId: params.chainId,
+            tokenIn: params.tokenIn,
+            tokenOut: params.tokenOut,
+            amountIn: params.amountIn,
+            feeAmount: params.feeAmount,
+            feeReceiver: params.feeReceiver,
+            isInBps: params.isInBps,
+            chargeFeeBy: params.chargeFeeBy,
+            clientId: params.clientId || 'MyWalletApp'
+        });
+        if (!routeResponse.data || !routeResponse.data.routeSummary) {
+            throw new Error('No valid route found for the swap');
+        }
+        const { routeSummary, routerAddress } = routeResponse.data;
+        console.log('✅ Best route found:', {
+            tokenIn: routeSummary.tokenIn,
+            tokenOut: routeSummary.tokenOut,
+            amountIn: routeSummary.amountIn,
+            amountOut: routeSummary.amountOut,
+            gasEstimate: routeSummary.gas,
+            routerAddress,
+            dexSources: routeSummary.swaps.map(swap => swap.exchange)
+        });
+        console.log(' Building executable transaction...');
+        const buildResponse = await buildKyberSwapTransaction(params.chainId, routeSummary, params.sender, params.recipient || params.sender, params.slippageTolerance || 50, params.deadline, params.clientId || 'MyWalletApp');
+        if (!buildResponse.data || !buildResponse.data.data) {
+            throw new Error('Failed to build transaction data');
+        }
+        const { data: encodedData, gas, routerAddress: finalRouterAddress } = buildResponse.data;
+        console.log('✅ Transaction built successfully:', {
+            to: finalRouterAddress,
+            dataLength: encodedData.length,
+            gasEstimate: gas,
+            expectedOutput: buildResponse.data.amountOut
+        });
+        return {
+            to: finalRouterAddress,
+            data: encodedData,
+            gasLimit: gas,
+            value: params.tokenIn.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
+                ? params.amountIn
+                : '0'
+        };
+    }
+    catch (error) {
+        console.error('❌ KyberSwap aggregation failed:', error);
+        throw new Error(`Swap preparation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+function getKyberSupportedChains() {
+    return { ...KYBER_SUPPORTED_CHAINS };
+}
+function isChainSupportedByKyber(chainId) {
+    return chainId in KYBER_SUPPORTED_CHAINS;
+}
+function getNativeTokenAddress() {
+    return '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+}
+function formatAmountToWei(amount, decimals) {
+    const amountBN = new bn_js_1.default(amount);
+    const multiplier = new bn_js_1.default(10).pow(new bn_js_1.default(decimals));
+    return amountBN.mul(multiplier).toString();
+}
+function formatAmountFromWei(amountWei, decimals) {
+    const amountBN = new bn_js_1.default(amountWei);
+    const divisor = new bn_js_1.default(10).pow(new bn_js_1.default(decimals));
+    return amountBN.div(divisor).toString();
+}
+function prepareSwapParams(tokenIn, tokenOut, amountIn, tokenInDecimals, isNativeIn = false, isNativeOut = false) {
+    const tokenInAddress = isNativeIn ? getNativeTokenAddress() : tokenIn;
+    const tokenOutAddress = isNativeOut ? getNativeTokenAddress() : tokenOut;
+    const formattedAmountIn = amountIn.includes('.')
+        ? formatAmountToWei(amountIn, tokenInDecimals)
+        : amountIn;
+    return {
+        tokenInAddress,
+        tokenOutAddress,
+        formattedAmountIn
+    };
+}

package/dist/utils/index.d.ts

@@ -4,3 +4,4 @@ export * from "./types";
 export * from "./vm";
 export * from "./evm";
 export * from "./svm";
+export * from "./types";

package/dist/utils/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./vm"), exports);
 __exportStar(require("./evm"), exports);
 __exportStar(require("./svm"), exports);
+__exportStar(require("./types"), exports);

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

@@ -2,17 +2,19 @@ import { Connection, Keypair, PublicKey } from "@solana/web3.js";
 import { VM } from "../vm";
 import { ChainWallet } from "../IChainWallet";
 import { Balance, ChainWalletConfig, TokenInfo, TransactionResult } from "../types";
+import { JupiterQuoteResponse } from "./utils";
 export declare class SVMVM extends VM<PublicKey, Keypair, Connection> {
     derivationPath: string;
-    constructor(mnemonic: string);
+    constructor(seed: 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): {
+    generatePrivateKey(index: number, seed?: string, mnemonic?: string, derivationPath?: string): {
         privateKey: Keypair;
         index: number;
     };
+    static fromMnemonic(seed: string): VM<PublicKey, Keypair, Connection>;
 }
 export declare class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection> {
     constructor(config: ChainWalletConfig, privateKey: Keypair, index: number);
@@ -21,4 +23,14 @@ export declare class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Conn
     getTokenBalance(tokenAddress: PublicKey): Promise<Balance>;
     transferNative(to: PublicKey, amount: number): Promise<TransactionResult>;
     transferToken(token: TokenInfo, to: PublicKey, amount: number): Promise<TransactionResult>;
+    swap(fromToken: TokenInfo, toToken: PublicKey, amount: number, slippage?: number): Promise<TransactionResult>;
+    getSwapQuote(fromToken: TokenInfo, toToken: PublicKey, amount: number, slippage?: number): Promise<{
+        success: boolean;
+        inputAmount?: string;
+        outputAmount?: string;
+        priceImpact?: string;
+        routePlan?: JupiterQuoteResponse['routePlan'];
+        slippageBps?: number;
+        error?: string;
+    }>;
 }