@deserialize/multi-vm-wallet 1.2.2 → 1.2.4

package/utils/evm/transactionParsing.ts

@@ -610,30 +610,4 @@ async function parseTransferLogs(
     return { tokens, nfts };
 }
 
-/**
- * Helper function to create a client
- */
-export function createEVMClient(rpcUrl: string) {
-    return createPublicClient({
-        transport: http(rpcUrl),
-    });
-}
-
-// Example usage:
-/*
-import { mainnet } from 'viem/chains';
-
-const client = createPublicClient({
-  chain: mainnet,
-  transport: http('https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY'),
-});
-
-const history = await getEVMTransactionHistoryWithAPI(
-  client,
-  '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb' as Address,
-  'https://api.etherscan.io/api',
-  'YOUR_ETHERSCAN_API_KEY'
-);
 
-console.log(history);
-*/

package/utils/evm/utils.ts

@@ -1,7 +1,8 @@
-import { Balance, ChainWalletConfig, SUPPORTED_VM, UserTokenBalance, TokenInfo } from '../types'
-import { JsonRpcProvider, Contract, Wallet, TransactionRequest, TransactionResponse, TransactionReceipt, parseUnits, formatUnits } from 'ethers'
+import { Balance, ChainWalletConfig, SUPPORTED_VM, UserTokenBalance, TokenInfo, EVMNFT, NFT } from '../types'
+import { JsonRpcProvider, Contract, Wallet, TransactionRequest, TransactionResponse, TransactionReceipt, parseUnits, formatUnits, ethers } from 'ethers'
 import BN from 'bn.js'
 import { HelperAPI } from '../helpers';
+import BigNumber from 'bignumber.js';
 
 const KYBER_BASE_URL = 'https://aggregator-api.kyberswap.com';
 
@@ -149,10 +150,11 @@ const ERC20_ABI = [
 
 export const getNativeBalance = async (address: string, provider: JsonRpcProvider): Promise<Balance> => {
     const balance = await provider.getBalance(address)
+    const final = ethers.formatEther(balance)
 
     return {
         balance: new BN(balance),
-        formatted: Number(balance / 10n ** 18n),
+        formatted: Number(final),
         decimal: 18
     }
 }
@@ -654,6 +656,24 @@ export const discoverTokens = async (wallet: string, chain: ChainWalletConfig):
     return formatBalances
 }
 
+export function calcGasTotal(gasLimit = '0', gasPrice = '0') {
+    return new BN(gasLimit, 16).mul(new BN(gasPrice, 16)).toString();
+}
+export function toPrecisionWithoutTrailingZeros(n: number, precision: number) {
+    return new BigNumber(n)
+        .toPrecision(precision)
+        .replace(/(\.[0-9]*[1-9])0*|(\.0*)/u, '$1');
+}
+
+/**
+ * @param {number|string|BigNumber} value
+ * @param {number=} decimals
+ * @returns {BigNumber}
+ */
+export function calcTokenAmount(value: number | string | BigNumber, decimals?: number): BigNumber {
+    const divisor = new BigNumber(10).pow(decimals ?? 0);
+    return new BigNumber(String(value)).div(divisor);
+}
 //swaps
 
 
