@deserialize/multi-vm-wallet 1.1.3 → 1.1.5

package/utils/evm/evm.ts

@@ -8,7 +8,7 @@ import { EVMDeriveChildPrivateKey } from "../bip32";
 import { ChainWallet } from "../IChainWallet";
 import { Balance, ChainWalletConfig, NFTInfo, TokenInfo, TransactionResult } from "../types";
 import { VM } from "../vm";
-import { ethers, JsonRpcProvider, Wallet } from "ethers";
+import { ethers, JsonRpcProvider, Wallet, formatUnits } from "ethers";
 import BN from "bn.js";
 import {
     getNativeBalance,
@@ -22,13 +22,51 @@ import {
     prepareSwapParams,
     formatAmountToWei,
     isChainSupportedByKyber,
+    isChainSupportedByDebonk,
+    // normalizeTokenAddressForDebonk,
+    convertSlippageForDebonk,
     TransactionParams,
     approveToken,
     executeContractMethod,
-    getTokenInfo
+    getTokenInfo,
+    DESERIALIZED_SUPPORTED_CHAINS
 } from "./utils";
 
-export const createEvmVmPrivateKey = (phrase: string) => { }
+interface DebonkQuoteResponse {
+    tokenA: string;
+    tokenB: string;
+    amountIn: string;
+    amountOut: string;
+    tokenPrice: string;
+    routePlan: Array<{
+        tokenA: string;
+        tokenB: string;
+        dexId: string;
+        poolAddress: string;
+        aToB: boolean;
+        fee: number;
+    }>;
+    dexId: string;
+    dexFactory: string;
+}
+
+interface DebonkSwapResponse {
+    transactions: Array<{
+        from: string;
+        to: string;
+        data: string;
+        value: string;
+        gasLimit?: string;
+        gasPrice?: string;
+    }>;
+}
+
+interface DebonkSwapResult {
+    success: boolean;
+    hash: string;
+    error?: string;
+}
+
 
 export class EVMVM extends VM<string, string, JsonRpcProvider> {
     derivationPath = "m/44'/60'/0'/0/"; // Default EVM derivation path
@@ -153,6 +191,200 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
                 slippage: `${slippage / 100}%`
             });
 
