@deserialize/multi-vm-wallet 1.2.31 → 1.2.41

package/utils/evm/utils.ts

@@ -1,4 +1,4 @@
-import { Balance, ChainWalletConfig, SUPPORTED_VM, UserTokenBalance, TokenInfo } from '../types'
+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';
@@ -954,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

@@ -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 } from "../types";
+import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionResult, NFT } from "../types";
 import {
     getSvmNativeBalance,
     getTokenBalance,
@@ -18,7 +18,8 @@ import {
     getTokenInfo,
     discoverTokens,
     signTransaction,
-    sendTransaction
+    sendTransaction,
+    fetchWalletNfts
 } from "./utils";
 import BN from "bn.js";
 import nacl from "tweetnacl";
@@ -110,6 +111,12 @@ 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!)

package/utils/svm/utils.ts

@@ -2,13 +2,14 @@
 
 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, Transaction, TransactionInstruction, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
-import { ChainWalletConfig, UserTokenBalance, TokenInfo } from "../types";
+import { ChainWalletConfig, UserTokenBalance, TokenInfo, SolanaNFT, NFT } from "../types";
 import { transactionSenderAndConfirmationWaiter } from "./transactionSender";
 import { BN } from "bn.js";
-import { generateSigner, percentAmount } from '@metaplex-foundation/umi'
+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";
@@ -283,20 +284,99 @@ const getMetaTokenMetaplexData = async (mintAddress: PublicKey, connection: Conn
     const umi = createUmi(connection.rpcEndpoint).use(mplTokenMetadata())
     const ass = await fetchDigitalAsset(umi, mintAddress.toBase58() as unknown as UmiPublicKey)
     return ass.metadata
+}
 
+interface TokenMetadata {
+    name?: string;
+    symbol?: string;
+    description?: string;
+    image?: string;
+    twitter?: string;
+    telegram?: string;
+    website?: string;
+    discord?: string;
+    extensions?: {
+        twitter?: string;
+        telegram?: string;
+        website?: string;
+        discord?: string;
+        [key: string]: string | undefined;
+    };
 }
 
