@deserialize/multi-vm-wallet 1.1.4 → 1.1.5

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,9 +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,
@@ -785,7 +797,7 @@ export async function performSwap(params: {
         }
 
         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);
@@ -801,13 +813,13 @@ export async function performSwap(params: {
             // 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) 
+            dexSources: routeSummary.swaps && Array.isArray(routeSummary.swaps)
                 ? routeSummary.swaps.map(swap => swap?.exchange || 'unknown').filter(Boolean)
                 : ['unknown']
         });
 
         console.log('Building executable transaction...');
-        
+
         const buildResponse = await buildKyberSwapTransaction(
             params.chainId,
             routeSummary,
@@ -845,7 +857,7 @@ 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:', {
@@ -854,7 +866,7 @@ export async function performSwap(params: {
                 name: error.name
             });
         }
-        
+
         throw new Error(`Swap preparation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
@@ -867,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';
 }
@@ -909,7 +925,22 @@ export function prepareSwapParams(
     };
 }
 
+/**
+ * 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;
+// }
 
-//recent activity
-// token list with balance
-// discover tokens with balances
+/**
+ * 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/test.ts

@@ -3,29 +3,31 @@ import { generateKey } from "crypto";
 
 import base58 from "bs58";
 import { NATIVE_MINT } from "@solana/spl-token";
-import { GenerateNewMnemonic } from "./bip32";
+// import { GenerateNewMnemonic } from "./bip32";
 import { SVMChainWallet, SVMVM } from "./svm";
 import { VM } from "./vm";
 import { ChainWalletConfig } from "./types";
-import { Keypair } from ".";
-const mnemonic = GenerateNewMnemonic()
+import { EVMChainWallet, EVMVM, Keypair } from ".";
+import { JsonRpcProvider } from "ethers";
+import BN from "bn.js";
+// const mnemonic = GenerateNewMnemonic()
 
 
-console.log('mnemonic: ', mnemonic);
+// console.log('mnemonic: ', mnemonic);
 
-const seed = VM.mnemonicToSeed(mnemonic)
+// const seed = VM.mnemonicToSeed(mnemonic)
 const pKey = "4QxETeX9pndiF1XNghUiDTnZnHq3cfjmuPLBJysrgocsLq1yb8w96aPWALa8ZnRZWmDU4wM8Tg8d1ZRVVByj7uXE"
 
 export const testUserKeyPair = Keypair.fromSecretKey(base58.decode(pKey));
 const x = testUserKeyPair instanceof Keypair;
-const vm = new SVMVM(seed)
+// const vm = new SVMVM(seed)
 
 
 // const vmFromMnemonic = SVMVM.fromMnemonic(mnemonic)
 // const keyFromMnemonic = vmFromMnemonic.generatePrivateKey(0)
 // console.log('keyFromMnemonic: ', keyFromMnemonic.privateKey.publicKey);
-const key = vm.generatePrivateKey(0)
-console.log('key: ', key.privateKey.publicKey);
+// const key = vm.generatePrivateKey(0)
+// console.log('key: ', key.privateKey.publicKey);
 const chainConfig: ChainWalletConfig = {
     chainId: "solana-mainnet",
     name: "Solana",
@@ -36,9 +38,42 @@ const chainConfig: ChainWalletConfig = {
 
 }
 
+const evmChainConfig: ChainWalletConfig = {
+    chainId: "evm-mainnet",
+    name: "Ethereum",
+    rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/vB5mKztdJeFdz9RkW99Qf",
+    explorerUrl: "https://explorer.ethereum.com",
+    nativeToken: { name: "Ethereum", symbol: "ETH", decimals: 18 },
+    confirmationNo: 1,
+}
+const gChainConfig: ChainWalletConfig = {
+    chainId: "16661",
+    name: "Ethereum",
+    rpcUrl: "https://evmrpc.0g.ai",
+    explorerUrl: "https://chainscan.0g.ai",
+    nativeToken: {
+        name: "OG Mainnet",
+        symbol: "0G",
+        decimals: 18,
+    },
+    confirmationNo: 1,
+}
+
+// const wallet = new SVMChainWallet(chainConfig, testUserKeyPair, 0)
+// const wallet = new EVMChainWallet(chainConfig, testUserKeyPair, 0)
+const address = "0x34906823118C27B83243a4d3B19dd2984DdfB645"
+EVMVM.getNativeBalance(address, new JsonRpcProvider(gChainConfig.rpcUrl)).then(e => {
+    const bal = (e.balance as BN).toString()
+    console.log('bal: ', bal);
+    console.log('native balance: ', e)
+
+})
+// console.log('wallet: ', wallet);
+
+// wallet.getNativeBalance().then(e => console.log('native balance: ', e))
+
+
 
-const wallet = new SVMChainWallet(chainConfig, testUserKeyPair, key.index)
-console.log('wallet: ', wallet);
 // const toBuy = new PublicKey("9BB6NFEcjBCtnNLFko2FqVQBq8HHM13kCyYcdQbgpump")
 // wallet.swap({
 //     name: NATIVE_MINT.toBase58(),

package/utils/todo.txt

@@ -0,0 +1,7 @@
+// Discover tokens for users both for evm and svm
+// Discover wallet address for users based on private staticAccountKeys
+// wallet activities from the blockchain per wallet address
+// transaction insight both evm and svm / transaction preview / transaction quote / simulate transactions and show result
+// 
+// provide good images for the blockchains
+// connect wallet