+            // Check if this is a 0G chain that should use Debonk
+            if (isChainSupportedByDebonk(chainId)) {
+                console.log('Using Debonk API for 0G chain swap');
+                return await this.performDebonkSwap(tokenIn, tokenOut, amount, slippage, recipient, deadline);
+            }
+
+            // Otherwise use Kyber (existing flow)
+            console.log('Using KyberSwap for non-0G chain swap');
+            return await this.performKyberSwap(tokenIn, tokenOut, amount, slippage, recipient, deadline);
+
+        } catch (error) {
+            console.error('Swap failed:', error);
+            throw new Error(`Swap failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+
+    private async performDebonkSwap(
+        tokenIn: TokenInfo,
+        tokenOut: TokenInfo,
+        amount: number,
+        slippage: number = 50,     // bps (e.g., 50 = 0.5%)
+        recipient?: string,
+        deadline?: number
+    ): Promise<DebonkSwapResult> {
+        try {
+            const BASE_URL = 'https://evm-api.deserialize.xyz';
+            const tokenInAddress = tokenIn.address;
+            const tokenOutAddress = tokenOut.address;
+
+            // Convert amount to wei (multiply by 10^18 for 18 decimal tokens)
+            const amountInWei = (amount * Math.pow(10, tokenIn.decimals || 18)).toString();
+            console.log("amountInWei", amountInWei)
+            // Convert slippage from bps to percentage (e.g., 50 bps -> 0.5%)
+            const slippagePercentage = slippage / 100;
+
+            console.log("Debonk API swap params:", {
+                tokenA: tokenInAddress,
+                tokenB: tokenOutAddress,
+                amountIn: amount,
+                amountInWei: amountInWei,
+                slippage: slippagePercentage,
+            });
+
+            // Step 1: Get quote from API
+            console.log("Getting quote from Debonk API...");
+
+            const quotePayload = {
+                tokenA: tokenInAddress,
+                tokenB: tokenOutAddress,
+                amountIn: amountInWei, // Use wei amount
+                dexId: "ZERO_G"
+            };
+
+            console.log("Quote request payload:", quotePayload);
+
+            const quoteResponse = await fetch(`${BASE_URL}/quote`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(quotePayload)
+            });
+
+            if (!quoteResponse.ok) {
+                const errorText = await quoteResponse.text();
+                console.error("Quote API error response:", errorText);
+                return this.fail(`Quote API failed: ${quoteResponse.status} ${errorText}`);
+            }
+
+            const quote: DebonkQuoteResponse = await quoteResponse.json();
+            console.log("Quote received:", JSON.stringify(quote, null, 2));
+
+            // Step 2: Fix the quote dexId for swap API (it expects "ALL")
+            const modifiedQuote = {
+                ...quote,
+                dexId: "ALL"  // Change from "ZERO_G" to "ALL" as required by swap API
+            };
+
+            console.log("Modified quote for swap API:", JSON.stringify(modifiedQuote, null, 2));
+
+            // Step 3: Get wallet address
+            const walletAddress = await this.getWallet().getAddress();
+            console.log("Wallet address:", walletAddress);
+
+            // Step 4: Call swap API with modified quote
+            console.log("Calling swap API...");
+
+            const swapPayload = {
+                publicKey: walletAddress,
+                slippage: slippagePercentage,
+                quote: modifiedQuote
+            };
+
+            console.log("Swap request payload:", JSON.stringify(swapPayload, null, 2));
+
+            const swapResponse = await fetch(`${BASE_URL}/swap`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(swapPayload)
+            });
+
+            if (!swapResponse.ok) {
+                const errorText = await swapResponse.text();
+                console.error("Swap API error response:", errorText);
+                return this.fail(`Swap API failed: ${swapResponse.status} ${errorText}`);
+            }
+
+            const swapData: DebonkSwapResponse = await swapResponse.json();
+            console.log("Swap API response:", JSON.stringify(swapData, null, 2));
+
+            const wallet = this.getWallet();
+            let lastTxHash = '';
+
+            // Step 5: Execute each transaction sequentially
+            console.log(`Executing ${swapData.transactions.length} transactions...`);
+
+            for (let i = 0; i < swapData.transactions.length; i++) {
+                const transaction = swapData.transactions[i];
+                console.log(`Executing transaction ${i + 1} of ${swapData.transactions.length}`);
+
+                // Prepare transaction object
+                const txRequest = {
+                    to: transaction.to,
+                    data: transaction.data,
+                    value: transaction.value,
+                    // gasPrice: 70000000000,
+                    // gasLimit: 70000, // Increase significantly
+                };
+                console.log("Prepared transaction request:", txRequest);
+                console.log(`Transaction ${i + 1} request:`, txRequest);
+
+                try {
+                    const txResponse = await wallet.sendTransaction(txRequest);
+                    console.log(`Transaction ${i + 1} sent:`, txResponse.hash);
+
+                    // Wait for confirmation
+                    const receipt = await txResponse.wait();
+
+                    if (!receipt) {
+                        return this.fail(`Transaction ${i + 1} failed - no receipt received`);
+                    }
+
+                    const txHash = receipt.hash || txResponse.hash;
+                    lastTxHash = txHash;
+
+                    console.log(`Transaction ${i + 1} confirmed:`, {
+                        hash: txHash,
+                        blockNumber: receipt.blockNumber,
+                        gasUsed: receipt.gasUsed?.toString()
+                    });
+
+                } catch (txError: any) {
+                    console.error(`Transaction ${i + 1} failed:`, txError);
+                    return this.fail(`Transaction ${i + 1} failed: ${txError?.message ?? String(txError)}`);
+                }
+            }
+
+            console.log("All transactions completed successfully");
+
+            return {
+                success: true,
+                hash: lastTxHash // Return the hash of the last transaction
+            };
+
+        } catch (error: any) {
+            console.error("Debonk API swap error:", error);
+            return this.fail(`Debonk API swap failed: ${error?.message ?? String(error)}`);
+        }
+    }
+
+    // Helper method for EVMChainWallet class
+    private fail(message: string): DebonkSwapResult {
+        return {
+            success: false,
+            hash: "",
+            error: message
+        };
+    }
+
+
+    private async performKyberSwap(
+        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();
+
             if (!isChainSupportedByKyber(chainId)) {
                 throw new Error(`Chain ${chainId} is not supported by KyberSwap`);
             }
@@ -179,7 +411,7 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
                 isNativeOut
             );
 
-            console.log('Swap parameters:', {
+            console.log('Kyber swap parameters:', {
                 tokenInAddress,
                 tokenOutAddress,
                 formattedAmountIn,
@@ -212,7 +444,7 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
                 clientId: 'EVMChainWallet'
             });
 
-            console.log('Swap transaction prepared:', {
+            console.log('Kyber swap transaction prepared:', {
                 to: swapTx.to,
                 dataLength: swapTx.data?.length || 0,
                 gasLimit: swapTx.gasLimit?.toString(),
@@ -255,20 +487,20 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
             );
 
             if (result.success) {
-                console.log(' Swap completed successfully:', {
+                console.log(' Kyber swap completed successfully:', {
                     hash: result.hash,
                     gasUsed: result.gasUsed?.toString(),
                     blockNumber: result.blockNumber
                 });
             } else {
-                console.log(' Swap failed:', result);
+                console.log(' Kyber swap failed:', result);
             }
 
             return result;
 
         } catch (error) {
-            console.error('Swap failed:', error);
-            throw new Error(`Swap failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            console.error('Kyber swap failed:', error);
+            throw new Error(`Kyber swap failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
 
@@ -282,6 +514,7 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
         gasEstimate: string;
         route: string[];
     }> {
+        
         try {
             const chainId = (await this.connection!.getNetwork()).chainId.toString();
 

package/utils/evm/script.ts

@@ -0,0 +1,160 @@
+
+
+import { ethers } from 'ethers';
+
+// Simplified ABI for Uniswap V3 Router
+const ROUTER_ABI = [
+  'function exactInputSingle((address tokenIn, address tokenIn, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountOut)',
+  'function exactOutputSingle((address tokenIn, address tokenIn, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountIn)'
+];
+
+// ERC20 ABI (simplified)
+const ERC20_ABI = [
+  'function approve(address spender, uint256 amount) external returns (bool)',
+  'function allowance(address owner, address spender) external view returns (uint256)',
+  'function balanceOf(address account) external view returns (uint256)'
+];
+
+export interface SwapParams {
+  privateKey: string;
+  tokenIn: string;
+  tokenOut: string;
+  tokenInDecimal:number;
+  amountIn: string;
+  adminAddress: string;
+  routerAddress: string;
+  minAmountOut:string;
+  rpcUrl: string;
+  feeTier?: number; // 500 = 0.05%, 3000 = 0.3%, 10000 = 1%
+}
+
+export const quote = async (quoterAddress:string,rpc:string,tokenIn:string, tokenOut:string, amountIn:string, fee:number,sqrtPriceLimitX96="0") => {
+  const provider = new ethers.JsonRpcProvider(rpc);
+
+  const viewABI = [
+    {
+      inputs: [
+        { internalType: "address", name: "tokenIn", type: "address" },
+        { internalType: "address", name: "tokenOut", type: "address" },
+        { internalType: "uint24", name: "fee", type: "uint24" },
+        { internalType: "uint256", name: "amountIn", type: "uint256" },
+        { internalType: "uint160", name: "sqrtPriceLimitX96", type: "uint160" },
+      ],
+      name: "quoteExactInputSingle",
+      outputs: [{ internalType: "uint256", name: "amountOut", type: "uint256" }],
+      stateMutability: "view",
+      type: "function",
+    },
+  ];
+
+  const quoter = new ethers.Contract(quoterAddress, viewABI, provider);
+
+  try {
+    const amountOut = await quoter.quoteExactInputSingle(
+      tokenIn,
+      tokenOut,
+      fee,
+      amountIn,
+      sqrtPriceLimitX96
+    );
+
+    console.log("Amount Out:", amountOut.toString());
+    return amountOut.toString();
+  } catch (err:any) {
+    console.error("Quote failed:", err);
+  }
+};
+
+
+export const quickSwapSetup = async (params: SwapParams) => {
+  const {
+    privateKey,
+    tokenIn,
+    tokenOut,
+    amountIn,
+    tokenInDecimal,
+    adminAddress,
+    routerAddress,
+    rpcUrl,
+    minAmountOut,
+
+    feeTier = 100 // 0.01% fee tier
+  } = params;
+
+  try {
+    // Setup provider and wallet
+    const provider = new ethers.JsonRpcProvider(rpcUrl);
+    const wallet = new ethers.Wallet(privateKey, provider);
+
+    // Create contract instances
+    const router = new ethers.Contract(routerAddress, ROUTER_ABI, wallet);
+    const tokenInContract = new ethers.Contract(tokenIn, ERC20_ABI, wallet);
+
+    // Convert amount to wei
+    const amountInWei = ethers.parseUnits(amountIn, tokenInDecimal); // Assuming 18 decimals
+
+    // Check and approve token allowance
+    const allowance = await tokenInContract.allowance(wallet.address, routerAddress);
+    
+    if (allowance < amountInWei) {
+      console.log('Approving tokens...');
+      const approveTx = await tokenInContract.approve(routerAddress, amountInWei);
+      await approveTx.wait();
+      console.log('Approval confirmed');
+    }
+
+    // Calculate amount with fee (0.01% to admin)
+    const feeAmount = amountInWei * BigInt(1) / BigInt(10000); // 0.01%
+    const amountAfterFee = amountInWei - feeAmount;
+
+    // Transfer fee to admin
+    if (feeAmount > 0) {
+      console.log(`Transferring ${ethers.formatUnits(feeAmount, tokenIn)} fee to admin`);
+      const feeTransferTx = await tokenInContract.transfer(adminAddress, feeAmount);
+      await feeTransferTx.wait();
+    }
+
+    // Set deadline (10 minutes from now)
+    const deadline = Math.floor(Date.now() / 1000) + 600;
+
+    // Prepare swap parameters
+    const swapParams = {
+      tokenIn: tokenIn,
+      tokenOut: tokenOut,
+      fee: feeTier,
+      recipient: wallet.address,
+      deadline: deadline,
+      amountIn: amountAfterFee,
+      amountOutMinimum: minAmountOut,
+      sqrtPriceLimitX96: 0
+    };
+
+    console.log('Executing swap...');
+    
+    // Execute swap
+    const swapTx = await router.exactInputSingle(swapParams);
+    const receipt = await swapTx.wait();
+
+    console.log('Swap successful!');
+    console.log('Transaction hash:', receipt.hash);
+
+    // Check final balances
+    const tokenOutContract = new ethers.Contract(tokenOut, ERC20_ABI, wallet);
+    const finalBalance = await tokenOutContract.balanceOf(wallet.address);
+    
+    console.log(`Final ${tokenOut} balance:`, ethers.formatUnits(finalBalance, 18));
+
+    return {
+      success: true,
+      txHash: receipt.hash,
+      amountOut: finalBalance.toString()
+    };
+
+  } catch (error) {
+    console.error('Swap failed:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error'
+    };
+  }
+};

package/utils/evm/utils.ts

@@ -1,4 +1,3 @@
-
 import { Balance, TokenInfo } from '../types'
 import { JsonRpcProvider, Contract, Wallet, TransactionRequest, TransactionResponse, TransactionReceipt } from 'ethers'
 import BN from 'bn.js'
@@ -24,6 +23,7 @@ interface TransactionResult {
     effectiveGasPrice?: bigint
     blockNumber?: number
     confirmations: number
+
 }
 
 export interface SwapParams {
@@ -114,6 +114,10 @@ const KYBER_SUPPORTED_CHAINS: { [key: string]: string } = {
     '59144': 'linea'
 };
 
+export const DESERIALIZED_SUPPORTED_CHAINS: { [key: string]: string } = {
+    '16661': '0gMainnet',
+};
+
 interface KyberSwapParams {
     chainId: string;
     tokenIn: string;
@@ -143,13 +147,18 @@ const ERC20_ABI = [
 ]
 
 export const getNativeBalance = async (address: string, provider: JsonRpcProvider): Promise<Balance> => {
-    const balance = await provider.getBalance(address)
+    const balance = await provider.getBalance(address); // returns BigInt in ethers v6
+
+    const dem = 10n ** 18n;
+
+    // ⚠️ BigInt division truncates, so avoid dividing BigInt directly
+    const formatted = Number(balance) / Number(dem);
 
     return {
-        balance: new BN(balance),
-        formatted: Number(balance / 10n ** 18n),
+        balance: new BN(balance.toString()), // raw wei as BN
+        formatted,                           // e.g. 0.1
         decimal: 18
-    }
+    };
 }
 
 export const getTokenInfo = async (
@@ -755,6 +764,9 @@ export async function performSwap(params: {
     chargeFeeBy?: 'currency_in' | 'currency_out';
     clientId?: string;
 }): Promise<TransactionParams> {
+    if (!KYBER_SUPPORTED_CHAINS[params.chainId]) {
+        throw new Error(`KyberSwap does not support chain ID: ${params.chainId}`);
+    }
     try {
         console.log('Starting KyberSwap aggregation...', {
             tokenIn: params.tokenIn,
@@ -762,7 +774,9 @@ export async function performSwap(params: {
             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,
@@ -775,12 +789,20 @@ export async function performSwap(params: {
             clientId: params.clientId || 'MyWalletApp'
         });
 
+        // Debug: Log the full response to understand structure
+        console.log('Full KyberSwap route response:', JSON.stringify(routeResponse, null, 2));
+
         if (!routeResponse.data || !routeResponse.data.routeSummary) {
             throw new Error('No valid route found for the swap');
         }
 
         const { routeSummary, routerAddress } = routeResponse.data;
 
+        // Debug: Log what we actually received
+        console.log('routeSummary keys:', Object.keys(routeSummary));
+        console.log('routeSummary.swaps exists:', !!routeSummary.swaps);
+
+        // Safe logging that handles undefined swaps
         console.log('✅ Best route found:', {
             tokenIn: routeSummary.tokenIn,
             tokenOut: routeSummary.tokenOut,
@@ -788,10 +810,16 @@ export async function performSwap(params: {
             amountOut: routeSummary.amountOut,
             gasEstimate: routeSummary.gas,
             routerAddress,
-            dexSources: routeSummary.swaps.map(swap => swap.exchange)
+            // Only try to access swaps if it exists
+            swapsCount: routeSummary.swaps ? routeSummary.swaps.length : 0,
+            // Only extract exchange names if swaps exists and has the expected structure
+            dexSources: routeSummary.swaps && Array.isArray(routeSummary.swaps)
+                ? routeSummary.swaps.map(swap => swap?.exchange || 'unknown').filter(Boolean)
+                : ['unknown']
         });
 
-        console.log(' Building executable transaction...');
+        console.log('Building executable transaction...');
+
         const buildResponse = await buildKyberSwapTransaction(
             params.chainId,
             routeSummary,
@@ -802,6 +830,9 @@ export async function performSwap(params: {
             params.clientId || 'MyWalletApp'
         );
 
+        // Debug: Log build response
+        console.log('Build response:', JSON.stringify(buildResponse, null, 2));
+
         if (!buildResponse.data || !buildResponse.data.data) {
             throw new Error('Failed to build transaction data');
         }
@@ -826,6 +857,16 @@ export async function performSwap(params: {
 
     } catch (error) {
         console.error('❌ KyberSwap aggregation failed:', error);
+
+        // More detailed error logging
+        if (error instanceof Error) {
+            console.error('Error details:', {
+                message: error.message,
+                stack: error.stack,
+                name: error.name
+            });
+        }
+
         throw new Error(`Swap preparation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
@@ -838,6 +879,10 @@ export function isChainSupportedByKyber(chainId: string): boolean {
     return chainId in KYBER_SUPPORTED_CHAINS;
 }
 
+export function isChainSupportedByDebonk(chainId: string): boolean {
+    return chainId in DESERIALIZED_SUPPORTED_CHAINS;
+}
+
 export function getNativeTokenAddress(): string {
     return '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
 }
@@ -878,4 +923,24 @@ export function prepareSwapParams(
         tokenOutAddress,
         formattedAmountIn
     };
+}
+
+/**
+ * Normalize token address for Debonk
+ * Converts 'native' or variations to the standard 0xEeeee... address
+ */
+// export function normalizeTokenAddressForDebonk(tokenAddress: string): string {
+//     if (tokenAddress === 'native' || 
+//         tokenAddress.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee') {
+//         return getNativeTokenAddress();
+//     }
+//     return tokenAddress;
+// }
+
+/**
+ * Convert slippage from basis points to percentage for Debonk
+ * Input: 50 (0.5% in bps) -> Output: 0.5 (percentage)
+ */
+export function convertSlippageForDebonk(slippageBps: number): number {
+    return slippageBps / 100;
 }

package/utils/index.ts

@@ -6,4 +6,6 @@ export * from "./evm"
 export * from "./svm"
 export * from "./bip32"
 export * from "./types"
-export * from "./constant"
+export * from "./constant"
+export * from "bs58"
+export * from "@solana/web3.js"