review

Author: humanagent

examples/coinbase-langchain/src/cdp.ts

@@ -2,12 +2,13 @@ import {
   Coinbase,
   TimeoutError,
   Wallet,
+  type Trade,
   type Transfer,
   type WalletData,
 } from "@coinbase/coinbase-sdk";
 import { isAddress } from "viem";
 import { getWalletData, saveWalletData } from "./storage";
-import type { XMTPUser } from "./types";
+import type { AgentWalletData, XMTPUser } from "./types";
 
 const coinbaseApiKeyName = process.env.CDP_API_KEY_NAME;
 let coinbaseApiKeyPrivateKey = process.env.CDP_API_KEY_PRIVATE_KEY;
@@ -74,18 +75,6 @@ function initializeCoinbaseSDK(): boolean {
   }
 }
 
-// Agent wallet data
-export type AgentWalletData = {
-  id: string;
-  wallet: Wallet;
-  data: WalletData;
-  human_address: string;
-  agent_address: string;
-  blockchain?: string;
-  state?: string;
-  inboxId: string;
-};
-
 // Wallet service class based on cointoss implementation
 export class WalletService {
   private walletStorage: WalletStorage;
@@ -285,12 +274,12 @@ export class WalletService {
   }
 
   async transfer(
-    inboxId: string,
-    humanAddress: string,
+    xmtpUser: XMTPUser,
     toAddress: string,
     amount: number,
   ): Promise<Transfer | undefined> {
-    humanAddress = humanAddress.toLowerCase();
+    const humanAddress = xmtpUser.address.toLowerCase();
+    const inboxId = xmtpUser.inboxId;
     toAddress = toAddress.toLowerCase();
 
     console.log("📤 TRANSFER INITIATED");
@@ -390,4 +379,58 @@ export class WalletService {
       throw error;
     }
   }
+
+  async swap(
+    xmtpUser: XMTPUser,
+    fromAssetId: string,
+    toAssetId: string,
+    amount: number,
+  ): Promise<Trade | undefined> {
+    const inboxId = xmtpUser.inboxId;
+    const walletData = await this.getWallet(inboxId);
+    if (!walletData) return undefined;
+    console.log(`Retrieved wallet data for ${inboxId}`);
+
+    console.log(
+      `Initiating swap from ${fromAssetId} to ${toAssetId} for amount: ${amount}`,
+    );
+    const trade = await walletData.wallet.createTrade({
+      amount,
+      fromAssetId,
+      toAssetId,
+    });
+
+    try {
+      await trade.wait();
+    } catch (err) {
+      if (err instanceof TimeoutError) {
+        console.log("Waiting for trade timed out");
+      } else {
+        console.error("Error while waiting for trade to complete: ", err);
+      }
+    }
+
+    return trade;
+  }
+
+  async deleteWallet(xmtpUser: XMTPUser): Promise<boolean> {
+    const inboxId = xmtpUser.inboxId;
+    console.log(`Deleting wallet for key ${inboxId}`);
+    const encryptedKey = `wallet:${inboxId}`;
+
+    // Create an empty wallet object to effectively delete the wallet
+    const emptyWallet: AgentWalletData = {
+      id: encryptedKey,
+      wallet: {} as Wallet,
+      data: {} as WalletData,
+      human_address: this.humanAddress,
+      agent_address: this.inboxId,
+      inboxId: this.inboxId,
+    };
+
+    await this.walletStorage.set(this.inboxId, JSON.stringify(emptyWallet));
+
+    console.log(`Wallet deleted for key ${inboxId}`);
+    return true;
+  }
 }

examples/coinbase-langchain/src/langchain.ts

