@deserialize/multi-vm-wallet 1.0.0 → 1.0.2

package/dist/utils/svm/svm.js

@@ -11,9 +11,9 @@ 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
+    constructor(seed) {
+        super(seed, "SVM");
+        this.derivationPath = "m/44'/501'/"; // Default SVM derivation path
     }
     static validateAddress(address) {
         return web3_js_1.PublicKey.isOnCurve(address.toBuffer());
@@ -28,11 +28,23 @@ class SVMVM extends vm_1.VM {
         }
         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);
+    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.SVMDeriveChildPrivateKey)(_seed, index, derivationPath);
         return { privateKey, index };
     }
+    static fromMnemonic(seed) {
+        return new SVMVM(seed);
+    }
 }
 exports.SVMVM = SVMVM;
 SVMVM.signAndSendTransaction = utils_1.signAndSendTransaction;
@@ -66,6 +78,89 @@ class SVMChainWallet extends IChainWallet_1.ChainWallet {
         const hash = await SVMVM.signAndSendTransaction(transaction, this.connection, [this.privateKey]);
         return { success: true, hash }; // Placeholder
     }
+    async swap(fromToken, toToken, amount, slippage = 50) {
+        try {
+            if (amount <= 0) {
+                return {
+                    success: false,
+                    hash: "",
+                    error: "Amount must be greater than 0"
+                };
+            }
+            if (slippage < 0 || slippage > 5000) {
+                return {
+                    success: false,
+                    hash: "",
+                    error: "Slippage must be between 0 and 5000 basis points (0-50%)"
+                };
+            }
+            const fromTokenMint = new web3_js_1.PublicKey(fromToken.address);
+            const toTokenMint = toToken;
+            const validation = await (0, utils_1.validateJupiterTokens)(fromTokenMint.toString(), toTokenMint.toString());
+            if (!validation.valid) {
+                return {
+                    success: false,
+                    hash: "",
+                    error: validation.message || "Token validation failed"
+                };
+            }
+            const baseAmount = (0, utils_1.uiAmountToBaseUnits)(amount, fromToken.decimals);
+            const balance = await this.getTokenBalance(fromTokenMint);
+            if (balance.balance.lt(new bn_js_1.default(baseAmount))) {
+                return {
+                    success: false,
+                    hash: "",
+                    error: "Insufficient balance for swap"
+                };
+            }
+            const swapResult = await (0, utils_1.executeJupiterSwap)({
+                fromToken: fromTokenMint,
+                toToken: toTokenMint,
+                amount: baseAmount,
+                slippageBps: slippage,
+                userPublicKey: this.address
+            }, this.connection, this.privateKey);
+            if (!swapResult.success) {
+                return {
+                    success: false,
+                    hash: "",
+                    error: swapResult.error || "Swap failed"
+                };
+            }
+            return {
+                success: true,
+                hash: swapResult.hash || ""
+            };
+        }
+        catch (error) {
+            console.error("Swap error:", error);
+            return {
+                success: false,
+                hash: "",
+                error: error instanceof Error ? error.message : "Unknown swap error occurred"
+            };
+        }
+    }
+    async getSwapQuote(fromToken, toToken, amount, slippage = 50) {
+        try {
+            const fromTokenMint = new web3_js_1.PublicKey(fromToken.address);
+            const baseAmount = (0, utils_1.uiAmountToBaseUnits)(amount, fromToken.decimals);
+            const quote = await (0, utils_1.getJupiterQuote)(fromTokenMint.toString(), toToken.toString(), baseAmount, slippage);
+            return {
+                success: true,
+                inputAmount: quote.inAmount,
+                outputAmount: quote.outAmount,
+                priceImpact: quote.priceImpactPct,
+                routePlan: quote.routePlan,
+                slippageBps: quote.slippageBps
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "Failed to get swap quote"
+            };
+        }
+    }
 }
 exports.SVMChainWallet = SVMChainWallet;
-//swaps jupiter swap here

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/dist/utils/vm.d.ts

@@ -1,10 +1,9 @@
 import { vmTypes } from "./types";
 export declare abstract class VM<AddressType, PrivateKeyType, ConnectionType> {
-    protected mnemonic: string;
     protected seed: string;
     type: vmTypes;
-    constructor(mnemonic: string, vm: vmTypes);
-    mnemonicToSeed: (mnemonic: string) => string;
+    constructor(seed: string, vm: vmTypes);
+    static mnemonicToSeed: (mnemonic: string) => string;
     abstract derivationPath: string;
     abstract generatePrivateKey(index: number, mnemonic?: string, derivationPath?: string): {
         privateKey: PrivateKeyType;

package/dist/utils/vm.js

@@ -37,13 +37,12 @@ exports.VM = void 0;
 const bip39 = __importStar(require("bip39"));
 // Abstract Base Classes
 class VM {
-    constructor(mnemonic, vm) {
-        this.mnemonicToSeed = (mnemonic) => {
-            return bip39.mnemonicToSeedSync(mnemonic).toString("hex");
-        };
-        this.mnemonic = mnemonic;
+    constructor(seed, vm) {
         this.type = vm;
-        this.seed = this.mnemonicToSeed(this.mnemonic);
+        this.seed = seed;
     }
 }
 exports.VM = VM;
+VM.mnemonicToSeed = (mnemonic) => {
+    return bip39.mnemonicToSeedSync(mnemonic).toString("hex");
+};

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@deserialize/multi-vm-wallet",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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>;