+const fetchMetadataFromUri = async (uri: string): Promise<TokenMetadata | null> => {
+    try {
+        // Convert IPFS URI to HTTP gateway if needed
+        let fetchUrl = uri;
+        if (uri.startsWith('ipfs://')) {
+            fetchUrl = uri.replace('ipfs://', 'https://ipfs.io/ipfs/');
+        }
+
+        console.log('Fetching metadata from:', fetchUrl);
+        const response = await fetch(fetchUrl, {
+            headers: {
+                'Accept': 'application/json',
+            },
+        });
+
+        if (!response.ok) {
+            console.log('Failed to fetch metadata:', response.status);
+            return null;
+        }
+
+        const metadata: TokenMetadata = await response.json();
+        console.log('Metadata fetched successfully');
+        return metadata;
+    } catch (error) {
+        console.log('Error fetching metadata from URI:', error);
+        return null;
+    }
+};
+
 export const getTokenInfo = async (tokenAddress: PublicKey, connection: Connection, programId?: PublicKey): Promise<TokenInfo> => {
     let mint: Mint
 
     const metaplexData = await getMetaTokenMetaplexData(tokenAddress, connection).catch(() => null);
+
+    // Fetch metadata from URI if available
+    let uriMetadata: TokenMetadata | null = null;
+    if (metaplexData?.uri) {
+        uriMetadata = await fetchMetadataFromUri(metaplexData.uri).catch(() => null);
+    }
+
     if (programId) {
         const mint = await getMint(connection, tokenAddress, "confirmed", programId)
+
+        // Build social object from metadata
+        const social: TokenInfo['social'] = {};
+        if (uriMetadata?.twitter || uriMetadata?.extensions?.twitter) {
+            social.twitter = uriMetadata.twitter || uriMetadata.extensions?.twitter;
+        }
+        if (uriMetadata?.telegram || uriMetadata?.extensions?.telegram) {
+            social.telegram = uriMetadata.telegram || uriMetadata.extensions?.telegram;
+        }
+        if (uriMetadata?.discord || uriMetadata?.extensions?.discord) {
+            social.discord = uriMetadata.discord || uriMetadata.extensions?.discord;
+        }
+
+        // Add any other social fields from extensions
+        if (uriMetadata?.extensions) {
+            Object.keys(uriMetadata.extensions).forEach(key => {
+                if (!['twitter', 'telegram', 'discord', 'website'].includes(key) && uriMetadata.extensions![key]) {
+                    social[key] = uriMetadata.extensions![key];
+                }
+            });
+        }
+
         return {
             address: tokenAddress.toString(),
             decimals: mint.decimals,
-            name: metaplexData?.name || "",
-            symbol: metaplexData?.symbol || ""
+            name: uriMetadata?.name || metaplexData?.name || "",
+            symbol: uriMetadata?.symbol || metaplexData?.symbol || "",
+            logoUrl: uriMetadata?.image || "",
+            description: uriMetadata?.description,
+            website: uriMetadata?.website || uriMetadata?.extensions?.website,
+            social: Object.keys(social).length > 0 ? social : undefined
         }
     }
     try {
@@ -309,11 +389,36 @@ export const getTokenInfo = async (tokenAddress: PublicKey, connection: Connecti
 
     }
 
+    // Build social object from metadata
+    const social: TokenInfo['social'] = {};
+    if (uriMetadata?.twitter || uriMetadata?.extensions?.twitter) {
+        social.twitter = uriMetadata.twitter || uriMetadata.extensions?.twitter;
+    }
+    if (uriMetadata?.telegram || uriMetadata?.extensions?.telegram) {
+        social.telegram = uriMetadata.telegram || uriMetadata.extensions?.telegram;
+    }
+    if (uriMetadata?.discord || uriMetadata?.extensions?.discord) {
+        social.discord = uriMetadata.discord || uriMetadata.extensions?.discord;
+    }
+
+    // Add any other social fields from extensions
+    if (uriMetadata?.extensions) {
+        Object.keys(uriMetadata.extensions).forEach(key => {
+            if (!['twitter', 'telegram', 'discord', 'website'].includes(key) && uriMetadata.extensions![key]) {
+                social[key] = uriMetadata.extensions![key];
+            }
+        });
+    }
+
     return {
         address: tokenAddress.toString(),
         decimals: mint.decimals,
-        name: metaplexData?.name || "",
-        symbol: metaplexData?.symbol || ""
+        name: uriMetadata?.name || metaplexData?.name || "",
+        symbol: uriMetadata?.symbol || metaplexData?.symbol || "",
+        logoUrl: uriMetadata?.image || "",
+        description: uriMetadata?.description,
+        website: uriMetadata?.website || uriMetadata?.extensions?.website,
+        social: Object.keys(social).length > 0 ? social : undefined
     }
 }
 
@@ -430,13 +535,16 @@ export const discoverTokens = async (ownerAddress: PublicKey, connection: Connec
 
         const mintAddress = accountInfo.account.data["parsed"]["info"]["mint"]
         const mint = await getTokenInfo(new PublicKey(mintAddress), connection)
+        // console.log('mint: ', mint);
         return {
             owner: accountInfo.account.data["parsed"]["info"]["owner"],
             address: accountInfo.account.data["parsed"]["info"]["mint"],
             decimals: accountInfo.account.data["parsed"]["info"]["tokenAmount"]["decimals"],
             symbol: mint.symbol,
             name: mint.name,
-            balance: accountInfo.account.data["parsed"]["info"]["tokenAmount"]["amount"]
+            balance: accountInfo.account.data["parsed"]["info"]["tokenAmount"]["amount"],
+            logoUrl: mint.logoUrl
+
         }
     }))
 
@@ -760,3 +868,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,12 +8,15 @@ 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 { getTokenInfo } from "./svm/utils";
+import { discoverTokens, fetchWalletNfts, getTokenInfo } from "./svm/utils";
+import { JsonRpcProvider } from "ethers";
+
+import { } from "@solana/spl-token-metadata"
 // const mnemonic = GenerateNewMnemonic()
 
 
@@ -22,8 +25,8 @@ import { getTokenInfo } from "./svm/utils";
 // const seed = VM.mnemonicToSeed(mnemonic)
 const pKey = "4QxETeX9pndiF1XNghUiDTnZnHq3cfjmuPLBJysrgocsLq1yb8w96aPWALa8ZnRZWmDU4wM8Tg8d1ZRVVByj7uXE"
 
-export const testUserKeyPair = Keypair.fromSecretKey(base58.decode(pKey));
-const x = testUserKeyPair instanceof Keypair;
+const testUserKeyPair = Keypair.fromSecretKey(base58.decode(pKey));
+// const x = testUserKeyPair instanceof Keypair;
 const evePrivateKey = "0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318"
 const evmPrivateKey2 = "0x0123456789012345678901234567890123456789012345678901234567890123"
 const ogPrivKey = "d2d3f7117aa9a4c6e5d4affedd8a5ea624ffd82b2a1de81509e5913709b1ea72"
@@ -39,7 +42,7 @@ const ogPrivKey = "d2d3f7117aa9a4c6e5d4affedd8a5ea624ffd82b2a1de81509e5913709b1e
 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,
@@ -49,7 +52,7 @@ 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,
@@ -93,6 +96,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.
@@ -125,4 +132,26 @@ const connection = new Connection(RPC_URL);
 //     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);