@@ -59,7 +59,6 @@ function createWalletTools(xmtpUser: XMTPUser) {
 
         const result = await walletService.transfer(
           xmtpUser.inboxId,
-          xmtpUser.address,
           recipientAddress,
           numericAmount,
         );
@@ -101,7 +100,7 @@ export async function initializeAgent(
     // Check if we already have an agent for this user
     if (xmtpUser.inboxId in agentStore) {
       console.log(`Using existing agent for user: ${xmtpUser.inboxId}`);
-      const agentConfig = {
+      const agentConfig: AgentConfig = {
         configurable: { thread_id: xmtpUser.inboxId },
       };
       return { agent: agentStore[xmtpUser.inboxId], config: agentConfig };

examples/coinbase-langchain/src/storage.ts

@@ -1,34 +1,23 @@
 import * as fs from "fs";
 import { createClient, type RedisClientType } from "redis";
 
-// Storage constants
+// Storage constantsf
 export const WALLET_KEY_PREFIX = "wallet_data:";
-export const LOCAL_STORAGE_DIR = ".data/wallet_data";
+export const WALLET_STORAGE_DIR = ".data/wallet_data";
+export const XMTP_STORAGE_DIR = ".data/xmtp";
 export let redisClient: RedisClientType | null = null;
 
-if (!process.env.REDIS_URL) {
-  console.warn(
-    "Warning: REDIS_URL not set, using local file storage for wallet data",
-  );
-}
 /**
  * Initialize Redis client and handle fallback to local storage
  */
 export async function initializeStorage() {
   if (process.env.REDIS_URL) {
-    try {
-      redisClient = createClient({
-        url: process.env.REDIS_URL,
-      });
+    redisClient = createClient({
+      url: process.env.REDIS_URL,
+    });
 
-      await redisClient.connect();
-      console.log("Connected to Redis");
-    } catch (error: unknown) {
-      console.error("Failed to connect to Redis:", error);
-      console.log("Falling back to local file storage");
-      redisClient = null;
-      ensureLocalStorage();
-    }
+    await redisClient.connect();
+    console.log("Connected to Redis");
   } else {
     console.log("Using local file storage for wallet data");
     ensureLocalStorage();
@@ -39,8 +28,8 @@ export async function initializeStorage() {
  * Ensure local storage directory exists
  */
 export function ensureLocalStorage() {
-  if (!fs.existsSync(LOCAL_STORAGE_DIR)) {
-    fs.mkdirSync(LOCAL_STORAGE_DIR, { recursive: true });
+  if (!fs.existsSync(WALLET_STORAGE_DIR)) {
+    fs.mkdirSync(WALLET_STORAGE_DIR, { recursive: true });
   }
 }
 
@@ -59,7 +48,7 @@ export async function saveWalletData(
   } else {
     // Save to local file
     try {
-      fs.writeFileSync(LOCAL_STORAGE_DIR + "/" + key + ".json", walletData);
+      fs.writeFileSync(WALLET_STORAGE_DIR + "/" + key + ".json", walletData);
     } catch (error: unknown) {
       const errorMessage =
         error instanceof Error ? error.message : String(error);
@@ -81,11 +70,8 @@ export async function getWalletData(
     return await redisClient.get(userKey);
   } else {
     try {
-      if (fs.existsSync(LOCAL_STORAGE_DIR + "/" + userKey + ".json")) {
-        return fs.readFileSync(
-          LOCAL_STORAGE_DIR + "/" + userKey + ".json",
-          "utf8",
-        );
+      if (fs.existsSync(WALLET_STORAGE_DIR + "/" + userKey)) {
+        return fs.readFileSync(WALLET_STORAGE_DIR + "/" + userKey, "utf8");
       }
     } catch (error: unknown) {
       const errorMessage =

examples/coinbase-langchain/src/types.ts

@@ -1,3 +1,4 @@
+import type { Wallet, WalletData } from "@coinbase/coinbase-sdk";
 import type { MemorySaver } from "@langchain/langgraph";
 import type { createReactAgent } from "@langchain/langgraph/prebuilt";
 
@@ -13,6 +14,17 @@ export interface AgentConfig {
     thread_id: string;
   };
 }
+// Agent wallet data
+export type AgentWalletData = {
+  id: string;
+  wallet: Wallet;
+  data: WalletData;
+  human_address: string;
+  agent_address: string;
+  blockchain?: string;
+  state?: string;
+  inboxId: string;
+};
 
 export type Agent = ReturnType<typeof createReactAgent>;
 

examples/coinbase-langchain/src/xmtp.ts

@@ -5,6 +5,7 @@ import {
   type XmtpEnv,
 } from "@xmtp/node-sdk";
 import { createSigner, getEncryptionKeyFromHex } from "@/helpers";
+import { XMTP_STORAGE_DIR } from "./storage";
 
 /**
  * Initialize the XMTP client
@@ -21,18 +22,20 @@ export async function initializeXmtpClient() {
   const signer = createSigner(WALLET_KEY as `0x${string}`);
   const encryptionKey = getEncryptionKeyFromHex(ENCRYPTION_KEY);
 
+  const identifier = await signer.getIdentifier();
+  const address = identifier.identifier;
   // Set the environment to dev or production
   const env: XmtpEnv = XMTP_ENV as XmtpEnv;
 
   console.log(`Creating XMTP client on the '${env}' network...`);
-  const client = await Client.create(signer, encryptionKey, { env });
+  const client = await Client.create(signer, encryptionKey, {
+    env,
+    dbPath: XMTP_STORAGE_DIR + `/${env}-${address}`,
+  });
 
   console.log("Syncing conversations...");
   await client.conversations.sync();
 
-  const identifier = await signer.getIdentifier();
-  const address = identifier.identifier;
-
   console.log(
     `Agent initialized on ${address}\nSend a message on http://xmtp.chat/dm/${address}?env=${env}`,
   );