feat: Add more storage options to Lens Client

.env.example

@@ -426,6 +426,23 @@ STARKNET_RPC_URL=
 # Lens Network Configuration
 LENS_ADDRESS=
 LENS_PRIVATE_KEY=
+LENS_PROFILE_ID=                # Your Lens Protocol profile ID (format: 0x1234)
+LENS_DRY_RUN=                   # Set to 'true' to simulate posts without actually publishing
+LENS_POLL_INTERVAL=             # Interval in seconds to check for new interactions (default: 60)
+LENS_STORAGE_PROVIDER=          # Storage provider for media: 'arweave', 'pinata', or 'storj'. Default "storj"
+
+# Arweave Storage Configuration
+ARWEAVE_JWK=                    # Arweave wallet JSON Web Key (JWK) for permanent storage
+
+# Storj Decentralized Storage Configuration
+STORJ_API_USERNAME=             # Storj network access grant username
+STORJ_API_PASSWORD=             # Storj network access grant password
+
+# Lens Protocol Configuration
+LENS_PROFILE_ID=                # Your Lens Protocol profile ID (format: 0x1234)
+LENS_DRY_RUN=                   # Set to 'true' to simulate posts without actually publishing
+LENS_POLL_INTERVAL=             # Interval in seconds to check for new interactions (default: 60)
+LENS_STORAGE_PROVIDER=          # Storage provider for media: 'arweave', 'pinata', or 'storj'. Default "storj"
 
 # Form Chain
 FORM_PRIVATE_KEY= # Form character account private key
@@ -595,6 +612,7 @@ STORY_PRIVATE_KEY=  # Story private key
 STORY_API_BASE_URL= # Story API base URL
 STORY_API_KEY=      # Story API key
 PINATA_JWT=         # Pinata JWT for uploading files to IPFS
+PINATA_GATEWAY_URL= # Pinata Gateway URL. Recommended for more consistent indexing with Lens.
 
 # Cosmos
 COSMOS_RECOVERY_PHRASE=  # 12 words recovery phrase (need to be in quotes, because of spaces)

packages/client-lens/package.json

@@ -30,6 +30,7 @@
         "@elizaos/core": "workspace:*",
         "@lens-protocol/client": "2.2.0",
         "@lens-protocol/metadata": "1.2.0",
+        "arweave": "1.15.5",
         "axios": "^1.7.9"
     },
     "devDependencies": {
@@ -40,4 +41,4 @@
     "peerDependencies": {
         "@elizaos/core": "workspace:*"
     }
-}
+}

packages/client-lens/src/actions.ts

