Add pnl

Author: monilpat

packages/client-coinbase/src/index.ts

@@ -95,7 +95,7 @@ export class CoinbaseClient implements Client {
         });
     }
 
-    private async generateTweetContent(event: WebhookEvent, amountInCurrency: number, formattedTimestamp: string, state: State): Promise<string> {
+    private async generateTweetContent(event: WebhookEvent, amountInCurrency: number, pnlText: string, formattedTimestamp: string, state: State): Promise<string> {
         try {
             const tradeTweetTemplate = `
 # Task
@@ -105,6 +105,7 @@ Trade details:
 - ${event.event.toUpperCase()} order for ${event.ticker}
 - Trading amount: $${amountInCurrency.toFixed(2)}
 - Current price: $${Number(event.price).toFixed(2)}
+- Overall Unrealized PNL: $${pnlText}
 - Time: ${formattedTimestamp}
 
 Requirements:
@@ -117,12 +118,12 @@ Requirements:
 7. Include the key information: action, amount, ticker, and price
 
 Example variations for buys:
-"📈 Just added $1,000 of BTC to the portfolio at $50,000.00"
-"🎯 Strategic BTC purchase: $1,000 at $50,000.00"
+"📈 Just added $1,000 of BTC to the portfolio at $50,000.00. Overall Unrealized PNL: $${pnlText}"
+"🎯 Strategic BTC purchase: $1,000 at $50,000.00. Overall Unrealized PNL: $${pnlText}"
 
 Example variations for sells:
-"💫 Executed BTC position: Sold $1,000 at $52,000.00"
-"📊 Strategic exit: Released $1,000 of BTC at $52,000.00"
+"💫 Executed BTC position: Sold $1,000 at $52,000.00. Overall Unrealized PNL: $${pnlText}"
+"📊 Strategic exit: Released $1,000 of BTC at $52,000.00. Overall Unrealized PNL: $${pnlText}"
 
 Generate only the tweet text, no commentary or markdown.`;
             const context = composeContext({
@@ -133,7 +134,7 @@ Generate only the tweet text, no commentary or markdown.`;
             const tweetContent = await generateText({
                 runtime: this.runtime,
                 context,
-                modelClass: ModelClass.SMALL,
+                modelClass: ModelClass.LARGE,
             });
 
             const trimmedContent = tweetContent.trim();
@@ -189,10 +190,10 @@ Generate only the tweet text, no commentary or markdown.`;
 
         const pnl = await pnlProvider.get(this.runtime, memory);
 
-        const pnlText = pnl ? `Realized PNL: ${JSON.stringify(pnl.realizedPnl)}, Unrealized PNL: ${JSON.stringify(pnl.unrealizedPnl)}` : "";
+        const pnlText = `Unrealized PNL: $${pnl.toFixed(2)}`;
 
         try {
-            const tweetContent = await this.generateTweetContent(event, amount, formattedTimestamp, state);
+            const tweetContent = await this.generateTweetContent(event, amount, pnlText, formattedTimestamp, state);
             elizaLogger.info("Generated tweet content:", tweetContent);
             const response = await postTweet(tweetContent);
             elizaLogger.info("Tweet response:", response);

packages/plugin-coinbase/src/plugins/advancedTrade.ts

@@ -105,6 +105,40 @@ const tradeProvider: Provider = {
     },
 };
 
+async function calculatePnl(client: RESTClient, amount: number): Promise<number> {
+    const accounts = JSON.parse(await client.listAccounts({})).accounts;
+    elizaLogger.info("Accounts:", accounts);
+
+    const btcAccount = accounts.find(account => account.currency === "BTC");
+    elizaLogger.info("BTC Account:", btcAccount);
+    const btcBalance = parseFloat(btcAccount?.available_balance?.value);
+    elizaLogger.info("BTC Balance:", btcBalance);
+
+    const ethAccount = accounts.find(account => account.currency === "ETH");
+    elizaLogger.info("ETH Account:", ethAccount);
+    const ethBalance = parseFloat(ethAccount?.available_balance?.value);
+    elizaLogger.info("ETH Balance:", ethBalance);
+
+    const usdAccount = accounts.find(account => account.currency === "USD");
+    elizaLogger.info("USD Account:", usdAccount);
+    const usdBalance = parseFloat(usdAccount?.available_balance?.value);
+    elizaLogger.info("USD Balance:", usdBalance);
+
+    const btcPrice = await getPrice(client, "BTC-USD");
+    elizaLogger.info("BTC Price:", btcPrice);
+    const ethPrice = await getPrice(client, "ETH-USD");
+    elizaLogger.info("ETH Price:", ethPrice);
+
+    const btcUSD = btcBalance * btcPrice;
+    elizaLogger.info("BTC USD:", btcUSD);
+    const ethUSD = ethBalance * ethPrice;
+    const totalValueUSD = btcUSD + ethUSD + usdBalance;
+    elizaLogger.info("Total Value USD:", totalValueUSD);
+
+    const pnl = totalValueUSD - amount;
+    return pnl;
+}
+
 export const pnlProvider: Provider = {
     get: async (runtime: IAgentRuntime, _message: Memory) => {
         const client = new RESTClient(
@@ -115,36 +149,14 @@ export const pnlProvider: Provider = {
         elizaLogger.info("Portfolios:", portfolios);
         const portfolioId = portfolios.portfolios[0].uuid;
         elizaLogger.info("Portfolio ID:", portfolioId);
-        return { realizedPnl: 0, unrealizedPnl: 0 };
         if (!portfolioId) {
             elizaLogger.error("Portfolio ID is not set");
             return { realizedPnl: 0, unrealizedPnl: 0 };
         }
-
-        let btcPosition: Position, ethPosition: Position;
-        try {
-            btcPosition = JSON.parse(await client.getPortfolioBalances({portfolioUuid: portfolioId, symbol: "BTC-USD"})).position;
-            ethPosition = JSON.parse(await client.getPortfolioBalances({portfolioUuid: portfolioId, symbol: "ETH-USD"})).position;
-            elizaLogger.info("BTC Position:", btcPosition);
-            elizaLogger.info("ETH Position:", ethPosition);
-        } catch (error) {
-            elizaLogger.error("Error fetching portfolio balances:", error.message);
-            return { realizedPnl: 0, unrealizedPnl: 0 };
-        }
-
-        const btcUnrealizedPnl = btcPosition?.unrealized_pnl || 0;
-        const ethUnrealizedPnl = ethPosition?.unrealized_pnl || 0;
-        const ethAggregatedPnl = ethPosition?.aggregated_pnl || 0;
-        const btcAggregatedPnl = btcPosition?.aggregated_pnl || 0;
-        elizaLogger.info("BTC Unrealized PNL:", JSON.stringify(btcUnrealizedPnl));
-        elizaLogger.info("ETH Unrealized PNL:", JSON.stringify(ethUnrealizedPnl));
-        elizaLogger.info("ETH Aggregated PNL:", JSON.stringify(ethAggregatedPnl));
-        return {
-            btcUnrealizedPnl: JSON.stringify(btcUnrealizedPnl),
-            ethUnrealizedPnl: JSON.stringify(ethUnrealizedPnl),
-            ethAggregatedPnl: JSON.stringify(ethAggregatedPnl),
-            btcAggregatedPnl: JSON.stringify(btcAggregatedPnl)
-        }
+        // Need to manually set the amount and calculate as endpoints not accessible for portfolios
+        const pnl = await calculatePnl(client, 1000);
+        elizaLogger.info("Pnl:", pnl);
+        return pnl
     }
 }