@deserialize/multi-vm-wallet 1.3.0 → 1.3.2

package/utils/evm/smartWallet.ts

@@ -33,8 +33,7 @@ import {
 // Import AA service from local aa-service
 import { AccountAbstractionService } from "./aa-service/services/account-abstraction";
 import {
-    createKernelAuthorization,
-    sendSponsoredBatchTransaction
+    createKernelAuthorization
 } from "./aa-service/lib/kernel-account";
 import type {
     KernelAccountInstance,
@@ -62,17 +61,14 @@ export class EVMSmartWallet {
     private options: SmartWalletOptions;
     private sessionAccount: any = null;
     private paymasterConfig: PaymasterConfig | null = null;
-    private bundlerUrl: string;
 
     constructor(
         privateKey: string,
         chain: Chain,
-        bundlerUrl: string,
         options: SmartWalletOptions = {}
     ) {
         this.ownerAccount = privateKeyToAccount(privateKey as Hex);
         this.chain = chain;
-        this.bundlerUrl = bundlerUrl;
         this.options = {
             entryPointVersion: '0.7',
             autoInitialize: true,
@@ -95,22 +91,26 @@ export class EVMSmartWallet {
      * Initialize the smart wallet
      * Creates the Kernel account and sets up delegation if needed
      */
-    async initialize(): Promise<void> {
+    async initialize(): Promise<EVMSmartWallet> {
         try {
-            // Initialize AA service singleton with custom bundler URL
+            // Initialize AA service singleton with AA config
             this.aaService = AccountAbstractionService.getInstance({
                 bundlerProvider: 'custom',
-                customBundlerUrl: this.bundlerUrl
+                customBundlerUrl: this.options.bundlerUrl!,
+                aaConfig: this.options.aaConfig
             });
 
             // Create Kernel account
             this.kernelAccount = await this.aaService.createAccount({
                 chain: this.chain,
                 owner: this.ownerAccount,
-                entryPointVersion: this.options.entryPointVersion
+                entryPointVersion: this.options.entryPointVersion,
+                aaConfig: this.options.aaConfig
             });
 
             console.log(`Smart wallet initialized: ${this.kernelAccount.address}`);
+
+            return this
         } catch (error) {
             throw new SmartWalletError(
                 `Failed to initialize smart wallet: ${error instanceof Error ? error.message : 'Unknown error'}`,
@@ -700,90 +700,12 @@ export class EVMSmartWallet {
         if (!this.aaService) {
             return {
                 provider: 'custom',
-                url: this.bundlerUrl
+                url: this.options.bundlerUrl || ''
             };
         }
         return this.aaService.getBundlerInfo(this.chain);
     }
 
-    // ============================================
-    // Sponsored Transactions (EIP-7702)
-    // ============================================
-
-    /**
-     * Send sponsored batch transaction where another wallet pays gas fees
-     * Requires smart wallet to be initialized
-     *
-     * @param calls - Array of calls to execute
-     * @param feePayerPrivateKey - Private key of the wallet paying gas fees
-     * @returns Transaction result with userOpHash and transactionHash
-     *
-     * @example
-     * // Send ETH transfer with sponsor paying gas
-     * const result = await smartWallet.sendSponsoredBatchTransaction(
-     *   [{ to: recipient, value: parseEther('0.1') }],
-     *   sponsorPrivateKey
-     * );
-     */
-    async sendSponsoredBatchTransaction(
-        calls: Call[],
-        feePayerPrivateKey: Hex
-    ): Promise<SmartWalletTransactionResult> {
-        if (!this.aaService) {
-            throw new SmartWalletError(
-                'Smart wallet not initialized. Call initialize() first.',
-                'NOT_INITIALIZED'
-            );
-        }
-
-        if (!this.kernelAccount) {
-            throw new SmartWalletError(
-                'Kernel account not found. Smart wallet may not be properly initialized.',
-                'ACCOUNT_NOT_FOUND'
-            );
-        }
-
-        try {
-            // Create authorization for owner wallet
-            const authorization = await createKernelAuthorization({
-                owner: this.ownerAccount,
-                chain: this.chain,
-                bundlerManager: this.aaService.getBundlerManager(this.chain)
-            });
-
-            if (!authorization) {
-                throw new SmartWalletError(
-                    'Failed to create authorization for sponsored transaction',
-                    'AUTHORIZATION_FAILED'
-                );
-            }
-
-            // Send sponsored transaction with feePayer
-            const result = await sendSponsoredBatchTransaction({
-                ownerAuthorization: authorization,
-                calls,
-                feePayerPrivateKey,
-                bundlerUrl: this.bundlerUrl,
-                paymasterUrl: this.paymasterConfig?.paymasterUrl,
-                chain: this.chain,
-                entryPointVersion: this.options.entryPointVersion
-            });
-
-            return {
-                success: true,
-                userOpHash: result.userOpHash,
-                transactionHash: result.transactionHash
-            };
-        } catch (error) {
-            console.error('Sponsored batch transaction failed:', error);
-            return {
-                success: false,
-                userOpHash: '0x' as Hex,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
-            };
-        }
-    }
-
     /**
      * Clear all caches
      */

package/utils/evm/utils.ts

@@ -641,6 +641,7 @@ export const safeApprove = async (
 
 export const discoverTokens = async (wallet: string, chain: ChainWalletConfig): Promise<UserTokenBalance<string>[]> => {
     const balances = await HelperAPI.getUserToken(wallet, chain.vmType ?? "EVM", chain.chainId)
+    console.log('balances: ', JSON.stringify(balances));
 
 
     const formatBalances: UserTokenBalance<string>[] = balances.data.map((token: any) => {
@@ -1008,7 +1009,7 @@ export const discoverNFTs = async (wallet: string, chain: ChainWalletConfig): Pr
         console.log('discoverNFTs: Successfully fetched', response.data.length, 'NFTs');
 
         // Filter out spam NFTs if desired (optional)
-        const evmNfts = response.data.filter(nft => !nft.contract.isSpam);
+        const evmNfts = response.data.filter((nft: any) => !nft.contract.isSpam);
 
         console.log('discoverNFTs: After spam filtering:', evmNfts.length, 'NFTs');
 

package/utils/helpers/index.ts

@@ -1,21 +1,158 @@
 export * from './routeScan';
 import { vmTypes, EVMNFTResponse } from "../types";
+import { RouteScanAPI } from './routeScan';
 
 const BASE_URL = "https://helper.decane.app"
 
 export class HelperAPI {
+    /**
+     * Get network name from chainId for RouteScan API
+     * Defaults to 'mainnet' for most chains
+     */
+    private static getNetworkFromChainId(chainId: number): string {
+        // Map common testnet chain IDs to 'testnet'
+        const testnets = [11155111, 80001, 5, 97, 421614, 84532]; // Sepolia, Mumbai, Goerli, BSC Testnet, Arbitrum Sepolia, Base Sepolia
+        if (testnets.includes(chainId)) {
+            return 'testnet';
+        }
+        return 'mainnet';
+    }
+
     static async getUserToken(wallet: string, vm: vmTypes, chainId: number) {
+        // Only try RouteScan for EVM chains
+        if (vm === 'EVM') {
+            try {
+                const network = this.getNetworkFromChainId(chainId);
+                const routeScanData = await RouteScanAPI.getTokenTransfers(
+                    network,
+                    chainId,
+                    wallet,
+                    undefined, // contractaddress
+                    0, // startblock
+                    99999999, // endblock
+                    1, // page
+                    100, // offset - get more results
+                    'desc' // sort by newest first
+                );
+
+                // If RouteScan succeeds and has valid data, transform to expected format
+                if (routeScanData && routeScanData.status === '1' && routeScanData.result) {
+                    // Group token transfers by contract address to get unique tokens
+                    const tokenMap = new Map<string, any>();
+
+                    for (const transfer of routeScanData.result) {
+                        const address = transfer.contractAddress.toLowerCase();
+
+                        if (!tokenMap.has(address)) {
+                            tokenMap.set(address, {
+                                contractAddress: transfer.contractAddress,
+                                name: transfer.tokenName,
+                                symbol: transfer.tokenSymbol,
+                                decimals: parseInt(transfer.tokenDecimal) || 0,
+                                balance: '0', // RouteScan doesn't provide current balance
+                                logo: undefined
+                            });
+                        }
+                    }
+
+                    // Transform to expected format with 'data' field
+                    return {
+                        data: Array.from(tokenMap.values())
+                    };
+                }
+            } catch (error) {
+                console.warn('RouteScan API failed, falling back to helper.decane.app:', error);
+            }
+        }
+
+        // Fallback to original API
         const res = await fetch("" + BASE_URL + `/${vm}/tokens/discover?wallet=${wallet}&chainId=${chainId}`);
         const data = await res.json();
         return data;
     }
 
-    static async getUserNFTs(wallet: string, vm: vmTypes, chainId: number): Promise<EVMNFTResponse> {
+    static async getUserNFTs(wallet: string, vm: vmTypes, chainId: number): Promise<EVMNFTResponse | any> {
+        // Only try RouteScan for EVM chains
+        if (vm === 'EVM') {
+            try {
+                const network = this.getNetworkFromChainId(chainId);
+                const routeScanData = await RouteScanAPI.getNftTransfers(
+                    network,
+                    chainId,
+                    wallet,
+                    undefined, // contractaddress
+                    0, // startblock
+                    99999999, // endblock
+                    1, // page
+                    100, // offset
+                    'desc' // sort by newest first
+                );
+
+                // If RouteScan succeeds and has valid data, transform to EVMNFTResponse format
+                if (routeScanData && routeScanData.status === '1' && routeScanData.result) {
+                    // Map RouteScan NFT transfers to EVMNFTResponse format
+                    const nfts = routeScanData.result.map(nftTx => ({
+                        contract: {
+                            address: nftTx.contractAddress,
+                            name: nftTx.tokenName,
+                            symbol: nftTx.tokenSymbol,
+                            totalSupply: '0',
+                            tokenType: 'ERC721', // Default, RouteScan doesn't specify
+                            contractDeployer: '',
+                            deployedBlockNumber: parseInt(nftTx.blockNumber) || 0,
+                            isSpam: false
+                        },
+                        tokenId: nftTx.tokenID,
+                        tokenType: 'ERC721', // Default
+                        name: nftTx.tokenName,
+                        description: '',
+                        balance: '1', // Default for NFTs
+                        timeLastUpdated: nftTx.timeStamp,
+                        acquiredAt: nftTx.timeStamp
+                    }));
+
+                    return {
+                        data: nfts
+                    };
+                }
+            } catch (error) {
+                console.warn('RouteScan API failed, falling back to helper.decane.app:', error);
+            }
+        }
+
+        // Fallback to original API
         const res = await fetch("" + BASE_URL + `/${vm}/nfts/discover?wallet=${wallet}&chainId=${chainId}`);
         const data = await res.json();
         return data;
     }
+
     static async getTransactionHistory(wallet: string, vm: vmTypes, chainId: number, limit: number = 20) {
+        // Only try RouteScan for EVM chains
+        if (vm === 'EVM') {
+            try {
+                const network = this.getNetworkFromChainId(chainId);
+                const routeScanData = await RouteScanAPI.getTxList(
+                    network,
+                    chainId,
+                    wallet,
+                    0, // startblock
+                    99999999, // endblock
+                    1, // page
+                    limit, // offset (number of results)
+                    'desc' // sort by newest first
+                );
+
+                // If RouteScan succeeds and has valid data, transform it to expected format
+                // Return RouteScan response as-is - consumer will handle the transformation
+                if (routeScanData && routeScanData.status === '1' && routeScanData.result) {
+                    return routeScanData;
+                }
+            } catch (error) {
+                console.warn('RouteScan API failed, falling back to helper.decane.app:', error);
+            }
+        }
+
+        // Fallback to original API
         const res = await fetch("" + BASE_URL + `/${vm}/transactions/history?wallet=${wallet}&chainId=${chainId}&limit=${limit}`);
         const data = await res.json();
         return data;

package/utils/svm/svm.ts

@@ -2,7 +2,7 @@ import { Connection, Keypair, PublicKey, Transaction, VersionedTransaction } fro
 import { SVMDeriveChildPrivateKey } from "../walletBip32";
 import { VM } from "../vm";
 import { ChainWallet } from "../IChainWallet";
-import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionResult, NFT, FeePayerOptions } from "../types";
+import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionResult, NFT } from "../types";
 import {
     getSvmNativeBalance,
     getTokenBalance,
@@ -117,56 +117,38 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
         return nfts
     }
 
-    async transferNative(to: PublicKey, amount: number, feePayerOptions?: FeePayerOptions): Promise<TransactionResult> {
+    async transferNative(to: PublicKey, amount: number): Promise<TransactionResult> {
         // Implement native transfer logic here
-        let feePayerKeypair: Keypair | undefined;
-
-        if (feePayerOptions) {
-            // Convert feePayer private key to Keypair
-            feePayerKeypair = Keypair.fromSecretKey(base58.decode(feePayerOptions.privateKey));
-        }
-
         const transaction = await getTransferNativeTransaction(
             this.privateKey,
             to,
             amount,
-            this.connection!,
-            feePayerKeypair
+            this.connection!
         );
 
         const hash = await SVMVM.signAndSendTransaction(
             transaction,
             this.connection!,
-            this.privateKey,
-            feePayerKeypair ? { feePayerSigner: feePayerKeypair } : undefined
+            this.privateKey
         );
 
         return { success: true, hash };
     }
 
-    async transferToken(token: TokenInfo, to: PublicKey, amount: number, feePayerOptions?: FeePayerOptions): Promise<TransactionResult> {
+    async transferToken(token: TokenInfo, to: PublicKey, amount: number): Promise<TransactionResult> {
         // Implement token transfer logic here
-        let feePayerKeypair: Keypair | undefined;
-
-        if (feePayerOptions) {
-            // Convert feePayer private key to Keypair
-            feePayerKeypair = Keypair.fromSecretKey(base58.decode(feePayerOptions.privateKey));
-        }
-
         const transaction = await getTransferTokenTransaction(
             this.privateKey,
             new PublicKey(to),
             token,
             amount,
-            this.connection!,
-            feePayerKeypair
+            this.connection!
         );
 
         const hash = await SVMVM.signAndSendTransaction(
             transaction,
             this.connection!,
-            this.privateKey,
-            feePayerKeypair ? { feePayerSigner: feePayerKeypair } : undefined
+            this.privateKey
         );
 
         return { success: true, hash };

package/utils/svm/utils.ts

@@ -281,8 +281,7 @@ export const getTransferNativeTransaction = async (
     from: Keypair,
     to: PublicKey,
     amount: number,
-    connection: Connection,
-    feePayerKeypair?: Keypair
+    connection: Connection
 ) => {
     console.log('getTransferNativeTransaction: Starting');
     const instruction = await getTransferNativeInx(from.publicKey, to, amount);
@@ -290,9 +289,7 @@ export const getTransferNativeTransaction = async (
         connection,
         [instruction],
         [from],
-        from.publicKey,
-        undefined,
-        feePayerKeypair?.publicKey
+        from.publicKey
     );
     console.log('getTransferNativeTransaction: Completed');
     return transaction;
@@ -475,8 +472,7 @@ export const getTransferTokenTransaction = async (
     to: PublicKey,
     token: TokenInfo,
     amount: number,
-    connection: Connection,
-    feePayerKeypair?: Keypair
+    connection: Connection
 ): Promise<VersionedTransaction> => {
     console.log('getTransferTokenTransaction: Starting');
     const instruction = await getTransferTokenInx(from.publicKey, to, token, amount, connection);
@@ -484,9 +480,7 @@ export const getTransferTokenTransaction = async (
         connection,
         instruction,
         [from],
-        from.publicKey,
-        undefined,
-        feePayerKeypair?.publicKey
+        from.publicKey
     );
     console.log('getTransferTokenTransaction: Completed');
     return transaction;

package/utils/test.ts

@@ -11,12 +11,15 @@ import { ChainWalletConfig } from "./types";
 import { discoverNFTs, EVMChainWallet } from "./evm";
 import { } from "./svm/transactionParsing";
 import { getEVMTransactionHistory } from "./evm/transactionParsing";
-import { createPublicClient, http, PublicClient } from "viem";
+import { createPublicClient, encodeFunctionData, Hex, http, parseAbi, parseUnits, PublicClient } from "viem";
 import { base, baseGoerli } from "viem/chains";
 import { discoverTokens, fetchWalletNfts, getTokenInfo } from "./svm/utils";
 import { JsonRpcProvider } from "ethers";
 
 import { } from "@solana/spl-token-metadata"
+import { entryPoint07Address } from "viem/account-abstraction";
+
+import { KERNEL_V3_3, KernelVersionToAddressesMap } from '@zerodev/sdk/constants';
 // const mnemonic = GenerateNewMnemonic()
 
 
@@ -31,6 +34,8 @@ const evePrivateKey = "0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01
 const evmPrivateKey2 = "0x0123456789012345678901234567890123456789012345678901234567890123"
 const ogPrivKey = "d2d3f7117aa9a4c6e5d4affedd8a5ea624ffd82b2a1de81509e5913709b1ea72"
 
+const evmPrivKey = "0xc9ca95aa5f40bae8b0f741ec89acc07b837590b2f9f818d3439df98c6e4f8dbe"
+const evmPrivateKeyExposed = "0x92cccc7792024dcac5992e5d2986dade41770acfd3dab0fe98ee953ed1bf0c3a"
 // const vm = new SVMVM(seed)
 
 
@@ -53,13 +58,31 @@ const chainConfig: ChainWalletConfig = {
 
 const evmChainConfig: ChainWalletConfig = {
     chainId: 8453,
-    name: "Ethereum",
-    rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/lhoyb3hc9ccT9NA_y2cfA",
+    name: "Base",
+    // rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/lhoyb3hc9ccT9NA_y2cfA",
+    rpcUrl: base.rpcUrls.default.http[0],
     explorerUrl: "https://explorer.ethereum.com",
     nativeToken: { name: "Ethereum", symbol: "ETH", decimals: 18 },
     confirmationNo: 1,
     vmType: "EVM",
-    logoUrl: ""
+    logoUrl: "",
+    aaSupport: {
+        enabled: true,
+        entryPoints: [
+            {
+                address: entryPoint07Address,
+                version: "0.7"
+            }
+        ],
+        bundlerUrl: `https://api.pimlico.io/v2/${8453}/rpc?apikey=pim_3UEhbTpS98H1XFm8p9kRxg`,
+        paymasterUrl: "",
+        kernelImplementations: [
+            {
+                address: KernelVersionToAddressesMap[KERNEL_V3_3].accountImplementationAddress,
+                version: 3
+            }
+        ]
+    }
 }
 
 const OgChainConfig: ChainWalletConfig = {
@@ -76,13 +99,54 @@ const OgChainConfig: ChainWalletConfig = {
 
 
 // const wallet = new SVMChainWallet(chainConfig, testUserKeyPair, 0)
-const wallet = new EVMChainWallet(OgChainConfig, ogPrivKey, 0)
-wallet.getNativeBalance().then(console.log)
+const wallet = new EVMChainWallet(evmChainConfig, evmPrivateKeyExposed, 0)
+
+//IIFE
+const walletA = new EVMChainWallet(evmChainConfig, evmPrivateKeyExposed, 0); //wallet that usdc to send
+const walletB = new EVMChainWallet(evmChainConfig, evmPrivKey, 0); // wallet that has gas
+const SEPOLIA_USDC_ADDRESS = '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238' as Hex;
+const BASE_USDC_ADDRESS = '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913' as Hex;
+const bundlerUrl = `https://api.pimlico.io/v2/${evmChainConfig.chainId}/rpc?apikey=pim_3UEhbTpS98H1XFm8p9kRxg`;
+
+const RECIPIENT = "0x7027F9C9a701adCbfCD55D16aD219501D4b9589A";
+(async () => {
+    return
+    console.log("walletA address: ", walletA.address);
+    console.log("walletB address: ", walletB.address);
+
+
+    //GET TOKEN LOGO using @solana/spl-token-metadata
+    const walletANativeBalance = await walletA.getNativeBalance();
+    console.log('walletA native balance: ', walletANativeBalance);
+
+    const walletBNativeBalance = await walletB.getNativeBalance();
+    console.log('walletB native balance: ', walletBNativeBalance);
+
+    //wallet B USDC balance
+    const walletBUSDCBalance = await walletB.getTokenBalance(BASE_USDC_ADDRESS);
+    console.log('walletB USDC balance: ', walletBUSDCBalance);
+
+    //extend wallet A wallet to a smart wallet with AA support
+    const extendedWalletA = await walletA.extend({
+        bundlerUrl: bundlerUrl
+    })
+
+    // console.log('extendedWalletA: ', extendedWalletA);
+    const initializedExtendedWalletA = await extendedWalletA.initialize()
+
+    // console.log('initializedExtendedWalletA: ', initializedExtendedWalletA);
+
+
+
+})();
+
+
+
 // console.log('wallet: ', wallet);
 // getTokenInfo(new PublicKey("9BB6NFEcjBCtnNLFko2FqVQBq8HHM13kCyYcdQbgpump"), wallet.connection!).then(e => console.log('token info: ', e))
-// wallet.discoverToken().then(e => console.log('discovered tokens: ', e))
+wallet.discoverToken().then(e => console.log('discovered tokens: ', e))
 // wallet.getNativeBalance().then(e => console.log('native balance: ', e))
-console.log('address: ', wallet.address);
+
 // const toBuy = new PublicKey("9BB6NFEcjBCtnNLFko2FqVQBq8HHM13kCyYcdQbgpump")
 // wallet.swap({
 //     name: NATIVE_MINT.toBase58(),
@@ -125,19 +189,19 @@ const connection = new Connection(RPC_URL);
 // }).catch((error: any) => {
 //     console.error("Error fetching transaction history:", error);
 // });
-const client = createPublicClient({
-    chain: base,
-    transport: http(base.rpcUrls.default.http[0]),
-})
-
-getEVMTransactionHistory(client as PublicClient, "0x9C82CE0e125F61AdE50BC0c19638F6Ba93d71D5e", {
-    startBlock: BigInt(37427020)
-    // before: "0xabc..."
-}).then((history: any) => {
-    console.log("EVM Transaction History:", history);
-}).catch((error: any) => {
-    console.error("Error fetching EVM transaction history:", error);
-});
+// const client = createPublicClient({
+//     chain: base,
+//     transport: http(base.rpcUrls.default.http[0]),
+// })
+
+// getEVMTransactionHistory(client as PublicClient, "0x9C82CE0e125F61AdE50BC0c19638F6Ba93d71D5e", {
+//     startBlock: BigInt(37427020)
+//     // before: "0xabc..."
+// }).then((history: any) => {
+//     console.log("EVM Transaction History:", history);
+// }).catch((error: any) => {
+//     console.error("Error fetching EVM transaction history:", error);
+// });
 
 // discoverNFTs("0x498581ff718922c3f8e6a244956af099b2652b2b", evmChainConfig).then(nfts => {
 //     console.log("Discovered NFTs:", nfts);

package/utils/types.ts

@@ -21,22 +21,24 @@ export interface ChainWalletConfig {
 
     // Smart wallet configuration (optional) only for EVM chains and 7702
 
-    aaSupport?: {
-        enabled: boolean;
-        entryPoints: {
-            address: string;
-            version: EntryPointVersion;
-        }[]
-        bundlerUrl: string;
-        paymasterUrl: string;
-        kernelImplementations: {
-            address: string;
-            version: number;
-        }[];
-    };
+    aaSupport?: AA_SupportConfig
 
 }
 
+export interface AA_SupportConfig {
+    enabled: boolean;
+    entryPoints: {
+        address: string;
+        version: EntryPointVersion;
+    }[]
+    bundlerUrl: string;
+    paymasterUrl: string;
+    kernelImplementations: {
+        address: string;
+        version: number;
+    }[];
+}
+
 export interface TokenInfo {
     address: string;
     name: string;
@@ -262,10 +264,6 @@ export interface TransactionResult {
     error?: string;
 }
 
-export interface FeePayerOptions {
-    privateKey: string;  // Private key of the wallet paying fees
-}
-
 export interface Balance {
     balance: BN;
     formatted: number;