@@ -8,26 +8,36 @@ import type {
 import { textOnly } from "@lens-protocol/metadata";
 import { createPublicationMemory } from "./memory";
 import type { AnyPublicationFragment } from "@lens-protocol/client";
-import type StorjProvider from "./providers/StorjProvider";
+import { StorageProvider } from "./providers/StorageProvider";
 
 export async function sendPublication({
     client,
     runtime,
     content,
     roomId,
     commentOn,
-    ipfs,
+    storage,
 }: {
     client: LensClient;
     runtime: IAgentRuntime;
     content: Content;
     roomId: UUID;
     commentOn?: string;
-    ipfs: StorjProvider;
+    storage: StorageProvider;
 }): Promise<{ memory?: Memory; publication?: AnyPublicationFragment }> {
     // TODO: arweave provider for content hosting
     const metadata = textOnly({ content: content.text });
-    const contentURI = await ipfs.pinJson(metadata);
+        let contentURI;
+
+    try {
+        const response = await storage.uploadJson(metadata);
+        contentURI = response.url;
+    } catch (e) {
+        elizaLogger.warn(
+            `Failed to upload metadata with storage provider: ${storage.provider}. Ensure your storage provider is configured correctly.`
+        );
+        throw e;
+    }
 
     const publication = await client.createPublication(
         contentURI,

packages/client-lens/src/index.ts

@@ -1,17 +1,23 @@
-import { type Client, type IAgentRuntime, elizaLogger } from "@elizaos/core";
+import { Client, IAgentRuntime, elizaLogger } from "@elizaos/core";
 import { privateKeyToAccount } from "viem/accounts";
 import { LensClient } from "./client";
 import { LensPostManager } from "./post";
 import { LensInteractionManager } from "./interactions";
-import StorjProvider from "./providers/StorjProvider";
+import {
+    StorageProvider,
+    StorageProviderEnum,
+} from "./providers/StorageProvider";
+import { StorjProvider } from "./providers/StorjProvider";
+import { PinataProvider } from "./providers/PinataProvider";
+import { ArweaveProvider } from "./providers/AreweaveProvider";
 
 export class LensAgentClient implements Client {
     client: LensClient;
     posts: LensPostManager;
     interactions: LensInteractionManager;
 
     private profileId: `0x${string}`;
-    private ipfs: StorjProvider;
+    private storage: StorageProvider;
 
     constructor(public runtime: IAgentRuntime) {
         const cache = new Map<string, any>();
@@ -37,26 +43,61 @@ export class LensAgentClient implements Client {
 
         elizaLogger.info("Lens client initialized.");
 
-        this.ipfs = new StorjProvider(runtime);
+        this.storage = this.getStorageProvider();
 
         this.posts = new LensPostManager(
             this.client,
             this.runtime,
             this.profileId,
             cache,
-            this.ipfs
+            this.storage
         );
 
         this.interactions = new LensInteractionManager(
             this.client,
             this.runtime,
             this.profileId,
             cache,
-            this.ipfs
+            this.storage
         );
     }
 
+    private getStorageProvider(): StorageProvider {
+        const storageProvider = this.runtime.getSetting(
+            "LENS_STORAGE_PROVIDER"
+        );
+
+        const storageProviderMap = {
+            [StorageProviderEnum.PINATA]: PinataProvider,
+            [StorageProviderEnum.STORJ]: StorjProvider,
+            [StorageProviderEnum.ARWEAVE]: ArweaveProvider,
+        };
+
+        let SelectedProvider =
+            storageProviderMap[storageProvider as StorageProviderEnum];
+
+        if (!SelectedProvider) {
+            elizaLogger.info(
+                "No valid storage provider specified, defaulting to Storj"
+            );
+
+            // Replace default provider with Lens Storage Nodes when on mainnet https://dev-preview.lens.xyz/docs/storage/using-storage
+            SelectedProvider = StorjProvider;
+        }
+        const selected = new SelectedProvider(this.runtime);
+
+        elizaLogger.info(
+            `Using ${selected.provider} storage provider in Lens Client`
+        );
+
+        return selected;
+    }
+
     async start() {
+        if (this.storage.initialize) {
+            await this.storage.initialize();
+        }
+
         await Promise.all([this.posts.start(), this.interactions.start()]);
     }
 

packages/client-lens/src/interactions.ts

@@ -23,7 +23,7 @@ import { publicationUuid } from "./utils";
 import { sendPublication } from "./actions";
 import type { AnyPublicationFragment } from "@lens-protocol/client";
 import type { Profile } from "./types";
-import type StorjProvider from "./providers/StorjProvider";
+import { StorageProvider } from "./providers/StorageProvider";
 
 export class LensInteractionManager {
     private timeout: NodeJS.Timeout | undefined;
@@ -32,7 +32,7 @@ export class LensInteractionManager {
         public runtime: IAgentRuntime,
         private profileId: string,
         public cache: Map<string, any>,
-        private ipfs: StorjProvider
+        private storage: StorageProvider
     ) {}
 
     public async start() {
@@ -280,7 +280,7 @@ export class LensInteractionManager {
                     content: content,
                     roomId: memory.roomId,
                     commentOn: publication.id,
-                    ipfs: this.ipfs,
+                    storage: this.storage,
                 });
                 if (!result.publication?.id)
                     throw new Error("publication not sent");

packages/client-lens/src/post.ts

@@ -11,7 +11,7 @@ import { formatTimeline, postTemplate } from "./prompts";
 import { publicationUuid } from "./utils";
 import { createPublicationMemory } from "./memory";
 import { sendPublication } from "./actions";
-import type StorjProvider from "./providers/StorjProvider";
+import { StorageProvider } from "./providers/StorageProvider";
 
 export class LensPostManager {
     private timeout: NodeJS.Timeout | undefined;
@@ -21,7 +21,7 @@ export class LensPostManager {
         public runtime: IAgentRuntime,
         private profileId: string,
         public cache: Map<string, any>,
-        private ipfs: StorjProvider
+        private storage: StorageProvider
     ) {}
 
     public async start() {
@@ -105,7 +105,7 @@ export class LensPostManager {
                     runtime: this.runtime,
                     roomId: generateRoomId,
                     content: { text: content },
-                    ipfs: this.ipfs,
+                    storage: this.storage,
                 });
 
                 if (!publication) throw new Error("failed to send publication");

packages/client-lens/src/providers/AreweaveProvider.ts

@@ -0,0 +1,104 @@
+import { elizaLogger, type IAgentRuntime } from "@elizaos/core";
+import {
+    StorageProvider,
+    StorageProviderEnum,
+    UploadResponse,
+} from "./StorageProvider";
+import Arweave from "arweave";
+import { JWKInterface } from "arweave/node/lib/wallet";
+
+export class ArweaveProvider implements StorageProvider {
+    provider = StorageProviderEnum.ARWEAVE;
+    private arweave: Arweave;
+    private jwk: JWKInterface;
+
+    constructor(runtime: IAgentRuntime) {
+        // Initialize Arweave client
+        this.arweave = Arweave.init({
+            host: "arweave.net",
+            port: 443,
+            protocol: "https",
+        });
+
+        const jwk = runtime.getSetting("ARWEAVE_JWK");
+        if (!jwk) {
+            elizaLogger.warn(
+                "To use Arweave storage service you need to set ARWEAVE_JWK in environment variables."
+            );
+        }
+
+        try {
+            this.jwk = JSON.parse(jwk || "{}") as JWKInterface;
+        } catch (error) {
+            elizaLogger.error("Failed to parse Arweave JWK:", error);
+            throw new Error("Invalid Arweave JWK format");
+        }
+    }
+
+    async uploadFile(file: {
+        buffer: Buffer;
+        originalname: string;
+        mimetype: string;
+    }): Promise<UploadResponse> {
+        // Create transaction
+        const transaction = await this.arweave.createTransaction(
+            {
+                data: file.buffer,
+            },
+            this.jwk
+        );
+
+        // Add tags
+        transaction.addTag("Content-Type", file.mimetype);
+        transaction.addTag("File-Name", file.originalname);
+
+        // Sign the transaction
+        await this.arweave.transactions.sign(transaction, this.jwk);
+
+        // Submit the transaction
+        const response = await this.arweave.transactions.post(transaction);
+
+        if (response.status !== 200) {
+            throw new Error(`Upload failed with status ${response.status}`);
+        }
+
+        return {
+            cid: transaction.id,
+            url: `https://arweave.net/${transaction.id}`,
+        };
+    }
+
+    async uploadJson(
+        json: Record<string, any> | string
+    ): Promise<UploadResponse> {
+        // Convert to string if object
+        const stringifiedData =
+            typeof json === "string" ? json : JSON.stringify(json);
+
+        // Create transaction
+        const transaction = await this.arweave.createTransaction(
+            {
+                data: stringifiedData,
+            },
+            this.jwk
+        );
+
+        // Add tags
+        transaction.addTag("Content-Type", "application/json");
+
+        // Sign the transaction
+        await this.arweave.transactions.sign(transaction, this.jwk);
+
+        // Submit the transaction
+        const response = await this.arweave.transactions.post(transaction);
+
+        if (response.status !== 200) {
+            throw new Error(`Upload failed with status ${response.status}`);
+        }
+
+        return {
+            cid: transaction.id,
+            url: `https://arweave.net/${transaction.id}`,
+        };
+    }
+}