@@ -934,4 +954,91 @@ export function prepareSwapParams(
 
 export function convertSlippageForDebonk(slippageBps: number): number {
     return slippageBps / 100;
+}
+
+export const transformEVMNFTToUnified = (nft: EVMNFT): NFT => {
+    // Extract image URL from various sources
+    const imageUrl = nft.image?.cachedUrl ||
+                     nft.image?.thumbnailUrl ||
+                     nft.image?.pngUrl ||
+                     nft.image?.originalUrl ||
+                     nft.openSeaMetadata?.imageUrl ||
+                     nft.raw?.metadata?.image ||
+                     undefined;
+
+    // Extract attributes
+    const attributes = nft.raw?.metadata?.attributes?.map(attr => ({
+        trait_type: attr.trait_type,
+        value: attr.value,
+        display_type: attr.display_type
+    }));
+
+    return {
+        id: `${nft.contract.address}:${nft.tokenId}`,
+        name: nft.name || nft.raw?.metadata?.name || 'Unknown',
+        symbol: nft.contract.symbol,
+        description: nft.description || nft.raw?.metadata?.description || '',
+        image: imageUrl,
+        uri: nft.raw?.tokenUri || '',
+        collection: {
+            address: nft.contract.address,
+            name: nft.openSeaMetadata?.collectionName || nft.contract.name,
+            verified: nft.openSeaMetadata?.safelistRequestStatus === 'verified'
+        },
+        chainType: 'EVM',
+        balance: nft.balance,
+        attributes,
+        tokenStandard: nft.tokenType,
+        isSpam: nft.contract.isSpam,
+        raw: {
+            evm: nft
+        }
+    };
+};
+
+export const discoverNFTs = async (wallet: string, chain: ChainWalletConfig): Promise<NFT[]> => {
+    console.log('discoverNFTs: Starting NFT discovery');
+    console.log('Wallet:', wallet);
+    console.log('Chain:', chain.name, 'ChainId:', chain.chainId);
+
+    try {
+        const response = await HelperAPI.getUserNFTs(wallet, chain.vmType ?? "EVM", chain.chainId);
+
+        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);
+
+        console.log('discoverNFTs: After spam filtering:', evmNfts.length, 'NFTs');
+
+        // Transform to unified NFT format
+        const nfts = evmNfts.map(transformEVMNFTToUnified);
+
+        return nfts;
+    } catch (error) {
+        console.error('discoverNFTs: Error fetching NFTs:', error);
+        console.error('Error details:', error instanceof Error ? error.message : 'Unknown error');
+        throw error;
+    }
+}
+
+export const discoverAllNFTs = async (wallet: string, chain: ChainWalletConfig): Promise<NFT[]> => {
+    console.log('discoverAllNFTs: Starting NFT discovery (including spam)');
+    console.log('Wallet:', wallet);
+    console.log('Chain:', chain.name, 'ChainId:', chain.chainId);
+
+    try {
+        const response = await HelperAPI.getUserNFTs(wallet, chain.vmType ?? "EVM", chain.chainId);
+
+        console.log('discoverAllNFTs: Successfully fetched', response.data.length, 'NFTs (including spam)');
+
+        // Transform to unified NFT format
+        const nfts = response.data.map(transformEVMNFTToUnified);
+
+        return nfts;
+    } catch (error) {
+        console.error('discoverAllNFTs: Error fetching NFTs:', error);
+        console.error('Error details:', error instanceof Error ? error.message : 'Unknown error');
+        throw error;
+    }
 }

package/utils/helpers/index.ts

@@ -1,4 +1,4 @@
-import { vmTypes } from "../types";
+import { vmTypes, EVMNFTResponse } from "../types";
 
 const BASE_URL = "https://helper.decane.app"
 
@@ -8,4 +8,10 @@ export class HelperAPI {
         const data = await res.json();
         return data;
     }
+
+    static async getUserNFTs(wallet: string, vm: vmTypes, chainId: number): Promise<EVMNFTResponse> {
+        const res = await fetch("" + BASE_URL + `/${vm}/nfts/discover?wallet=${wallet}&chainId=${chainId}`);
+        const data = await res.json();
+        return data;
+    }
 }

package/utils/svm/svm.ts

