@deserialize/multi-vm-wallet 1.0.0 → 1.0.12

package/utils/evm/utils.ts

@@ -3,8 +3,9 @@ import { Balance } from '../types'
 import { JsonRpcProvider, Contract, Wallet, TransactionRequest, TransactionResponse, TransactionReceipt } from 'ethers'
 import BN from 'bn.js'
 
+const KYBER_BASE_URL = 'https://aggregator-api.kyberswap.com';
 
-interface TransactionParams {
+export interface TransactionParams {
     to: string
     value?: string | bigint  // For native token transfers
     data?: string           // For contract calls
@@ -25,6 +26,110 @@ interface TransactionResult {
     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;
+    };
+}
+
+const KYBER_SUPPORTED_CHAINS: { [key: string]: string } = {
+    '1': 'ethereum',
+    '137': 'polygon',
+    '56': 'bsc',
+    '43114': 'avalanche',
+    '250': 'fantom',
+    '42161': 'arbitrum',
+    '10': 'optimism',
+    '8453': 'base',
+    '324': 'zksync',
+    '59144': 'linea'
+};
+
+interface KyberSwapParams {
+    chainId: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: string;
+    slippageTolerance?: number; // in bips (e.g., 50 = 0.5%)
+    recipient?: string;
+    sender?: string;
+    deadline?: number; // Unix timestamp
+    feeAmount?: string;
+    feeReceiver?: string;
+    isInBps?: boolean;
+    chargeFeeBy?: 'currency_in' | 'currency_out';
+    clientId?: string;
+}
+
 // ERC-20 ABI
 const ERC20_ABI = [
     "function balanceOf(address owner) view returns (uint256)",
@@ -502,3 +607,247 @@ export const safeApprove = async (
 
 //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
+
+
+
+export async function getKyberSwapRoute(params: KyberSwapParams): Promise<KyberSwapResponse> {
+    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: { [key: string]: string } = {};
+    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;
+    }
+}
+
+
+export async function buildKyberSwapTransaction(
+    chainId: string,
+    routeSummary: KyberRoute,
+    sender: string,
+    recipient: string,
+    slippageTolerance: number = 50,
+    deadline?: number,
+    clientId?: string
+): Promise<KyberBuildResponse> {
+    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: { [key: string]: string } = {
+        '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;
+    }
+}
+
+export async 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> {
+    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'}`);
+    }
+}
+
+export function getKyberSupportedChains(): { [key: string]: string } {
+    return { ...KYBER_SUPPORTED_CHAINS };
+}
+
+export function isChainSupportedByKyber(chainId: string): boolean {
+    return chainId in KYBER_SUPPORTED_CHAINS;
+}
+
+export function getNativeTokenAddress(): string {
+    return '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+}
+
+export function formatAmountToWei(amount: string, decimals: number): string {
+    const amountBN = new BN(amount);
+    const multiplier = new BN(10).pow(new BN(decimals));
+    return amountBN.mul(multiplier).toString();
+}
+
+export function formatAmountFromWei(amountWei: string, decimals: number): string {
+    const amountBN = new BN(amountWei);
+    const divisor = new BN(10).pow(new BN(decimals));
+    return amountBN.div(divisor).toString();
+}
+
+export function prepareSwapParams(
+    tokenIn: string,
+    tokenOut: string,
+    amountIn: string,
+    tokenInDecimals: number,
+    isNativeIn: boolean = false,
+    isNativeOut: boolean = false
+): {
+    tokenInAddress: string;
+    tokenOutAddress: string;
+    formattedAmountIn: string;
+} {
+    const tokenInAddress = isNativeIn ? getNativeTokenAddress() : tokenIn;
+    const tokenOutAddress = isNativeOut ? getNativeTokenAddress() : tokenOut;
+
+    const formattedAmountIn = amountIn.includes('.')
+        ? formatAmountToWei(amountIn, tokenInDecimals)
+        : amountIn;
+
+    return {
+        tokenInAddress,
+        tokenOutAddress,
+        formattedAmountIn
+    };
+}

package/utils/index.ts

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

package/utils/svm/svm.ts

@@ -3,11 +3,23 @@ import { SVMDeriveChildPrivateKey } from "../bip32";
 import { VM } from "../vm";
 import { ChainWallet } from "../IChainWallet";
 import { Balance, ChainWalletConfig, TokenInfo, TransactionResult } from "../types";
-import { getSvmNativeBalance, getTokenBalance, getTransferNativeTransaction, getTransferTokenTransaction, signAndSendTransaction } from "./utils";
+import {
+    getSvmNativeBalance,
+    getTokenBalance,
+    getTransferNativeTransaction,
+    getTransferTokenTransaction,
+    signAndSendTransaction,
+    getJupiterQuote,
+    buildJupiterSwapTransaction,
+    executeJupiterSwap,
+    uiAmountToBaseUnits,
+    validateJupiterTokens,
+    JupiterQuoteResponse
+} from "./utils";
 import BN from "bn.js";
 
 export class SVMVM extends VM<PublicKey, Keypair, Connection> {
-    derivationPath = "m/44'/501'/"; // Default EVM derivation path
+    derivationPath = "m/44'/501'/"; // Default SVM derivation path
 
     constructor(mnemonic: string) {
         super(mnemonic, "SVM");
@@ -68,8 +80,121 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
         const hash = await SVMVM.signAndSendTransaction(transaction, this.connection!, [this.privateKey]);
         return { success: true, hash }; // Placeholder
     }
-}
 
 
-//swaps jupiter swap here
+    async swap(fromToken: TokenInfo, toToken: PublicKey, amount: number, slippage: number = 50): Promise<TransactionResult> {
+        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 PublicKey(fromToken.address);
+            const toTokenMint = toToken;
+
+            const validation = await validateJupiterTokens(
+                fromTokenMint.toString(),
+                toTokenMint.toString()
+            );
+
+            if (!validation.valid) {
+                return {
+                    success: false,
+                    hash: "",
+                    error: validation.message || "Token validation failed"
+                };
+            }
+
+            const baseAmount = uiAmountToBaseUnits(amount, fromToken.decimals);
+
+            const balance = await this.getTokenBalance(fromTokenMint);
+            if (balance.balance.lt(new BN(baseAmount))) {
+                return {
+                    success: false,
+                    hash: "",
+                    error: "Insufficient balance for swap"
+                };
+            }
+
+            const swapResult = await 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: TokenInfo, toToken: PublicKey, amount: number, slippage: number = 50): Promise<{
+        success: boolean;
+        inputAmount?: string;
+        outputAmount?: string;
+        priceImpact?: string;
+        routePlan?: JupiterQuoteResponse['routePlan'];
+        slippageBps?: number;
+        error?: string;
+    }> {
+        try {
+            const fromTokenMint = new PublicKey(fromToken.address);
+            const baseAmount = uiAmountToBaseUnits(amount, fromToken.decimals);
+
+            const quote = await 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"
+            };
+        }
+    }
+}