+// });
+
+// discoverTokens(new PublicKey("8AXoqNjEVyhhe43ckDEsYiphWxTBH2oWXkKLZAbCNWLL"), connection).then(tokens => {
+//     console.log("Discovered Tokens:", tokens);
+// }).catch(error => {
+//     console.error("Error discovering Tokens:", error);
+// });
+
 
+// //IIFE
+// (async () => {
+//     //GET TOKEN LOGO using @solana/spl-token-metadata
+// })();

package/utils/types.ts

@@ -24,6 +24,15 @@ export interface TokenInfo {
     name: string;
     symbol: string;
     decimals: number;
+    logoUrl?: string;
+    description?: string;
+    website?: string;
+    social?: {
+        twitter?: string;
+        discord?: string;
+        telegram?: string;
+        [key: string]: string | undefined;
+    };
 }
 
 export interface UserTokenBalance<AddressType> extends TokenInfo {
@@ -39,6 +48,146 @@ export interface NFTInfo {
     image?: string;
 }
 
+// Unified NFT interface for both EVM and SVM chains
+export interface NFT {
+    // Unique identifier
+    id: string; // For Solana: mint address, For EVM: contractAddress:tokenId
+
+    // Basic metadata
+    name: string;
+    symbol?: string;
+    description: string;
+    image?: string;
+    uri: string; // Metadata URI
+
+    // Collection/Contract info
+    collection: {
+        address: string;
+        name: string;
+        verified?: boolean;
+    };
+
+    // Chain-specific data
+    chainType: 'SVM' | 'EVM';
+
+    // Ownership
+    balance?: string; // Quantity owned (useful for ERC1155)
+
+    // Optional metadata
+    attributes?: Array<{
+        trait_type: string;
+        value: string | number;
+        display_type?: string;
+    }>;
+
+    // Creators/Royalties (mainly for Solana)
+    creators?: Array<{
+        address: string;
+        verified: boolean;
+        share: number;
+    }>;
+
+    // Additional metadata
+    sellerFeeBasisPoints?: number; // Royalty percentage
+    tokenStandard?: string; // e.g., "ERC721", "ERC1155", "NonFungible", etc.
+
+    // Spam detection (mainly for EVM)
+    isSpam?: boolean;
+
+    // Raw chain-specific data for advanced use cases
+    raw?: {
+        svm?: SolanaNFT;
+        evm?: EVMNFT;
+    };
+}
+
+export interface SolanaNFT {
+    mint: string;
+    name: string;
+    symbol: string;
+    uri: string;
+    updateAuthority: string;
+    sellerFeeBasisPoints: number;
+    creators?: Array<{
+        address: string;
+        verified: boolean;
+        share: number;
+    }>;
+}
+
+export interface EVMNFTContract {
+    address: string;
+    name: string;
+    symbol: string;
+    totalSupply: string;
+    tokenType: string;
+    contractDeployer: string;
+    deployedBlockNumber: number;
+    isSpam: boolean;
+    spamClassifications?: string[];
+}
+
+export interface EVMNFTOpenSeaMetadata {
+    collectionName: string;
+    collectionSlug: string;
+    floorPrice?: number;
+    safelistRequestStatus: string;
+    imageUrl?: string;
+    lastIngestedAt: string;
+}
+
+export interface EVMNFTImage {
+    cachedUrl?: string;
+    thumbnailUrl?: string;
+    pngUrl?: string;
+    contentType?: string;
+    size?: number;
+    originalUrl?: string;
+}
+
+export interface EVMNFTAttribute {
+    trait_type: string;
+    value: string | number;
+    display_type?: string;
+}
+
+export interface EVMNFTRawMetadata {
+    tokenUri?: string;
+    metadata?: {
+        name?: string;
+        description?: string;
+        image?: string;
+        attributes?: EVMNFTAttribute[];
+        [key: string]: any;
+    };
+}
+
+export interface EVMNFTMint {
+    mintAddress?: string;
+    blockNumber?: number;
+    timestamp?: string;
+    transactionHash?: string;
+}
+
+export interface EVMNFT {
+    contract: EVMNFTContract;
+    openSeaMetadata?: EVMNFTOpenSeaMetadata;
+    tokenId: string;
+    tokenType: string;
+    name: string;
+    description: string;
+    balance: string;
+    image?: EVMNFTImage;
+    raw?: EVMNFTRawMetadata;
+    mint?: EVMNFTMint;
+    timeLastUpdated: string;
+    acquiredAt?: string;
+}
+
+export interface EVMNFTResponse {
+    data: EVMNFT[];
+}
+
 export interface TransactionResult {
     hash: string;
     success: boolean;