@deserialize/multi-vm-wallet 1.2.31 → 1.2.43

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, NFTCollection } 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,153 @@ 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;
+    }
+};
+
+/**
+ * Get NFT collection details for a specific collection on Solana
+ * @param walletAddress - User's wallet public key
+ * @param collectionAddress - The NFT collection address (can be collection mint or update authority)
+ * @param connection - Solana connection
+ * @returns NFTCollection object with collection details and user's NFTs in that collection
+ *
+ * Note: On Solana, collections can be identified by:
+ * - Collection mint address (from collection field in NFT metadata)
+ * - Update authority (who can modify the NFT metadata)
+ * This function filters by the collection.address field which is typically the collection mint
+ */
+export const getNFTCollection = async (
+    walletAddress: PublicKey,
+    collectionAddress: string,
+    connection: Connection
+): Promise<NFTCollection | null> => {
+    console.log('getNFTCollection: Starting collection fetch');
+    console.log('Wallet address:', walletAddress.toString());
+    console.log('Collection Address:', collectionAddress);
+
+    try {
+        // Fetch all NFTs for the user
+        const allNfts = await fetchWalletNfts(walletAddress, connection);
+
+        console.log('getNFTCollection: Fetched', allNfts.length, 'total NFTs');
+
+        // Filter NFTs by collection address (case-insensitive comparison)
+        // On Solana, we match against the collection.address which is set from the mint
+        const collectionNfts = allNfts.filter(
+            nft => nft.collection.address.toLowerCase() === collectionAddress.toLowerCase()
+        );
+
+        console.log('getNFTCollection: Found', collectionNfts.length, 'NFTs in collection');
+
+        if (collectionNfts.length === 0) {
+            console.log('getNFTCollection: No NFTs found in this collection');
+            return null;
+        }
+
+        // Extract collection metadata from the first NFT
+        const firstNft = collectionNfts[0];
+        const rawSvmNft = firstNft.raw?.svm;
+
+        // Aggregate creators from all NFTs (they should be the same for a collection)
+        const creators = firstNft.creators;
+
+        const collection: NFTCollection = {
+            address: collectionAddress,
+            name: firstNft.collection.name,
+            symbol: firstNft.symbol,
+            description: undefined, // Could be fetched from URI metadata if needed
+            image: undefined, // Solana collections don't have a single image
+            verified: firstNft.collection.verified,
+            chainType: 'SVM',
+            nfts: collectionNfts,
+            totalOwned: collectionNfts.length,
+            collectionMetadata: rawSvmNft ? {
+                updateAuthority: rawSvmNft.updateAuthority,
+                sellerFeeBasisPoints: rawSvmNft.sellerFeeBasisPoints,
+                creators: creators,
+            } : undefined,
+        };
+
+        console.log('getNFTCollection: Successfully created collection object');
+        return collection;
+    } catch (error) {
+        console.error('getNFTCollection: Error fetching collection:', error);
+        console.error('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.
@@ -111,18 +118,40 @@ 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);
+// });
+
+// 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,196 @@ 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;
+    };
+}
+
+// NFT Collection interface for both EVM and SVM chains
+export interface NFTCollection {
+    // Collection identifier
+    address: string;
+
+    // Collection metadata
+    name: string;
+    symbol?: string;
+    description?: string;
+    image?: string;
+
+    // Verification status
+    verified?: boolean;
+
+    // Chain-specific data
+    chainType: 'SVM' | 'EVM';
+
+    // NFTs owned by the user in this collection
+    nfts: NFT[];
+
+    // Collection statistics
+    totalOwned: number; // Number of NFTs owned by user in this collection
+
+    // Collection-level metadata (for EVM)
+    contractMetadata?: {
+        tokenType?: string; // ERC721, ERC1155, etc.
+        totalSupply?: string;
+        contractDeployer?: string;
+        deployedBlockNumber?: number;
+    };
+
+    // Collection-level metadata (for SVM)
+    collectionMetadata?: {
+        updateAuthority?: string;
+        sellerFeeBasisPoints?: number;
+        creators?: Array<{
+            address: string;
+            verified: boolean;
+            share: number;
+        }>;
+    };
+
+    // OpenSea metadata (for EVM)
+    openSeaMetadata?: {
+        collectionSlug?: string;
+        floorPrice?: number;
+        safelistRequestStatus?: string;
+    };
+}
+
+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;