@deserialize/multi-vm-wallet 1.0.0 → 1.0.1

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

@@ -1,6 +1,54 @@
 import { Account } from "@solana/spl-token";
 import { Connection, Keypair, PublicKey, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
 import { TokenInfo } from "../types";
+export interface JupiterQuoteResponse {
+    inputMint: string;
+    inAmount: string;
+    outputMint: string;
+    outAmount: string;
+    otherAmountThreshold: string;
+    swapMode: string;
+    slippageBps: number;
+    platformFee: null | any;
+    priceImpactPct: string;
+    routePlan: RoutePlan[];
+    contextSlot: number;
+    timeTaken: number;
+}
+interface RoutePlan {
+    swapInfo: SwapInfo;
+    percent: number;
+}
+interface SwapInfo {
+    ammKey: string;
+    label: string;
+    inputMint: string;
+    outputMint: string;
+    inAmount: string;
+    outAmount: string;
+    feeAmount: string;
+    feeMint: string;
+}
+interface JupiterSwapResponse {
+    swapTransaction: string;
+    lastValidBlockHeight: number;
+    prioritizationFeeLamports: number;
+}
+interface SwapParams {
+    fromToken: PublicKey;
+    toToken: PublicKey;
+    amount: number;
+    slippageBps?: number;
+    userPublicKey: PublicKey;
+}
+interface SwapResult {
+    success: boolean;
+    hash?: string;
+    error?: string;
+    inputAmount?: string;
+    outputAmount?: string;
+    priceImpact?: string;
+}
 export declare const createV0Transaction: (connection: Connection, inX: TransactionInstruction[], signers: Keypair[], payerPubKey: PublicKey, blockHash?: string) => Promise<VersionedTransaction>;
 export declare const createAtaAndIx: (token: PublicKey, ownerPublicKey: PublicKey, tokenProgramId: PublicKey, connection: Connection) => Promise<{
     AtaTokenIx: any;
@@ -24,3 +72,14 @@ export declare const getTransferNativeTransaction: (from: Keypair, to: PublicKey
 export declare const getTransferTokenInx: (from: PublicKey, to: PublicKey, token: TokenInfo, amount: number, connection: Connection) => Promise<TransactionInstruction[]>;
 export declare const getTransferTokenTransaction: (from: Keypair, to: PublicKey, token: TokenInfo, amount: number, connection: Connection) => Promise<VersionedTransaction>;
 export declare const signAndSendTransaction: (transaction: VersionedTransaction, connection: Connection, signers: Keypair[]) => Promise<string>;
+export declare const getJupiterQuote: (inputMint: string, outputMint: string, amount: number, slippageBps?: number) => Promise<JupiterQuoteResponse>;
+export declare const buildJupiterSwapTransaction: (quote: JupiterQuoteResponse, userPublicKey: string, prioritizationFeeLamports?: number) => Promise<JupiterSwapResponse>;
+export declare const executeJupiterSwap: (swapParams: SwapParams, connection: Connection, payer: Keypair) => Promise<SwapResult>;
+export declare const uiAmountToBaseUnits: (uiAmount: number, decimals: number) => number;
+export declare const baseUnitsToUiAmount: (baseAmount: string | number, decimals: number) => number;
+export declare const getJupiterTokenList: () => Promise<any[]>;
+export declare const validateJupiterTokens: (inputMint: string, outputMint: string) => Promise<{
+    valid: boolean;
+    message?: string;
+}>;
+export {};

package/dist/utils/svm/utils.js

@@ -1,11 +1,12 @@
 "use strict";
 //we will write all the svm utils function here
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.signAndSendTransaction = exports.getTransferTokenTransaction = exports.getTransferTokenInx = exports.getTransferNativeTransaction = exports.getTransferNativeInx = exports.getTokenAccountAccount = exports.getTokenBalance = exports.getSvmNativeBalance = exports.getProgramIdOfToken = exports.getSureAssociatedTokenAddressAndAccount = exports.createAtaAndIx = exports.createV0Transaction = void 0;
+exports.validateJupiterTokens = exports.getJupiterTokenList = exports.baseUnitsToUiAmount = exports.uiAmountToBaseUnits = exports.executeJupiterSwap = exports.buildJupiterSwapTransaction = exports.getJupiterQuote = exports.signAndSendTransaction = exports.getTransferTokenTransaction = exports.getTransferTokenInx = exports.getTransferNativeTransaction = exports.getTransferNativeInx = exports.getTokenAccountAccount = exports.getTokenBalance = exports.getSvmNativeBalance = exports.getProgramIdOfToken = exports.getSureAssociatedTokenAddressAndAccount = exports.createAtaAndIx = exports.createV0Transaction = void 0;
 const spl_token_1 = require("@solana/spl-token");
 const web3_js_1 = require("@solana/web3.js");
 const transactionSender_1 = require("./transactionSender");
 const bn_js_1 = require("bn.js");
+const JUPITER_BASE_URL = 'https://lite-api.jup.ag';
 const createV0Transaction = async (connection, inX, signers, payerPubKey, blockHash) => {
     const blockhash = blockHash || (await connection.getLatestBlockhash()).blockhash;
     const message = new web3_js_1.TransactionMessage({
@@ -71,7 +72,7 @@ const getProgramIdOfToken = async (owner, token, connection) => {
     }
 };
 exports.getProgramIdOfToken = getProgramIdOfToken;
-//get native balance 
+//get native balance
 const getSvmNativeBalance = async (address, connection) => {
     const balance = await connection.getBalance(address);
     return { balance: new bn_js_1.BN(balance), formatted: balance / web3_js_1.LAMPORTS_PER_SOL, decimal: 9 };
@@ -159,3 +160,145 @@ const signAndSendTransaction = async (transaction, connection, signers) => {
     return res.transaction.signatures[0];
 };
 exports.signAndSendTransaction = signAndSendTransaction;
+//swap
+//you will. use jupiter for this
+const getJupiterQuote = async (inputMint, outputMint, amount, slippageBps = 50) => {
+    const params = new URLSearchParams({
+        inputMint,
+        outputMint,
+        amount: amount.toString(),
+        slippageBps: slippageBps.toString(),
+        onlyDirectRoutes: 'false',
+        asLegacyTransaction: 'false'
+    });
+    const response = await fetch(`${JUPITER_BASE_URL}/swap/v1/quote?${params}`);
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Jupiter quote failed: ${error.message || response.statusText}`);
+    }
+    return await response.json();
+};
+exports.getJupiterQuote = getJupiterQuote;
+const buildJupiterSwapTransaction = async (quote, userPublicKey, prioritizationFeeLamports) => {
+    const body = {
+        quoteResponse: quote,
+        userPublicKey,
+        wrapAndUnwrapSol: true,
+        useSharedAccounts: true,
+        feeAccount: undefined,
+        trackingAccount: undefined,
+        computeUnitPriceMicroLamports: undefined,
+        prioritizationFeeLamports: prioritizationFeeLamports || 1000,
+        asLegacyTransaction: false,
+        useTokenLedger: false,
+        destinationTokenAccount: undefined,
+        dynamicComputeUnitLimit: true,
+        skipUserAccountsRpcCalls: false
+    };
+    const response = await fetch(`${JUPITER_BASE_URL}/swap/v1/swap`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Jupiter swap transaction build failed: ${error.message || response.statusText}`);
+    }
+    return await response.json();
+};
+exports.buildJupiterSwapTransaction = buildJupiterSwapTransaction;
+const executeJupiterSwap = async (swapParams, connection, payer) => {
+    try {
+        console.log('Getting Jupiter quote...');
+        const quote = await (0, exports.getJupiterQuote)(swapParams.fromToken.toString(), swapParams.toToken.toString(), swapParams.amount, swapParams.slippageBps);
+        console.log('Quote received:', {
+            inputAmount: quote.inAmount,
+            outputAmount: quote.outAmount,
+            priceImpact: quote.priceImpactPct
+        });
+        console.log('Building swap transaction...');
+        const swapResponse = await (0, exports.buildJupiterSwapTransaction)(quote, swapParams.userPublicKey.toString());
+        console.log('Deserializing transaction...');
+        const swapTransactionBuf = Buffer.from(swapResponse.swapTransaction, 'base64');
+        const transaction = web3_js_1.VersionedTransaction.deserialize(swapTransactionBuf);
+        console.log('Signing transaction...');
+        transaction.sign([payer]);
+        console.log('Sending transaction...');
+        const blockhash = await connection.getLatestBlockhash();
+        const signature = await (0, transactionSender_1.transactionSenderAndConfirmationWaiter)({
+            connection,
+            serializedTransaction: Buffer.from(transaction.serialize()),
+            blockhashWithExpiryBlockHeight: {
+                blockhash: blockhash.blockhash,
+                lastValidBlockHeight: blockhash.lastValidBlockHeight
+            }
+        });
+        if (!signature) {
+            return {
+                success: false,
+                error: 'Transaction failed to confirm'
+            };
+        }
+        console.log('Swap successful! Signature:', signature.transaction.signatures[0]);
+        return {
+            success: true,
+            hash: signature.transaction.signatures[0],
+            inputAmount: quote.inAmount,
+            outputAmount: quote.outAmount,
+            priceImpact: quote.priceImpactPct
+        };
+    }
+    catch (error) {
+        console.error('Jupiter swap failed:', error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error occurred'
+        };
+    }
+};
+exports.executeJupiterSwap = executeJupiterSwap;
+const uiAmountToBaseUnits = (uiAmount, decimals) => {
+    return Math.floor(uiAmount * Math.pow(10, decimals));
+};
+exports.uiAmountToBaseUnits = uiAmountToBaseUnits;
+const baseUnitsToUiAmount = (baseAmount, decimals) => {
+    return Number(baseAmount) / Math.pow(10, decimals);
+};
+exports.baseUnitsToUiAmount = baseUnitsToUiAmount;
+const getJupiterTokenList = async () => {
+    try {
+        const response = await fetch(`${JUPITER_BASE_URL}/tokens/v1/mints/tradable`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch token list: ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        console.error('Failed to fetch Jupiter token list:', error);
+        return [];
+    }
+};
+exports.getJupiterTokenList = getJupiterTokenList;
+const validateJupiterTokens = async (inputMint, outputMint) => {
+    try {
+        const tokenList = await (0, exports.getJupiterTokenList)();
+        const inputSupported = tokenList.includes(inputMint);
+        const outputSupported = tokenList.includes(outputMint);
+        if (!inputSupported && !outputSupported) {
+            return { valid: false, message: 'Both input and output tokens are not supported' };
+        }
+        if (!inputSupported) {
+            return { valid: false, message: 'Input token is not supported' };
+        }
+        if (!outputSupported) {
+            return { valid: false, message: 'Output token is not supported' };
+        }
+        return { valid: true };
+    }
+    catch (error) {
+        return { valid: false, message: 'Failed to validate tokens' };
+    }
+};
+exports.validateJupiterTokens = validateJupiterTokens;

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@deserialize/multi-vm-wallet",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "devDependencies": {
     "@types/bn.js": "^5.2.0",
-    "@types/node": "^24.1.0",
-    "@types/promise-retry": "^1.1.6"
+    "@types/node": "^24.2.1",
+    "@types/promise-retry": "^1.1.6",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.9.2"
   },
   "dependencies": {
     "@solana/spl-token": "^0.4.13",
@@ -22,7 +24,8 @@
   "types": "dist/index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "sudo rm -r dist ;  tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json",
+    "dev": "ts-node-dev --respawn --transpile-only utils/index.ts",
     "publish:sdk": "npm run build && npm publish --access=public"
   },
   "repository": {

package/utils/IChainWallet.ts

@@ -20,6 +20,8 @@ export abstract class ChainWallet<AddressType, PrivateKeyType, ConnectionType> {
     abstract getTokenBalance(tokenAddress: AddressType): Promise<Balance>;
     abstract transferNative(to: AddressType, amount: number): Promise<TransactionResult>;
     abstract transferToken(tokenAddress: TokenInfo, to: AddressType, amount: number): Promise<TransactionResult>;
+    abstract swap (tokenAddress: TokenInfo, to: AddressType, amount: number, slippage?: number): Promise<TransactionResult>;
+
     // abstract transferNFT(contractAddress: AddressType, tokenId: string, to: string): Promise<TransactionResult>;
     // abstract getTokenInfo(tokenAddress: string): Promise<TokenInfo>;
     // abstract getNFTInfo(contractAddress: string, tokenId: string): Promise<NFTInfo>;

package/utils/evm/evm.ts

@@ -1,5 +1,5 @@
 /**
- * 
+ *
  * @param phrase this is the pass phrase for this vm
  * this is a class that will be responsible for creating several evm wallets
  */
@@ -9,12 +9,24 @@ import { ChainWallet } from "../IChainWallet";
 import { Balance, ChainWalletConfig, NFTInfo, TokenInfo, TransactionResult } from "../types";
 import { VM } from "../vm";
 import { ethers, JsonRpcProvider, Wallet } from "ethers";
-import { getNativeBalance, getTokenBalance, sendERC20Token, sendNativeToken } from "./utils";
+import BN from "bn.js";
+import {
+    getNativeBalance,
+    getTokenBalance,
+    sendERC20Token,
+    sendNativeToken,
+    performSwap,
+    checkAndApprove,
+    signSendAndConfirm,
+    getNativeTokenAddress,
+    prepareSwapParams,
+    formatAmountToWei,
+    isChainSupportedByKyber,
+    TransactionParams
+} from "./utils";
 
 export const createEvmVmPrivateKey = (phrase: string) => { }
 
-
-
 export class EVMVM extends VM<string, string, JsonRpcProvider> {
     derivationPath = "m/44'/60'/0'/0/"; // Default EVM derivation path
 
@@ -43,7 +55,6 @@ export class EVMVM extends VM<string, string, JsonRpcProvider> {
 }
 
 export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider> {
-
     constructor(config: ChainWalletConfig, privateKey: string, index: number) {
         super(config, privateKey, index);
         const wallet = new Wallet(privateKey);
@@ -51,9 +62,11 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
         this.privateKey = privateKey;
         this.connection = new JsonRpcProvider(config.rpcUrl)
     }
+
     getWallet(): Wallet {
-        return new Wallet(this.privateKey);
+        return new Wallet(this.privateKey, this.connection);
     }
+
     generateAddress(): string {
         return this.address;
     }
@@ -80,5 +93,212 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
         return await 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: TokenInfo,
+        to: string,
+        amount: number,
+        slippage: number = 50
+    ): Promise<TransactionResult> {
+        if (amount <= 0) {
+            return {
+                success: false,
+                hash: "",
+                error: "Amount must be greater than 0"
+            };
+        }
+        const tokenOut: TokenInfo = {
+            address: to,
+            name: '',
+            symbol: '',
+            decimals: 18
+        };
+
+        return await this.performCompleteSwap(tokenAddress, tokenOut, amount, slippage);
+    }
+
+    async performCompleteSwap(
+        tokenIn: TokenInfo,
+        tokenOut: TokenInfo,
+        amount: number,
+        slippage: number = 50,
+        recipient?: string,
+        deadline?: number
+    ): Promise<TransactionResult> {
+        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 (!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 } = 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(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(formattedAmountIn);
+                if (tokenBalance.balance.lt(requiredAmount)) {
+                    throw new Error(`Insufficient token balance. Required: ${amount}, Available: ${tokenBalance.formatted}`);
+                }
+            }
 
+            const swapTx = await 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 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 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: TokenInfo,
+        tokenOut: TokenInfo,
+        amount: number
+    ): Promise<{
+        amountOut: string;
+        priceImpact: string;
+        gasEstimate: string;
+        route: string[];
+    }> {
+        try {
+            const chainId = (await this.connection!.getNetwork()).chainId.toString();
+
+            if (!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 } = 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;
+        }
+    }
+}