fix lint issues, export b2 plugin

packages/plugin-b2/src/actions/stake.ts

@@ -10,8 +10,8 @@ import {
     composeContext,
     ModelClass,
 } from "@elizaos/core";
-import { getTxReceipt, sendNativeAsset, sendToken, depositBTC } from "../utils";
-import { Address, Hash } from "viem";
+import { getTxReceipt, depositBTC } from "../utils";
+import { Hash } from "viem";
 import { validateB2NetworkConfig } from "../environment";
 import { stakeTemplate } from "../templates";
 import { WalletProvider } from "../providers";

packages/plugin-b2/src/index.ts

@@ -5,7 +5,7 @@ import { unstakeAction } from "./actions/unstake";
 import { withdrawAction } from "./actions/withdraw";
 import { walletProvider } from "./providers";
 
-const b2Plugin: Plugin = {
+export const b2Plugin: Plugin = {
     name: "b2",
     description: "B2 Network Plugin for Eliza",
     actions: [transferAction, stakeAction, unstakeAction, withdrawAction],

packages/plugin-b2/src/tests/stake.test.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import { generatePrivateKey } from "viem/accounts";
-import { getEnvVariable } from "@elizaos/core";
 
 import { StakeAction } from "../actions/stake";
 import { WalletProvider } from "../providers";

packages/plugin-b2/src/tests/unstake.test.ts

@@ -1,10 +1,9 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import { generatePrivateKey } from "viem/accounts";
-import { getEnvVariable } from "@elizaos/core";
 
 import { UnstakeAction } from "../actions/unstake";
 import { WalletProvider } from "../providers";
-import { TransferParams, UnstakeParams } from "../types";
+import { UnstakeParams } from "../types";
 
 describe("Unstake Action", () => {
     let wp: WalletProvider;

packages/plugin-b2/src/tests/wallet.test.ts

@@ -1,16 +1,15 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { initWalletProvider, WalletProvider } from "../providers";
-import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
-import { Memory, State } from "@elizaos/core";
+import { generatePrivateKey } from "viem/accounts";
 
 describe("B2 Network Wallet Provider", () => {
-    let walletProvider: WalletProvider;
+    //let walletProvider: WalletProvider;
     let mockRuntime;
 
     beforeEach(() => {
         vi.clearAllMocks();
         const pk = generatePrivateKey();
-        walletProvider = new WalletProvider(pk);
+        //walletProvider = new WalletProvider(pk);
         mockRuntime = {
             getSetting: vi.fn(),
         };

packages/plugin-b2/src/types/index.ts

@@ -1,4 +1,4 @@
-import type { Token } from "@lifi/types";
+//import type { Token } from "@lifi/types";
 import type {
     Address,
     Hash,
@@ -26,5 +26,5 @@ export interface UnstakeParams {
     amount: string | number;
 }
 
-export interface WithdrawParams {
-}
+//export interface WithdrawParams {
+//}

packages/plugin-b2/src/utils/index.ts

@@ -1,10 +1,9 @@
-import { IAgentRuntime, elizaLogger } from "@elizaos/core";
+import {  elizaLogger } from "@elizaos/core";
 import {
     Hash,
     Address,
     parseUnits,
     encodeFunctionData,
-    SendTransactionParameters,
 } from "viem";
 import { b2Network } from "./chains";
 import { WalletProvider } from "../providers";

packages/plugin-squid-router/src/helpers/utils.ts

@@ -1,8 +1,8 @@
 import { IAgentRuntime } from "@elizaos/core";
 import { z } from 'zod';
 import { ethers } from 'ethers';
-import { bech32 } from 'bech32';
-import bs58 from 'bs58';
+//import { bech32 } from 'bech32';
+//import bs58 from 'bs58';
 import {SquidToken, XChainSwapContent} from "../types";
 
 export function convertToWei(amount: string | number, token: SquidToken): string {
@@ -55,6 +55,7 @@ const isValidEvmPrivateKey = (key: string): boolean => {
     return /^[0-9a-fA-F]{64}$/.test(cleanedKey);
 };
 
+/*
 const isValidSolanaAddress = (address: string): boolean => {
     try {
         const decoded = bs58.decode(address);
@@ -80,6 +81,7 @@ const isValidCosmosAddress = (address: string): boolean => {
 const isValidCosmosPrivateKey = (key: string): boolean => {
     return /^[0-9a-fA-F]{64}$/.test(key);
 };
+*/
 
 export const squidRouterEnvSchema = z
     .object({

packages/plugin-squid-router/src/providers/squidRouter.ts

@@ -109,7 +109,7 @@ const squidRouterProvider: Provider = {
         _state?: State
     ): Promise<string | null> => {
         try {
-            const provider = initSquidRouterProvider(runtime);
+            /* const provider = */ initSquidRouterProvider(runtime);
             return "Squid Router provider setup successful."
         } catch (error) {
             console.error("Error in Squid Router provider:", error);

packages/plugin-whatsapp/__tests__/handlers/message.handler.test.ts

@@ -4,31 +4,31 @@ import { WhatsAppClient } from '../../src/client';
 import { WhatsAppMessage } from '../../src/types';
 
 describe('MessageHandler', () => {
-    let messageHandler: MessageHandler;
-    let mockClient: WhatsAppClient;
+    let messageHandler;
+    let mockClient;
 
     beforeEach(() => {
         mockClient = {
             sendMessage: vi.fn(),
-        } as any as WhatsAppClient;
+        };
 
         messageHandler = new MessageHandler(mockClient);
     });
 
     it('should successfully send a message', async () => {
-        const mockMessage: WhatsAppMessage = {
+        const mockMessage  = {
             type: 'text',
             to: '1234567890',
             content: 'Test message'
         };
 
-        const mockResponse = { 
+        const mockResponse = {
             messaging_product: 'whatsapp',
             contacts: [{ input: '1234567890', wa_id: 'WHATSAPP_ID' }],
             messages: [{ id: 'MESSAGE_ID' }]
         };
 
-        (mockClient.sendMessage as any).mockResolvedValue({ data: mockResponse });
+        mockClient.sendMessage.mockResolvedValue({ data: mockResponse });
 
         const result = await messageHandler.send(mockMessage);
 
@@ -37,28 +37,28 @@ describe('MessageHandler', () => {
     });
 
     it('should handle client errors with error message', async () => {
-        const mockMessage: WhatsAppMessage = {
+        const mockMessage = {
             type: 'text',
             to: '1234567890',
             content: 'Test message'
         };
 
         const errorMessage = 'API Error';
-        (mockClient.sendMessage as any).mockRejectedValue(new Error(errorMessage));
+        mockClient.sendMessage.mockRejectedValue(new Error(errorMessage));
 
         await expect(messageHandler.send(mockMessage))
             .rejects
             .toThrow(`Failed to send WhatsApp message: ${errorMessage}`);
     });
 
     it('should handle unknown errors', async () => {
-        const mockMessage: WhatsAppMessage = {
+        const mockMessage = {
             type: 'text',
             to: '1234567890',
             content: 'Test message'
         };
 
-        (mockClient.sendMessage as any).mockRejectedValue('Unknown error');
+        mockClient.sendMessage.mockRejectedValue('Unknown error');
 
         await expect(messageHandler.send(mockMessage))
             .rejects