@dainprotocol/service-sdk 2.0.53 → 2.0.54

package/dist/__tests__/crypto-plugin.test.js

@@ -0,0 +1,694 @@
+"use strict";
+// File: src/__tests__/crypto-plugin.test.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const client_auth_1 = require("@/client/client-auth");
+const client_1 = require("@/client/client");
+const ed25519_1 = require("@noble/curves/ed25519");
+const bs58_1 = tslib_1.__importDefault(require("bs58"));
+const nodeService_1 = require("@/service/nodeService");
+const core_1 = require("@/service/core");
+const zod_1 = require("zod");
+const crypto_plugin_1 = require("@/plugins/crypto-plugin");
+const cuid2_1 = require("@paralleldrive/cuid2");
+describe("DAIN Framework CryptoPlugin System", () => {
+    // Generate test keys
+    const servicePrivateKey = ed25519_1.ed25519.utils.randomPrivateKey();
+    const servicePublicKey = ed25519_1.ed25519.getPublicKey(servicePrivateKey);
+    const serviceAddress = bs58_1.default.encode(servicePublicKey);
+    const clientPrivateKey = ed25519_1.ed25519.utils.randomPrivateKey();
+    // Set up client authentication
+    const agentAuth = new client_auth_1.DainClientAuth({
+        privateKeyBase58: bs58_1.default.encode(clientPrivateKey),
+        agentId: "agent-crypto-test",
+        orgId: "org-crypto-test",
+    });
+    // Create a test wallet configuration
+    const testWallets = [
+        { chain: "sol", address: "Sol11111111111111111111111111111111111111111" },
+        { chain: "eth", address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" },
+        { chain: "arb", address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8" }
+    ];
+    // Create separate CryptoPlugin instances for client and service
+    const clientCryptoPlugin = new crypto_plugin_1.CryptoPlugin(testWallets);
+    const serviceCryptoPlugin = new crypto_plugin_1.CryptoPlugin(); // Service doesn't need wallet information
+    // Initialize the connection to the DAIN service with the client crypto plugin
+    const dainConnection = new client_1.DainServiceConnection("http://localhost:4485", agentAuth, {
+        plugins: [clientCryptoPlugin]
+    });
+    // Create a mock Solana transaction (added id field)
+    const mockSolanaTransaction = {
+        encodedTx: "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
+        chain: "sol",
+        signer: "Sol11111111111111111111111111111111111111111",
+        metadata: {
+            description: "Test SOL Transfer",
+            amount: 0.01,
+            recipient: "SolRecipient111111111111111111111111111111111"
+        }
+    };
+    // Create a mock Ethereum transaction (added id field)
+    const mockEthereumTransaction = {
+        encodedTx: "0xf86c0a85046c7cfe0083016dea94d1310c1e0aa1b9d5dfe80aa9ee4a8b0a48d0f2a780a46057361d00000000000000000000000000000000000000000000000000000000000003e880820a95a0f5d4c5201602ddf5110f112a85fb0cf39a85e3a3174cd237b8383670cab7a3b5a048f2be5cc9f0a0b3f22e60f709c649d5a6a4ad3d70ce44ec80b96ffe7843508c",
+        chain: "eth",
+        signer: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        metadata: {
+            description: "Test ETH Transfer",
+            amount: 0.1,
+            recipient: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+            gasLimit: 21000
+        }
+    };
+    // Create a wallet context to test context with plugins
+    const walletContext = {
+        id: "wallet-context",
+        name: "Wallet Information",
+        description: "Provides information about available wallets",
+        getContextData: async (agentInfo, context) => {
+            console.log("[CONTEXT] Getting wallet information with context:", context);
+            // Use the unified helper method to extract wallet information
+            const wallets = serviceCryptoPlugin.getUserWallets(context);
+            console.log(`[CONTEXT] Found ${wallets.length} wallet(s) using helper method`);
+            if (wallets.length > 0) {
+                return {
+                    connectedWallets: wallets.map(wallet => ({
+                        chain: wallet.chain,
+                        address: wallet.address,
+                        shortAddress: wallet.address.substring(0, 6) + '...' + wallet.address.substring(wallet.address.length - 4)
+                    })),
+                    walletsCount: wallets.length,
+                    primaryWallet: wallets[0] || null
+                };
+            }
+            return {
+                connectedWallets: [],
+                walletsCount: 0,
+                primaryWallet: null
+            };
+        }
+    };
+    // Create a balance datasource to test datasource with plugins
+    const walletBalanceDatasource = {
+        id: "wallet-balance",
+        name: "Wallet Balance",
+        description: "Get balance information for connected wallets",
+        type: "json",
+        input: zod_1.z.object({
+            chain: zod_1.z.enum(["sol", "eth", "arb"]).optional()
+        }),
+        getDatasource: async (agentInfo, params, context) => {
+            console.log("[DATASOURCE] Getting wallet balance with context:", context);
+            // Use the unified helper method to extract wallet information
+            const wallets = serviceCryptoPlugin.getUserWallets(context);
+            console.log(`[DATASOURCE] Found ${wallets.length} wallet(s) using helper method`);
+            if (wallets.length > 0) {
+                const targetWallets = params.chain
+                    ? wallets.filter(wallet => wallet.chain === params.chain)
+                    : wallets;
+                // If a specific chain is requested, we can also use the unified helper method to get that specific wallet
+                if (params.chain) {
+                    const specificWallet = serviceCryptoPlugin.getUserWalletForChain(context, params.chain);
+                    console.log(`[DATASOURCE] Wallet for chain ${params.chain}: ${specificWallet}`);
+                }
+                // Generate mock balances for demonstration purposes
+                return {
+                    balances: targetWallets.map(wallet => ({
+                        chain: wallet.chain,
+                        address: wallet.address,
+                        balance: Math.random() * 10,
+                        token: wallet.chain === "sol" ? "SOL" : wallet.chain === "eth" ? "ETH" : "ARB",
+                        usdValue: Math.random() * 1000
+                    })),
+                    totalUsdValue: Math.random() * 5000,
+                    timestamp: Date.now()
+                };
+            }
+            return {
+                balances: [],
+                totalUsdValue: 0,
+                timestamp: Date.now()
+            };
+        }
+    };
+    // Create a test tool that uses wallet information and creates unsigned transactions
+    const cryptoTransferTool = (0, core_1.createTool)({
+        id: "crypto-transfer",
+        name: "Cryptocurrency Transfer Tool",
+        description: "Creates unsigned transactions for cryptocurrency transfers",
+        input: zod_1.z.object({
+            amount: zod_1.z.number().positive(),
+            chain: zod_1.z.enum(["sol", "eth", "arb"]),
+            recipientAddress: zod_1.z.string(),
+            executeSimultaneously: zod_1.z.boolean().optional(),
+            waitForConfirmation: zod_1.z.boolean().optional()
+        }),
+        output: zod_1.z.object({
+            success: zod_1.z.boolean(),
+            message: zod_1.z.string(),
+            signatureRequests: zod_1.z.array(zod_1.z.object({
+                txs: zod_1.z.array(zod_1.z.object({
+                    id: zod_1.z.string(),
+                    encodedTx: zod_1.z.string(),
+                    chain: zod_1.z.enum(["sol", "eth", "arb"]),
+                    signer: zod_1.z.string(),
+                    metadata: zod_1.z.any().optional(),
+                    ui: zod_1.z.any().optional()
+                })),
+                executeSimultaneously: zod_1.z.boolean().optional(),
+                toolsShouldWaitForConfirmation: zod_1.z.boolean().optional(),
+                ui: zod_1.z.any().optional()
+            })).optional()
+        }),
+        handler: async ({ amount, chain, recipientAddress, executeSimultaneously, waitForConfirmation }, agentInfo, context) => {
+            // Use the SERVICE-SIDE plugin unified helper to get the user's wallets
+            const wallets = serviceCryptoPlugin.getUserWallets(context);
+            console.log(`[SERVICE] Available user wallets:`, wallets);
+            // Get the wallet for the specified chain
+            const userWallet = serviceCryptoPlugin.getUserWalletForChain(context, chain);
+            if (!userWallet) {
+                return {
+                    text: `No wallet found for ${chain} chain`,
+                    data: {
+                        success: false,
+                        message: `No ${chain} wallet found for this user. Please connect a ${chain} wallet.`
+                    },
+                    ui: null
+                };
+            }
+            console.log(`[SERVICE] Using ${chain} wallet: ${userWallet} for transfer of ${amount} to ${recipientAddress}`);
+            // Create mock transactions based on the chain
+            let mockTransaction;
+            if (chain === "sol") {
+                mockTransaction = {
+                    ...mockSolanaTransaction,
+                    signer: userWallet,
+                    metadata: {
+                        ...mockSolanaTransaction.metadata,
+                        amount: amount,
+                        recipient: recipientAddress
+                    },
+                    ui: {
+                        type: "transaction",
+                        title: "Solana Transfer",
+                        description: `Transfer ${amount} SOL to ${recipientAddress}`,
+                        icon: "💸",
+                        fields: [
+                            { label: "Amount", value: `${amount} SOL` },
+                            { label: "To", value: recipientAddress, truncate: true },
+                            { label: "Network", value: "Solana", badge: "mainnet" }
+                        ],
+                        theme: "purple"
+                    }
+                };
+            }
+            else if (chain === "eth" || chain === "arb") {
+                mockTransaction = {
+                    ...mockEthereumTransaction,
+                    chain: chain,
+                    signer: userWallet,
+                    metadata: {
+                        ...mockEthereumTransaction.metadata,
+                        amount: amount,
+                        recipient: recipientAddress
+                    },
+                    ui: {
+                        type: "transaction",
+                        title: `${chain === "eth" ? "Ethereum" : "Arbitrum"} Transfer`,
+                        description: `Transfer ${amount} ${chain === "eth" ? "ETH" : "ARB"} to ${recipientAddress}`,
+                        icon: chain === "eth" ? "Ξ" : "🔷",
+                        fields: [
+                            { label: "Amount", value: `${amount} ${chain === "eth" ? "ETH" : "ARB"}` },
+                            { label: "To", value: recipientAddress, truncate: true },
+                            { label: "Network", value: chain === "eth" ? "Ethereum" : "Arbitrum", badge: chain === "eth" ? "mainnet" : "L2" },
+                            { label: "Gas Limit", value: "21000" }
+                        ],
+                        theme: chain === "eth" ? "blue" : "orange"
+                    }
+                };
+            }
+            else {
+                return {
+                    text: `Unsupported chain: ${chain}`,
+                    data: {
+                        success: false,
+                        message: `Chain ${chain} is not supported yet.`
+                    },
+                    ui: null
+                };
+            }
+            // Create a transaction with a unique ID using the service plugin helper
+            const transactionWithId = serviceCryptoPlugin.createTransaction(mockTransaction);
+            // Log the transaction ID for debugging
+            console.log(`[SERVICE] Created transaction with ID: ${transactionWithId.id}`);
+            // Create a signature request using the SERVICE-SIDE plugin helper
+            const signatureRequest = serviceCryptoPlugin.createTransactionRequest([transactionWithId], {
+                executeSimultaneously: executeSimultaneously,
+                toolsShouldWaitForConfirmation: waitForConfirmation,
+                ui: {
+                    type: "transaction-group",
+                    title: "Transaction Approval Required",
+                    description: "Please review and sign the following transaction:",
+                    style: "card",
+                    actions: [
+                        { label: "Sign & Send", action: "approve", variant: "primary" },
+                        { label: "Cancel", action: "reject", variant: "secondary" }
+                    ]
+                }
+            });
+            return {
+                text: `Created unsigned ${chain} transaction for ${amount} to ${recipientAddress}`,
+                data: {
+                    success: true,
+                    message: `Created unsigned ${chain} transaction. Please sign to complete the transfer.`,
+                    signatureRequests: [signatureRequest]
+                },
+                ui: null
+            };
+        },
+    });
+    // Initialize the DAIN service with the SERVICE crypto plugin instance
+    const dainService = (0, nodeService_1.defineDAINService)({
+        metadata: {
+            title: "Crypto Plugin Test Service",
+            description: "A DAIN service for testing the crypto plugin",
+            version: "1.0.0",
+            author: "Test Author",
+            tags: ["crypto", "plugin", "test"],
+        },
+        identity: {
+            publicKey: bs58_1.default.encode(servicePublicKey),
+            agentId: "crypto-agent",
+            orgId: "crypto-org",
+            privateKey: bs58_1.default.encode(servicePrivateKey),
+        },
+        tools: [cryptoTransferTool],
+        plugins: [serviceCryptoPlugin], // Using service-side plugin instance
+        contexts: [walletContext],
+        datasources: [walletBalanceDatasource]
+    });
+    let server;
+    beforeAll(async () => {
+        server = await dainService.startNode({ port: 4485 });
+        await new Promise(resolve => setTimeout(resolve, 500)); // Give server time to start
+    });
+    afterAll(async () => {
+        await server.shutdown();
+    });
+    it("should assign unique IDs to transactions", async () => {
+        console.log("[CLIENT] Using client plugin with wallets:", clientCryptoPlugin.getWallets());
+        console.log("[SERVICE] Using service plugin with wallets:", serviceCryptoPlugin.getWallets());
+        // Call the tool WITHOUT providing wallet information in the params
+        // The client plugin should automatically add wallet info
+        const params = {
+            amount: 0.05,
+            chain: "sol",
+            recipientAddress: "SolRecipient222222222222222222222222222222222"
+            // No wallets provided - they should come from the client plugin
+        };
+        // Call the tool
+        const result = await dainConnection.callTool("crypto-transfer", params);
+        console.log("[CLIENT] Received response:", JSON.stringify(result, null, 2));
+        // Verify the response
+        expect(result.data.success).toBe(true);
+        expect(result.data.message).toContain("Created unsigned sol transaction");
+        // Use the CLIENT plugin helper to extract transaction requests
+        const signatureRequests = clientCryptoPlugin.getRequestedCryptoSignatures(result);
+        console.log("[CLIENT] Extracted signature requests:", JSON.stringify(signatureRequests, null, 2));
+        expect(signatureRequests).toBeDefined();
+        expect(signatureRequests.length).toBe(1);
+        expect(signatureRequests[0].txs.length).toBe(1);
+        const transaction = signatureRequests[0].txs[0];
+        expect(transaction.chain).toBe("sol");
+        expect(transaction.signer).toBe(testWallets[0].address);
+        expect(transaction.encodedTx).toBeDefined();
+        // Verify the transaction has an ID
+        expect(transaction.id).toBeDefined();
+        expect(typeof transaction.id).toBe("string");
+        expect(transaction.id.length).toBeGreaterThan(10);
+        // Save the transaction ID for later use
+        const txId = transaction.id;
+        console.log(`[CLIENT] Transaction ID: ${txId}`);
+        // Test getTransactionById method
+        const foundTx = clientCryptoPlugin.getTransactionById(result, txId);
+        expect(foundTx).toBeDefined();
+        expect(foundTx?.id).toBe(txId);
+    });
+    it("should handle Ethereum transactions with unique IDs", async () => {
+        // Prepare the tool parameters without wallet information
+        const params = {
+            amount: 0.25,
+            chain: "eth",
+            recipientAddress: "0xRecipientEthereumAddress0123456789abcdef"
+            // No wallets provided - they should come from the client plugin
+        };
+        // Call the tool
+        const result = await dainConnection.callTool("crypto-transfer", params);
+        // Verify the response
+        expect(result.data.success).toBe(true);
+        expect(result.data.message).toContain("Created unsigned eth transaction");
+        // Get transaction requests using the CLIENT plugin
+        const signatureRequests = clientCryptoPlugin.getRequestedCryptoSignatures(result);
+        const transaction = signatureRequests[0].txs[0];
+        expect(transaction.chain).toBe("eth");
+        expect(transaction.signer).toBe(testWallets[1].address);
+        expect(transaction.metadata?.amount).toBe(0.25);
+        expect(transaction.metadata?.recipient).toBe("0xRecipientEthereumAddress0123456789abcdef");
+        // Verify the transaction has an ID
+        expect(transaction.id).toBeDefined();
+        expect(typeof transaction.id).toBe("string");
+        console.log(`[CLIENT] Ethereum transaction ID: ${transaction.id}`);
+    });
+    it("should show wallet information flow and transaction IDs", async () => {
+        // Add a new custom wallet to the client plugin
+        clientCryptoPlugin.addWallet({
+            chain: "sol",
+            address: "CustomSolAddress123456789"
+        });
+        // Call the tool with the updated client plugin
+        const result = await dainConnection.callTool("crypto-transfer", {
+            amount: 0.75,
+            chain: "sol",
+            recipientAddress: "NewRecipientAddress"
+        });
+        // Verify the result uses the updated wallet
+        const signatureRequests = clientCryptoPlugin.getRequestedCryptoSignatures(result);
+        const transaction = signatureRequests[0].txs[0];
+        // The address should be the new custom one we just added
+        expect(transaction.signer).toBe("CustomSolAddress123456789");
+        expect(transaction.metadata?.amount).toBe(0.75);
+        // Verify the transaction has an ID
+        expect(transaction.id).toBeDefined();
+        console.log(`[CLIENT] Updated wallet transaction ID: ${transaction.id}`);
+    });
+    it("should demonstrate creating and accessing transactions with IDs", async () => {
+        // Create a transaction directly with the createTransaction method
+        const txData = {
+            encodedTx: "0xManuallyCreatedTx",
+            chain: "eth",
+            signer: "0xManualAddress",
+            metadata: { test: true, purpose: "Demo" }
+        };
+        // Create a transaction with the client plugin
+        const tx1 = clientCryptoPlugin.createTransaction(txData);
+        // Create another transaction with the same data
+        const tx2 = clientCryptoPlugin.createTransaction(txData);
+        // Create a transaction with a predefined ID
+        const customId = (0, cuid2_1.createId)();
+        const tx3 = clientCryptoPlugin.createTransaction({
+            ...txData,
+            id: customId
+        });
+        // Verify each transaction has a unique ID
+        expect(tx1.id).toBeDefined();
+        expect(tx2.id).toBeDefined();
+        expect(tx3.id).toBeDefined();
+        // Transaction IDs should be unique
+        expect(tx1.id).not.toBe(tx2.id);
+        // Custom ID should be preserved
+        expect(tx3.id).toBe(customId);
+        console.log(`[TEST] Manual transaction IDs:`, {
+            tx1Id: tx1.id,
+            tx2Id: tx2.id,
+            tx3Id: tx3.id
+        });
+        // Create a signature request with multiple transactions
+        const signatureRequest = clientCryptoPlugin.createTransactionRequest([tx1, tx2, tx3]);
+        // Verify the signature request contains all transactions
+        expect(signatureRequest.txs.length).toBe(3);
+        expect(signatureRequest.txs.map(tx => tx.id)).toContain(tx1.id);
+        expect(signatureRequest.txs.map(tx => tx.id)).toContain(tx2.id);
+        expect(signatureRequest.txs.map(tx => tx.id)).toContain(tx3.id);
+    });
+    it("should demonstrate new transaction option parameters", async () => {
+        // Create transaction data
+        const txData = {
+            encodedTx: "0xTestTransactionForOptions",
+            chain: "eth",
+            signer: "0xTestAddress",
+            metadata: { test: true, purpose: "Testing Options" }
+        };
+        // Create transactions
+        const tx1 = clientCryptoPlugin.createTransaction(txData);
+        const tx2 = clientCryptoPlugin.createTransaction({
+            ...txData,
+            signer: "0xAnotherTestAddress"
+        });
+        // Create a transaction request with options
+        const signatureRequest = clientCryptoPlugin.createTransactionRequest([tx1, tx2], {
+            executeSimultaneously: true,
+            toolsShouldWaitForConfirmation: true
+        });
+        // Verify the request has the correct options
+        expect(signatureRequest.executeSimultaneously).toBe(true);
+        expect(signatureRequest.toolsShouldWaitForConfirmation).toBe(true);
+        expect(signatureRequest.txs.length).toBe(2);
+        // Test calling the tool with options
+        const result = await dainConnection.callTool("crypto-transfer", {
+            amount: 1.5,
+            chain: "eth",
+            recipientAddress: "0xOptionTestRecipientAddress",
+            executeSimultaneously: true,
+            waitForConfirmation: true
+        });
+        // Extract the signature requests
+        const requests = clientCryptoPlugin.getRequestedCryptoSignatures(result);
+        // Verify the options were passed through
+        expect(requests.length).toBe(1);
+        expect(requests[0].executeSimultaneously).toBe(true);
+        expect(requests[0].toolsShouldWaitForConfirmation).toBe(true);
+        // Verify the transaction was created correctly
+        expect(requests[0].txs.length).toBe(1);
+        expect(requests[0].txs[0].chain).toBe("eth");
+        expect(requests[0].txs[0].metadata?.amount).toBe(1.5);
+        expect(requests[0].txs[0].metadata?.recipient).toBe("0xOptionTestRecipientAddress");
+    });
+    it("should preserve UI components in transactions and signature requests", async () => {
+        console.log("[TEST] Testing UI components in crypto transactions");
+        // Call the tool to create a Solana transaction
+        const solResult = await dainConnection.callTool("crypto-transfer", {
+            amount: 2.5,
+            chain: "sol",
+            recipientAddress: "SolUITestRecipient111111111111111111111111111"
+        });
+        // Extract the signature requests
+        const solRequests = clientCryptoPlugin.getRequestedCryptoSignatures(solResult);
+        // Verify the transaction has UI components
+        expect(solRequests[0].txs[0].ui).toBeDefined();
+        expect(solRequests[0].txs[0].ui.type).toBe("transaction");
+        expect(solRequests[0].txs[0].ui.title).toBe("Solana Transfer");
+        expect(solRequests[0].txs[0].ui.icon).toBe("💸");
+        expect(solRequests[0].txs[0].ui.theme).toBe("purple");
+        expect(solRequests[0].txs[0].ui.fields).toBeDefined();
+        expect(solRequests[0].txs[0].ui.fields.length).toBe(3);
+        // Verify the signature request has UI components
+        expect(solRequests[0].ui).toBeDefined();
+        expect(solRequests[0].ui.type).toBe("transaction-group");
+        expect(solRequests[0].ui.title).toBe("Transaction Approval Required");
+        expect(solRequests[0].ui.actions).toBeDefined();
+        expect(solRequests[0].ui.actions.length).toBe(2);
+        console.log("[TEST] Solana transaction UI:", JSON.stringify(solRequests[0].txs[0].ui, null, 2));
+        console.log("[TEST] Signature request UI:", JSON.stringify(solRequests[0].ui, null, 2));
+        // Test Ethereum transaction UI
+        const ethResult = await dainConnection.callTool("crypto-transfer", {
+            amount: 0.1,
+            chain: "eth",
+            recipientAddress: "0xEthUITestRecipient0123456789abcdef"
+        });
+        const ethRequests = clientCryptoPlugin.getRequestedCryptoSignatures(ethResult);
+        // Verify Ethereum transaction UI
+        expect(ethRequests[0].txs[0].ui).toBeDefined();
+        expect(ethRequests[0].txs[0].ui.type).toBe("transaction");
+        expect(ethRequests[0].txs[0].ui.title).toBe("Ethereum Transfer");
+        expect(ethRequests[0].txs[0].ui.icon).toBe("Ξ");
+        expect(ethRequests[0].txs[0].ui.theme).toBe("blue");
+        expect(ethRequests[0].txs[0].ui.fields.length).toBe(4); // ETH has gas limit field
+        // Test Arbitrum transaction UI
+        const arbResult = await dainConnection.callTool("crypto-transfer", {
+            amount: 5.0,
+            chain: "arb",
+            recipientAddress: "0xArbUITestRecipient0123456789abcdef"
+        });
+        const arbRequests = clientCryptoPlugin.getRequestedCryptoSignatures(arbResult);
+        // Verify Arbitrum transaction UI
+        expect(arbRequests[0].txs[0].ui).toBeDefined();
+        expect(arbRequests[0].txs[0].ui.type).toBe("transaction");
+        expect(arbRequests[0].txs[0].ui.title).toBe("Arbitrum Transfer");
+        expect(arbRequests[0].txs[0].ui.icon).toBe("🔷");
+        expect(arbRequests[0].txs[0].ui.theme).toBe("orange");
+        expect(arbRequests[0].txs[0].ui.fields[2].badge).toBe("L2");
+        console.log("[TEST] All UI components preserved successfully");
+    });
+    it("should handle transactions with custom UI components", async () => {
+        // Create a transaction with custom UI using the plugin helper
+        const customUITransaction = clientCryptoPlugin.createTransaction({
+            encodedTx: "0xCustomUITransaction",
+            chain: "eth",
+            signer: "0xCustomUIWallet",
+            metadata: { customField: "Custom Value" },
+            ui: {
+                type: "custom-transaction",
+                title: "Custom Transaction UI",
+                customProperty: "This is a custom UI component",
+                fields: [
+                    { label: "Custom Field", value: "Custom Value" }
+                ]
+            }
+        });
+        // Verify the custom UI is preserved
+        expect(customUITransaction.ui).toBeDefined();
+        expect(customUITransaction.ui.type).toBe("custom-transaction");
+        expect(customUITransaction.ui.customProperty).toBe("This is a custom UI component");
+        // Create a signature request with custom UI
+        const customRequest = clientCryptoPlugin.createTransactionRequest([customUITransaction], {
+            executeSimultaneously: false,
+            toolsShouldWaitForConfirmation: true,
+            ui: {
+                type: "custom-request",
+                title: "Custom Request UI",
+                customStyles: { backgroundColor: "#f0f0f0" }
+            }
+        });
+        // Verify both transaction and request UI are preserved
+        expect(customRequest.txs[0].ui).toBeDefined();
+        expect(customRequest.txs[0].ui.type).toBe("custom-transaction");
+        expect(customRequest.ui).toBeDefined();
+        expect(customRequest.ui.type).toBe("custom-request");
+        expect(customRequest.ui.customStyles).toEqual({ backgroundColor: "#f0f0f0" });
+        console.log("[TEST] Custom UI preserved:", {
+            transactionUI: customUITransaction.ui,
+            requestUI: customRequest.ui
+        });
+    });
+    it("should verify plugins provide wallet data to context handlers on service side", async () => {
+        // Create a mock context for testing
+        const mockContext = {
+            context: {
+                plugins: {
+                    'crypto-plugin': {
+                        wallets: [
+                            { chain: "sol", address: "CustomSolAddress123456789" },
+                            { chain: "eth", address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" }
+                        ]
+                    }
+                }
+            }
+        };
+        // Use the helper method to get wallets
+        const wallets = serviceCryptoPlugin.getUserWallets(mockContext.context);
+        expect(wallets).toBeDefined();
+        expect(wallets.length).toBe(2);
+        // Test the chain-specific helper method
+        const solWallet = serviceCryptoPlugin.getUserWalletForChain(mockContext.context, "sol");
+        expect(solWallet).toBe("CustomSolAddress123456789");
+        const ethWallet = serviceCryptoPlugin.getUserWalletForChain(mockContext.context, "eth");
+        expect(ethWallet).toBe("0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266");
+        // Directly call the context handler function
+        const contextData = await walletContext.getContextData({}, mockContext.context);
+        // Verify wallet information was properly extracted
+        expect(contextData.connectedWallets).toBeDefined();
+        expect(contextData.connectedWallets.length).toBe(2);
+        expect(contextData.walletsCount).toBe(2);
+        // Verify the wallet information matches our test wallets
+        const wallet = contextData.connectedWallets.find(w => w.chain === "sol");
+        expect(wallet).toBeDefined();
+        expect(wallet?.address).toBe("CustomSolAddress123456789");
+    });
+    it("should verify plugins provide wallet data to datasource handlers on service side", async () => {
+        // Create a mock context for testing
+        const mockContext = {
+            plugins: {
+                'crypto-plugin': {
+                    wallets: [
+                        { chain: "sol", address: "CustomSolAddress123456789" },
+                        { chain: "eth", address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" },
+                        { chain: "arb", address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8" }
+                    ]
+                }
+            }
+        };
+        // Use the helper method to get wallets
+        const wallets = serviceCryptoPlugin.getUserWallets({ plugins: mockContext.plugins });
+        expect(wallets).toBeDefined();
+        expect(wallets.length).toBe(3);
+        // Test the chain-specific helper method
+        const solWallet = serviceCryptoPlugin.getUserWalletForChain({ plugins: mockContext.plugins }, "sol");
+        expect(solWallet).toBe("CustomSolAddress123456789");
+        const ethWallet = serviceCryptoPlugin.getUserWalletForChain({ plugins: mockContext.plugins }, "eth");
+        expect(ethWallet).toBe("0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266");
+        const arbWallet = serviceCryptoPlugin.getUserWalletForChain({ plugins: mockContext.plugins }, "arb");
+        expect(arbWallet).toBe("0x70997970C51812dc3A010C7d01b50e0d17dc79C8");
+        // Test with chain filter
+        const ethBalanceData = await walletBalanceDatasource.getDatasource({}, { chain: "eth" }, { plugins: mockContext.plugins });
+        // Verify balance information
+        expect(ethBalanceData.balances).toBeDefined();
+        expect(ethBalanceData.balances.length).toBe(1); // Only ETH wallet
+        expect(ethBalanceData.balances[0].chain).toBe("eth");
+        expect(ethBalanceData.balances[0].token).toBe("ETH");
+        // Test without filter
+        const allBalancesData = await walletBalanceDatasource.getDatasource({}, {}, { plugins: mockContext.plugins });
+        // Verify we get balances for all wallets
+        expect(allBalancesData.balances.length).toBe(3); // SOL, ETH, ARB wallets
+        // Verify the wallet chains
+        const chains = allBalancesData.balances.map(b => b.chain);
+        expect(chains).toContain("sol");
+        expect(chains).toContain("eth");
+        expect(chains).toContain("arb");
+    });
+    it("should allow service plugin to process transactions with additional data", async () => {
+        // Create a new test with a local function that adds metadata
+        // We'll use a real function instead of adding to the plugin instance
+        const addServiceMetadata = (tx) => {
+            return {
+                ...tx,
+                metadata: {
+                    ...tx.metadata,
+                    timestamp: Date.now(),
+                    serviceId: "test-service-id",
+                    enhanced: true
+                }
+            };
+        };
+        // Create a simple tool handler that would use this function
+        // This simulates what a service would do
+        const processTransaction = async (chain, userWallet, options) => {
+            // Create a basic transaction with ID
+            const baseTx = {
+                encodedTx: "0xBasicTransaction",
+                chain: chain,
+                signer: userWallet,
+                metadata: { basic: true }
+            };
+            // Create transaction with ID using the helper
+            const tx = serviceCryptoPlugin.createTransaction(baseTx);
+            // Enhance it with service-side metadata
+            const enhancedTx = addServiceMetadata(tx);
+            // Create the signature request
+            const request = serviceCryptoPlugin.createTransactionRequest([enhancedTx], options);
+            return {
+                success: true,
+                signatureRequests: [request]
+            };
+        };
+        // Simulate processing with options
+        const testWallet = "0xTestWalletAddress";
+        const result = await processTransaction("eth", testWallet, {
+            executeSimultaneously: true,
+            toolsShouldWaitForConfirmation: false
+        });
+        // Verify the metadata was added
+        expect(result.signatureRequests[0].txs[0].metadata?.enhanced).toBe(true);
+        expect(result.signatureRequests[0].txs[0].metadata?.serviceId).toBe("test-service-id");
+        expect(result.signatureRequests[0].txs[0].metadata?.timestamp).toBeDefined();
+        expect(result.signatureRequests[0].txs[0].metadata?.basic).toBe(true); // Original data preserved
+        // Verify the transaction options
+        expect(result.signatureRequests[0].executeSimultaneously).toBe(true);
+        expect(result.signatureRequests[0].toolsShouldWaitForConfirmation).toBe(false);
+        // Make sure the transaction info is correct
+        expect(result.signatureRequests[0].txs[0].chain).toBe("eth");
+        expect(result.signatureRequests[0].txs[0].signer).toBe(testWallet);
+        // Verify the transaction has an ID
+        expect(result.signatureRequests[0].txs[0].id).toBeDefined();
+        console.log(`[TEST] Service processed transaction ID: ${result.signatureRequests[0].txs[0].id}`);
+    });
+});
+//# sourceMappingURL=crypto-plugin.test.js.map