@@ -1,8 +1,8 @@
-import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import { Connection, Keypair, PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
 import { SVMDeriveChildPrivateKey } from "../walletBip32";
 import { VM } from "../vm";
 import { ChainWallet } from "../IChainWallet";
-import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionResult } from "../types";
+import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionResult, NFT } from "../types";
 import {
     getSvmNativeBalance,
     getTokenBalance,
@@ -16,7 +16,10 @@ import {
     validateJupiterTokens,
     JupiterQuoteResponse,
     getTokenInfo,
-    discoverTokens
+    discoverTokens,
+    signTransaction,
+    sendTransaction,
+    fetchWalletNfts
 } from "./utils";
 import BN from "bn.js";
 import nacl from "tweetnacl";
@@ -26,6 +29,7 @@ import { getSVMTransactionHistory, SVMTransactionHistoryItem } from "./transacti
 
 export class SVMVM extends VM<PublicKey, Keypair, Connection> {
     getTokenInfo = getTokenInfo
+    static getTokenInfo = getTokenInfo
     static validateAddress(address: PublicKey): boolean {
         try {
             new PublicKey(address)
@@ -54,6 +58,10 @@ export class SVMVM extends VM<PublicKey, Keypair, Connection> {
 
     static signAndSendTransaction = signAndSendTransaction
 
+    static signTransaction = signTransaction
+
+    static sendTransaction = sendTransaction
+
 
     generatePrivateKey(index: number, seed?: string, mnemonic?: string, derivationPath = this.derivationPath) {
         let _seed: string
@@ -91,6 +99,8 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
         return await SVMVM.getNativeBalance(this.address, this.connection!)
     }
 
+
+
     async getTokenBalance(tokenAddress: PublicKey): Promise<Balance> {
         // Implement token balance retrieval logic here
         return await SVMVM.getTokenBalance(this.address, (tokenAddress), this.connection!);
@@ -101,25 +111,47 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
         return tokens
     }
 
+    async discoverNFT(): Promise<NFT[]> {
+        // Implement NFT discovery logic here
+        const nfts = await fetchWalletNfts(this.address, this.connection!)
+        return nfts
+    }
+
     async transferNative(to: PublicKey, amount: number): Promise<TransactionResult> {
         // Implement native transfer logic here
         const transaction = await getTransferNativeTransaction(this.privateKey, to, amount, this.connection!)
-        const hash = await SVMVM.signAndSendTransaction(transaction, this.connection!, [this.privateKey]);
+        const hash = await SVMVM.signAndSendTransaction(transaction, this.connection!, this.privateKey);
         return { success: true, hash } // Placeholder
     }
 
     async transferToken(token: TokenInfo, to: PublicKey, amount: number): Promise<TransactionResult> {
         // Implement token transfer logic here
         const transaction = await getTransferTokenTransaction(this.privateKey, new PublicKey(to), token, (amount), this.connection!);
-        const hash = await SVMVM.signAndSendTransaction(transaction, this.connection!, [this.privateKey]);
+        const hash = await SVMVM.signAndSendTransaction(transaction, this.connection!, this.privateKey);
         return { success: true, hash }; // Placeholder
     }
 
+    async signTransaction(transaction: VersionedTransaction | Transaction) {
+        return await SVMVM.signTransaction(transaction, this.privateKey)
+    }
+
+    async sendTransaction(transaction: VersionedTransaction | Transaction) {
+        return await SVMVM.sendTransaction(transaction, this.connection!)
+    }
+
+    async signAndSendTransaction(transaction: VersionedTransaction | Transaction) {
+        return await SVMVM.signAndSendTransaction(transaction, this.connection!, this.privateKey);
+    }
+
     async getTransactionHistory(): Promise<SVMTransactionHistoryItem[]> {
         const history = await getSVMTransactionHistory(this.connection!, this.address);
         return history;
     }
 
+    async getTokenInfo(tokenAddress: PublicKey) {
+        return await SVMVM.getTokenInfo(tokenAddress, this.connection!)
+    }
+
     async swap(fromToken: TokenInfo, toToken: PublicKey, amount: number, slippage: number = 50): Promise<TransactionResult> {
         try {
             if (amount <= 0) {
@@ -235,9 +267,8 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
             };
         }
     }
-    signMessage = (message: string, signer: Keypair) => {
-        const messageBytes = new TextEncoder().encode(message);
-        const signature = nacl.sign.detached(messageBytes, signer.secretKey);
-        return base58.encode(signature);
+    signMessage = (message: Uint8Array<ArrayBuffer>,) => {
+        const signature = nacl.sign.detached(message, this.privateKey.secretKey);
+        return signature
     };
 }

package/utils/svm/utils.ts

@@ -1,11 +1,20 @@
 //we will write all the svm utils function here
 
 import { Account, createAssociatedTokenAccountIdempotentInstruction, createTransferCheckedInstruction, getAccount, getAssociatedTokenAddress, getAssociatedTokenAddressSync, getMint, Mint, NATIVE_MINT, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
-import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, SystemProgram, TransactionInstruction, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
-import { ChainWalletConfig, UserTokenBalance, TokenInfo } from "../types";
+import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, SystemProgram, Transaction, TransactionInstruction, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
+import { ChainWalletConfig, UserTokenBalance, TokenInfo, SolanaNFT, NFT } from "../types";
 import { transactionSenderAndConfirmationWaiter } from "./transactionSender";
 import { BN } from "bn.js";
-import { Metaplex } from "@metaplex-foundation/js";
+import { generateSigner, percentAmount, publicKey } from '@metaplex-foundation/umi'
+import {
+    createNft,
+    fetchDigitalAsset,
+    fetchAllDigitalAssetByOwner,
+    mplTokenMetadata,
+} from '@metaplex-foundation/mpl-token-metadata'
+import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
+
+import { PublicKey as UmiPublicKey } from "@metaplex-foundation/umi-public-keys"
 
 const JUPITER_BASE_URL = 'https://lite-api.jup.ag';
 
@@ -271,15 +280,16 @@ export const getTransferNativeTransaction = async (from: Keypair, to: PublicKey,
     console.log('getTransferNativeTransaction: Completed');
     return transaction;
 }
-const getMetaTokenMetaplexData = (mintAddress: PublicKey, connection: Connection) => {
-    const metaplex = Metaplex.make(connection);
-    return metaplex.nfts().findByMint({ mintAddress: mintAddress });
+const getMetaTokenMetaplexData = async (mintAddress: PublicKey, connection: Connection) => {
+    const umi = createUmi(connection.rpcEndpoint).use(mplTokenMetadata())
+    const ass = await fetchDigitalAsset(umi, mintAddress.toBase58() as unknown as UmiPublicKey)
+    return ass.metadata
+
 }
 
 export const getTokenInfo = async (tokenAddress: PublicKey, connection: Connection, programId?: PublicKey): Promise<TokenInfo> => {
     let mint: Mint
 
-
     const metaplexData = await getMetaTokenMetaplexData(tokenAddress, connection).catch(() => null);
     if (programId) {
         const mint = await getMint(connection, tokenAddress, "confirmed", programId)
@@ -347,17 +357,31 @@ export const getTransferTokenTransaction = async (from: Keypair, to: PublicKey,
     return transaction;
 }
 
-export const signAndSendTransaction = async (transaction: VersionedTransaction, connection: Connection, signers: Keypair[]) => {
-    console.log('signAndSendTransaction: Starting');
-    console.log('Signers count:', signers.length);
+export const signTransaction = async (
+    transaction: VersionedTransaction | Transaction,
+    signers: Keypair,
+): Promise<VersionedTransaction | Transaction> => {
+
 
-    transaction.sign(signers)
-    console.log('Transaction signed');
+    if (transaction instanceof Transaction) {
+        transaction.partialSign(signers);
 
-    const blockhash = await connection.getLatestBlockhash()
-    console.log('Got latest blockhash:', blockhash.blockhash);
+    } else {
+        transaction.sign([signers]);
+
+    }
+
+    return transaction;
+};
+
+export const sendTransaction = async (
+    transaction: VersionedTransaction | Transaction,
+    connection: Connection
+): Promise<string> => {
+
+
+    const blockhash = await connection.getLatestBlockhash();
 
-    console.log('Sending transaction...');
     const res = await transactionSenderAndConfirmationWaiter({
         connection,
         serializedTransaction: Buffer.from(transaction.serialize()),
@@ -375,7 +399,21 @@ export const signAndSendTransaction = async (transaction: VersionedTransaction,
     const signature = res.transaction.signatures[0];
     console.log('Transaction successful, signature:', signature);
     return signature;
-}
+};
+
+export const signAndSendTransaction = async (
+    transaction: VersionedTransaction | Transaction,
+    connection: Connection,
+    signers: Keypair,
+    options?: { partialSign?: boolean }
+): Promise<string> => {
+    console.log('signAndSendTransaction: Starting');
+
+    const signedTx = await signTransaction(transaction, signers);
+    const signature = await sendTransaction(signedTx, connection);
+
+    return signature;
+};
 export const discoverTokens = async (ownerAddress: PublicKey, connection: Connection): Promise<UserTokenBalance<PublicKey>[]> => {
 
     const owner = new PublicKey(ownerAddress);
@@ -723,3 +761,80 @@ export const validateJupiterTokens = async (
     }
 };
 
+export const transformSolanaNFTToUnified = (nft: SolanaNFT): NFT => {
+    return {
+        id: nft.mint,
+        name: nft.name,
+        symbol: nft.symbol,
+        description: '', // Will be populated from metadata URI if needed
+        image: undefined, // Will be populated from metadata URI if needed
+        uri: nft.uri,
+        collection: {
+            address: nft.mint,
+            name: nft.name,
+            verified: nft.creators?.some(c => c.verified) ?? false,
+        },
+        chainType: 'SVM',
+        balance: '1', // NFTs on Solana are typically quantity 1
+        creators: nft.creators,
+        sellerFeeBasisPoints: nft.sellerFeeBasisPoints,
+        tokenStandard: 'NonFungible',
+        raw: {
+            svm: nft
+        }
+    };
+};
+
+export const fetchWalletNfts = async (
+    walletAddress: PublicKey,
+    connection: Connection
+): Promise<NFT[]> => {
+    console.log('fetchWalletNfts: Starting');
+    console.log('Wallet address:', walletAddress.toString());
+
+    try {
+        // Create UMI instance with the connection's RPC endpoint
+        const umi = createUmi(connection.rpcEndpoint).use(mplTokenMetadata());
+        console.log('UMI instance created with RPC endpoint:', connection.rpcEndpoint);
+
+        // Convert Solana PublicKey to UMI PublicKey
+        const owner = publicKey(walletAddress.toString());
+        console.log('Fetching NFTs for owner:', owner);
+
+        // Fetch all digital assets owned by the wallet
+        const assets = await fetchAllDigitalAssetByOwner(umi, owner);
+        console.log('Fetched assets count:', assets.length);
+
+        // Transform the assets into our SolanaNFT format
+        const solanaNfts: SolanaNFT[] = assets.map((asset) => {
+            const metadata = asset.metadata;
+
+            return {
+                mint: asset.publicKey.toString(),
+                name: metadata.name,
+                symbol: metadata.symbol,
+                uri: metadata.uri,
+                updateAuthority: metadata.updateAuthority.toString(),
+                sellerFeeBasisPoints: metadata.sellerFeeBasisPoints,
+                creators: metadata.creators && 'value' in metadata.creators && metadata.creators.value
+                    ? metadata.creators.value.map((creator) => ({
+                        address: creator.address.toString(),
+                        verified: creator.verified,
+                        share: creator.share,
+                    }))
+                    : undefined,
+            };
+        });
+
+        // Transform to unified NFT format
+        const nfts = solanaNfts.map(transformSolanaNFTToUnified);
+
+        console.log('fetchWalletNfts: Successfully fetched', nfts.length, 'NFTs');
+        return nfts;
+    } catch (error) {
+        console.log('fetchWalletNfts: Error fetching NFTs:', error);
+        console.log('Error details:', error instanceof Error ? error.message : 'Unknown error');
+        throw error;
+    }
+};
+

package/utils/test.ts

@@ -8,11 +8,13 @@ import { Connection, PublicKey, Keypair } from "@solana/web3.js";
 import { SVMChainWallet, SVMVM, } from "./svm";
 import { VM } from "./vm";
 import { ChainWalletConfig } from "./types";
-import { EVMChainWallet } from "./evm";
+import { discoverNFTs, EVMChainWallet } from "./evm";
 import { } from "./svm/transactionParsing";
 import { getEVMTransactionHistory } from "./evm/transactionParsing";
 import { createPublicClient, http, PublicClient } from "viem";
 import { base, baseGoerli } from "viem/chains";
+import { fetchWalletNfts, getTokenInfo } from "./svm/utils";
+import { JsonRpcProvider } from "ethers";
 // const mnemonic = GenerateNewMnemonic()
 
 
@@ -25,6 +27,7 @@ export const testUserKeyPair = Keypair.fromSecretKey(base58.decode(pKey));
 const x = testUserKeyPair instanceof Keypair;
 const evePrivateKey = "0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318"
 const evmPrivateKey2 = "0x0123456789012345678901234567890123456789012345678901234567890123"
+const ogPrivKey = "d2d3f7117aa9a4c6e5d4affedd8a5ea624ffd82b2a1de81509e5913709b1ea72"
 
 // const vm = new SVMVM(seed)
 
@@ -37,7 +40,7 @@ const evmPrivateKey2 = "0x012345678901234567890123456789012345678901234567890123
 const chainConfig: ChainWalletConfig = {
     chainId: 123456789,
     name: "Solana",
-    rpcUrl: "https://solana-mainnet.g.alchemy.com/v2/vB5mKztdJeFdz9RkW99Qf",
+    rpcUrl: "https://solana-mainnet.g.alchemy.com/v2/lhoyb3hc9ccT9NA_y2cfA",
     explorerUrl: "https://explorer.solana.com",
     nativeToken: { name: "Solana", symbol: "SOL", decimals: 9 },
     confirmationNo: 1,
@@ -47,17 +50,27 @@ const chainConfig: ChainWalletConfig = {
 const evmChainConfig: ChainWalletConfig = {
     chainId: 8453,
     name: "Ethereum",
-    rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/vB5mKztdJeFdz9RkW99Qf",
+    rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/lhoyb3hc9ccT9NA_y2cfA",
     explorerUrl: "https://explorer.ethereum.com",
     nativeToken: { name: "Ethereum", symbol: "ETH", decimals: 18 },
     confirmationNo: 1,
 }
 
+const OgChainConfig: ChainWalletConfig = {
+    chainId: 16661,
+    name: "",
+    rpcUrl: "https://evmrpc.0g.ai",
+    explorerUrl: "",
+    nativeToken: { name: "Ethereum", symbol: "ETH", decimals: 18 },
+
+}
+
 
 // const wallet = new SVMChainWallet(chainConfig, testUserKeyPair, 0)
-const wallet = new EVMChainWallet(evmChainConfig, evmPrivateKey2, 0)
+const wallet = new EVMChainWallet(OgChainConfig, ogPrivKey, 0)
+wallet.getNativeBalance().then(console.log)
 // 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.getNativeBalance().then(e => console.log('native balance: ', e))
 console.log('address: ', wallet.address);
@@ -81,6 +94,10 @@ console.log('address: ', wallet.address);
 const RPC_URL = chainConfig.rpcUrl;
 const connection = new Connection(RPC_URL);
 
+// const evmConnection = new JsonRpcProvider(evmChainConfig.rpcUrl, {
+//     chainId: evmChainConfig.chainId
+// });
+
 /**
  * Fetches and logs the token metadata for a given mint address.
  * @param mintAddress - The mint address of the token.
@@ -99,17 +116,30 @@ 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);
+// }).catch(error => {
+//     console.error("Error discovering NFTs:", error);
+// });
+
+// fetchWalletNfts(new PublicKey("LebronkTYWjc5J1gtqntdMcbhBXgwRgYcCxMA8JMA17"), connection).then(nfts => {
+//     console.log("Discovered NFTs:", nfts);
+// }).catch(error => {
+//     console.error("Error discovering NFTs:", error);
+// });
+