shogun-relay-sdk 1.2.11 → 1.4.0

package/README.md

@@ -0,0 +1,408 @@
+# Shogun Relay SDK
+
+TypeScript/JavaScript SDK for interacting with Shogun Relay API.
+
+## Installation
+
+```bash
+npm install @shogun/relay-sdk
+# or
+yarn add @shogun/relay-sdk
+```
+
+## Quick Start
+
+```typescript
+import ShogunRelaySDK from '@shogun/relay-sdk';
+import { generateWalletSignature } from '@shogun/relay-sdk/utils/wallet';
+import { ethers } from 'ethers';
+
+// Initialize SDK
+const sdk = new ShogunRelaySDK({
+  baseURL: 'https://shogun-relay.scobrudot.dev',
+  token: 'your-admin-token' // Optional: for admin operations
+});
+
+// Or set token later
+sdk.setToken('your-admin-token');
+```
+
+## Authentication
+
+### Admin Authentication
+
+For admin operations, use the admin token:
+
+```typescript
+const sdk = new ShogunRelaySDK({
+  baseURL: 'https://shogun-relay.scobrudot.dev',
+  token: 'your-admin-token'
+});
+
+// Admin upload (no signature required)
+const result = await sdk.ipfs.uploadFile(
+  fileBuffer,
+  'example.txt',
+  'text/plain'
+);
+```
+
+### Wallet Signature Authentication
+
+For user operations, you need to sign a message with your wallet:
+
+```typescript
+import { generateWalletSignature } from '@shogun/relay-sdk/utils/wallet';
+import { ethers } from 'ethers';
+
+// Connect to wallet
+const provider = new ethers.BrowserProvider(window.ethereum);
+const signer = await provider.getSigner();
+const address = await signer.getAddress();
+
+// Generate signature
+const signature = await generateWalletSignature(signer);
+
+// Upload with wallet signature
+const result = await sdk.ipfs.uploadFile(
+  fileBuffer,
+  'example.txt',
+  'text/plain',
+  {
+    userAddress: address,
+    walletSignature: signature,
+    isDealUpload: true // For deal uploads (no subscription required)
+  }
+);
+```
+
+## API Keys
+
+Manage API keys for programmatic access to all relay services:
+
+```typescript
+// List all API keys
+const keys = await sdk.apiKeys.list();
+
+// Create a new API key
+const newKey = await sdk.apiKeys.create('My App Key', 30); // 30 days expiration
+console.log('API Key:', newKey.token); // Save this, it's only shown once!
+
+// Use the API key for authentication
+sdk.apiKeys.useApiKey(newKey.token);
+
+// Or use it directly
+sdk.setToken(newKey.token);
+
+// Revoke an API key
+await sdk.apiKeys.revoke(newKey.keyId);
+```
+
+**Note**: API keys work across all relay services (Drive, IPFS, etc.) and use the prefix `shogun-api-`.
+
+## Drive Operations
+
+The Drive module provides file system operations for the admin drive:
+
+### List Files
+
+```typescript
+// List root directory
+const files = await sdk.drive.list();
+
+// List specific directory
+const files = await sdk.drive.list('folder/subfolder');
+```
+
+### Upload Files
+
+```typescript
+// Upload single file
+const result = await sdk.drive.uploadFile(
+  fileBuffer,
+  'example.txt',
+  'folder' // optional path
+);
+
+// Upload multiple files
+const result = await sdk.drive.uploadFiles([
+  { file: fileBuffer1, filename: 'file1.txt' },
+  { file: fileBuffer2, filename: 'file2.txt' }
+], 'folder');
+```
+
+### Download Files
+
+```typescript
+const fileBuffer = await sdk.drive.download('path/to/file.txt');
+```
+
+### Directory Operations
+
+```typescript
+// Create directory
+await sdk.drive.createDirectory('new-folder', 'parent-folder');
+
+// Rename file/directory
+await sdk.drive.rename('old-name.txt', 'new-name.txt');
+
+// Move file/directory
+await sdk.drive.move('source.txt', 'destination/folder/source.txt');
+
+// Delete file/directory
+await sdk.drive.delete('path/to/item');
+```
+
+### Storage Statistics
+
+```typescript
+const stats = await sdk.drive.getStats();
+console.log(`Total: ${stats.stats.totalSizeMB} MB`);
+console.log(`Files: ${stats.stats.fileCount}`);
+```
+
+### Public Links
+
+```typescript
+// Create a public sharing link
+const link = await sdk.drive.createPublicLink('document.pdf', 7); // 7 days expiration
+console.log('Public URL:', link.publicUrl);
+
+// List all public links
+const links = await sdk.drive.listPublicLinks();
+
+// Revoke a link
+await sdk.drive.revokePublicLink(link.linkId);
+
+// Get public file URL (for direct access)
+const publicUrl = sdk.drive.getPublicFileUrl(link.linkId, 'https://shogun-relay.scobrudot.dev');
+```
+
+## IPFS Operations
+
+### Upload Single File
+
+```typescript
+// Admin upload
+const result = await sdk.ipfs.uploadFile(
+  fileBuffer,
+  'example.txt',
+  'text/plain'
+);
+
+// User upload with subscription
+const result = await sdk.ipfs.uploadFile(
+  fileBuffer,
+  'example.txt',
+  'text/plain',
+  {
+    userAddress: address,
+    walletSignature: signature
+  }
+);
+
+// Deal upload (no subscription required)
+const result = await sdk.ipfs.uploadFile(
+  fileBuffer,
+  'example.txt',
+  'text/plain',
+  {
+    userAddress: address,
+    walletSignature: signature,
+    isDealUpload: true
+  }
+);
+
+// Encrypted upload
+const encryptedResult = await sdk.ipfs.uploadFile(
+  fileBuffer,
+  'example.txt',
+  'text/plain',
+  {
+    userAddress: address,
+    walletSignature: signature,
+    encrypted: true,
+    encryptionToken: signature // Use same signature for encryption
+  }
+);
+```
+
+### Upload Directory
+
+```typescript
+const files = [
+  {
+    buffer: indexHtmlBuffer,
+    filename: 'index.html',
+    path: 'index.html',
+    contentType: 'text/html'
+  },
+  {
+    buffer: styleCssBuffer,
+    filename: 'style.css',
+    path: 'css/style.css',
+    contentType: 'text/css'
+  }
+];
+
+const result = await sdk.ipfs.uploadDirectory(files, {
+  userAddress: address,
+  walletSignature: signature,
+  isDealUpload: true
+});
+```
+
+### Browser Upload
+
+```typescript
+// Single file
+const fileInput = document.querySelector('input[type="file"]');
+const file = fileInput.files[0];
+
+const result = await sdk.ipfs.uploadFileBrowser(file, {
+  userAddress: address,
+  walletSignature: signature,
+  isDealUpload: true
+});
+
+// Directory upload
+const directoryInput = document.querySelector('input[type="file"][webkitdirectory]');
+const files = Array.from(directoryInput.files);
+
+const result = await sdk.ipfs.uploadDirectoryBrowser(files, {
+  userAddress: address,
+  walletSignature: signature
+});
+```
+
+### Retrieve File
+
+```typescript
+// Get file content
+const content = await sdk.ipfs.cat('QmHash...');
+
+// Get encrypted file (decrypted)
+const decryptedContent = await sdk.ipfs.catDecrypt(
+  'QmHash...',
+  signature, // Encryption token
+  address // Optional: for signature verification
+);
+```
+
+## Storage Deals
+
+### Upload for Deal
+
+```typescript
+const signature = await generateWalletSignature(signer);
+
+const result = await sdk.deals.uploadForDeal(
+  fileBuffer,
+  'example.txt',
+  'text/plain',
+  address,
+  signature // Required: wallet signature
+);
+```
+
+### Create Deal
+
+```typescript
+const deal = await sdk.deals.createDeal({
+  cid: 'QmHash...',
+  clientAddress: address,
+  sizeMB: 10,
+  durationDays: 30,
+  tier: 'standard'
+});
+```
+
+## Wallet Utilities
+
+The SDK includes utility functions for wallet operations:
+
+```typescript
+import {
+  generateWalletSignature,
+  verifyWalletSignature,
+  getAddressFromSignature,
+  WALLET_AUTH_MESSAGE
+} from '@shogun/relay-sdk/utils/wallet';
+
+// Generate signature
+const signature = await generateWalletSignature(signer);
+
+// Verify signature
+const isValid = await verifyWalletSignature(address, signature);
+
+// Get address from signature
+const recoveredAddress = await getAddressFromSignature(signature);
+
+// The message that must be signed
+console.log(WALLET_AUTH_MESSAGE); // "I Love Shogun"
+```
+
+## Complete Example
+
+```typescript
+import ShogunRelaySDK from '@shogun/relay-sdk';
+import { generateWalletSignature } from '@shogun/relay-sdk/utils/wallet';
+import { ethers } from 'ethers';
+import fs from 'fs';
+
+async function uploadFileExample() {
+  // Initialize SDK
+  const sdk = new ShogunRelaySDK({
+    baseURL: 'https://shogun-relay.scobrudot.dev'
+  });
+
+  // Connect wallet
+  const provider = new ethers.BrowserProvider(window.ethereum);
+  const signer = await provider.getSigner();
+  const address = await signer.getAddress();
+
+  // Generate signature for authentication
+  const signature = await generateWalletSignature(signer);
+
+  // Read file
+  const fileBuffer = fs.readFileSync('example.txt');
+
+  // Upload as deal (no subscription required)
+  const result = await sdk.ipfs.uploadFile(
+    fileBuffer,
+    'example.txt',
+    'text/plain',
+    {
+      userAddress: address,
+      walletSignature: signature,
+      isDealUpload: true
+    }
+  );
+
+  console.log('Uploaded! CID:', result.cid);
+  return result;
+}
+```
+
+## API Reference
+
+See the main [API Documentation](../docs/API.md) for complete endpoint reference.
+
+## Modules
+
+- **System**: Health checks, stats, system information
+- **IPFS**: File uploads, directory uploads, content retrieval, pinning
+- **Drive**: Admin drive file system operations, public link sharing
+- **API Keys**: API key management for programmatic access
+- **Deals**: Storage deal creation, activation, management
+- **Registry**: On-chain relay registry operations
+- **Network**: Network federation, reputation, relay discovery
+- **X402**: Subscription management, storage limits
+- **Bridge**: L2 bridge operations, deposits, withdrawals
+- **Uploads**: User upload metadata management
+- **AnnasArchive**: Torrent and archive management
+
+## License
+
+MIT
+

package/dist/index.d.ts

@@ -8,8 +8,13 @@ import { RegistryModule } from "./modules/registry";
 import { UploadsModule } from "./modules/uploads";
 import { BridgeModule } from "./modules/bridge";
 import { AnnasArchiveModule } from "./modules/annas-archive";
+import { DriveModule } from "./modules/drive";
+import { ApiKeysModule } from "./modules/api-keys";
 export * from "./types";
 export * from "./modules/annas-archive";
+export * from "./modules/drive";
+export * from "./modules/api-keys";
+export * from "./utils/wallet";
 export declare class ShogunRelaySDK {
     private client;
     system: SystemModule;
@@ -21,6 +26,8 @@ export declare class ShogunRelaySDK {
     uploads: UploadsModule;
     bridge: BridgeModule;
     annasArchive: AnnasArchiveModule;
+    drive: DriveModule;
+    apiKeys: ApiKeysModule;
     constructor(config: ApiClientConfig);
     setToken(token: string): void;
 }

package/dist/index.js

@@ -25,9 +25,15 @@ const registry_1 = require("./modules/registry");
 const uploads_1 = require("./modules/uploads");
 const bridge_1 = require("./modules/bridge");
 const annas_archive_1 = require("./modules/annas-archive");
+const drive_1 = require("./modules/drive");
+const api_keys_1 = require("./modules/api-keys");
 // Export types
 __exportStar(require("./types"), exports);
 __exportStar(require("./modules/annas-archive"), exports);
+__exportStar(require("./modules/drive"), exports);
+__exportStar(require("./modules/api-keys"), exports);
+// Export wallet utilities
+__exportStar(require("./utils/wallet"), exports);
 class ShogunRelaySDK {
     constructor(config) {
         this.client = new client_1.ApiClient(config);
@@ -40,6 +46,8 @@ class ShogunRelaySDK {
         this.uploads = new uploads_1.UploadsModule(this.client);
         this.bridge = new bridge_1.BridgeModule(this.client);
         this.annasArchive = new annas_archive_1.AnnasArchiveModule(this.client);
+        this.drive = new drive_1.DriveModule(this.client);
+        this.apiKeys = new api_keys_1.ApiKeysModule(this.client);
     }
     setToken(token) {
         this.client.setToken(token);

package/dist/modules/api-keys.d.ts

@@ -0,0 +1,44 @@
+import { ApiClient } from "../client";
+export interface ApiKey {
+    keyId: string;
+    name: string;
+    createdAt: number;
+    lastUsedAt: number | null;
+    expiresAt: number | null;
+}
+export interface ApiKeyCreateResponse {
+    success: boolean;
+    keyId: string;
+    token: string;
+    name: string;
+    createdAt: number;
+    expiresAt: number | null;
+    message: string;
+}
+export interface ApiKeysListResponse {
+    success: boolean;
+    keys: ApiKey[];
+}
+export declare class ApiKeysModule {
+    private client;
+    constructor(client: ApiClient);
+    /**
+     * List all API keys
+     */
+    list(): Promise<ApiKeysListResponse>;
+    /**
+     * Create a new API key
+     */
+    create(name: string, expiresInDays?: number): Promise<ApiKeyCreateResponse>;
+    /**
+     * Revoke an API key
+     */
+    revoke(keyId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Set the API key as the authentication token for future requests
+     */
+    useApiKey(apiKeyToken: string): void;
+}

package/dist/modules/api-keys.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeysModule = void 0;
+class ApiKeysModule {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List all API keys
+     */
+    async list() {
+        return this.client.get("/api/v1/api-keys");
+    }
+    /**
+     * Create a new API key
+     */
+    async create(name, expiresInDays) {
+        return this.client.post("/api/v1/api-keys", {
+            name,
+            expiresInDays,
+        });
+    }
+    /**
+     * Revoke an API key
+     */
+    async revoke(keyId) {
+        return this.client.delete(`/api/v1/api-keys/${keyId}`);
+    }
+    /**
+     * Set the API key as the authentication token for future requests
+     */
+    useApiKey(apiKeyToken) {
+        this.client.setToken(apiKeyToken);
+    }
+}
+exports.ApiKeysModule = ApiKeysModule;

package/dist/modules/deals.d.ts

@@ -3,7 +3,7 @@ export declare class DealsModule {
     private client;
     constructor(client: ApiClient);
     getPricing(sizeMB?: number, durationDays?: number, tier?: string): Promise<any>;
-    uploadForDeal(fileBuffer: Buffer, filename: string, contentType: string, walletAddress: string): Promise<any>;
+    uploadForDeal(fileBuffer: Buffer, filename: string, contentType: string, walletAddress: string, walletSignature: string): Promise<any>;
     createDeal(dealParams: {
         cid: string;
         clientAddress: string;

package/dist/modules/deals.js

@@ -19,7 +19,7 @@ class DealsModule {
             params.tier = tier;
         return this.client.get("/api/v1/deals/pricing", { params });
     }
-    async uploadForDeal(fileBuffer, filename, contentType, walletAddress) {
+    async uploadForDeal(fileBuffer, filename, contentType, walletAddress, walletSignature) {
         const form = new form_data_1.default();
         form.append("file", fileBuffer, {
             filename: filename,
@@ -28,7 +28,9 @@ class DealsModule {
         return this.client.post("/api/v1/deals/upload", form, {
             headers: {
                 ...form.getHeaders(),
-                "x-wallet-address": walletAddress,
+                "x-user-address": walletAddress,
+                "x-wallet-signature": walletSignature,
+                "x-deal-upload": "true",
             },
         });
     }

package/dist/modules/drive.d.ts

@@ -0,0 +1,135 @@
+import { ApiClient } from "../client";
+export interface DriveFileItem {
+    name: string;
+    path: string;
+    type: "file" | "directory";
+    size: number;
+    modified: number;
+}
+export interface DriveListResponse {
+    success: boolean;
+    items: DriveFileItem[];
+    path: string;
+}
+export interface DriveStatsResponse {
+    success: boolean;
+    stats: {
+        totalBytes: number;
+        totalSizeMB: string;
+        totalSizeGB: string;
+        fileCount: number;
+        dirCount: number;
+    };
+}
+export interface PublicLink {
+    linkId: string;
+    filePath: string;
+    createdAt: number;
+    expiresAt: number | null;
+    accessCount: number;
+    lastAccessedAt: number | null;
+}
+export interface PublicLinkResponse {
+    success: boolean;
+    linkId: string;
+    filePath: string;
+    publicUrl: string;
+    createdAt: number;
+    expiresAt: number | null;
+}
+export interface PublicLinksListResponse {
+    success: boolean;
+    links: PublicLink[];
+}
+export declare class DriveModule {
+    private client;
+    constructor(client: ApiClient);
+    /**
+     * List files and folders in the specified directory
+     */
+    list(path?: string): Promise<DriveListResponse>;
+    /**
+     * Upload a single file
+     */
+    uploadFile(file: Buffer | Blob, filename: string, path?: string): Promise<{
+        success: boolean;
+        message: string;
+        files: Array<{
+            name: string;
+            path: string;
+            size: number;
+        }>;
+    }>;
+    /**
+     * Upload multiple files
+     */
+    uploadFiles(files: Array<{
+        file: Buffer | Blob;
+        filename: string;
+    }>, path?: string): Promise<{
+        success: boolean;
+        message: string;
+        files: Array<{
+            name: string;
+            path: string;
+            size: number;
+        }>;
+    }>;
+    /**
+     * Download a file
+     */
+    download(path: string): Promise<Buffer>;
+    /**
+     * Delete a file or directory
+     */
+    delete(path: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Create a directory
+     */
+    createDirectory(name: string, path?: string): Promise<{
+        success: boolean;
+        message: string;
+        path: string;
+    }>;
+    /**
+     * Rename a file or directory
+     */
+    rename(oldPath: string, newName: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Move a file or directory
+     */
+    move(sourcePath: string, destPath: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Get storage statistics
+     */
+    getStats(): Promise<DriveStatsResponse>;
+    /**
+     * Create a public sharing link for a file
+     */
+    createPublicLink(filePath: string, expiresInDays?: number): Promise<PublicLinkResponse>;
+    /**
+     * List all public links
+     */
+    listPublicLinks(): Promise<PublicLinksListResponse>;
+    /**
+     * Revoke a public link
+     */
+    revokePublicLink(linkId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Get public file URL (for direct access without authentication)
+     * Note: This requires the baseURL from the SDK configuration to construct the full URL
+     */
+    getPublicFileUrl(linkId: string, baseURL?: string): string;
+}

package/dist/modules/drive.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveModule = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+class DriveModule {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List files and folders in the specified directory
+     */
+    async list(path) {
+        const url = path ? `/api/v1/drive/list/${encodeURIComponent(path)}` : "/api/v1/drive/list";
+        return this.client.get(url);
+    }
+    /**
+     * Upload a single file
+     */
+    async uploadFile(file, filename, path) {
+        const formData = new form_data_1.default();
+        formData.append("file", file, filename);
+        const url = path ? `/api/v1/drive/upload/${encodeURIComponent(path)}` : "/api/v1/drive/upload";
+        return this.client.post(url, formData, {
+            headers: formData.getHeaders(),
+        });
+    }
+    /**
+     * Upload multiple files
+     */
+    async uploadFiles(files, path) {
+        const formData = new form_data_1.default();
+        files.forEach(({ file, filename }) => {
+            formData.append("files", file, filename);
+        });
+        const url = path ? `/api/v1/drive/upload/${encodeURIComponent(path)}` : "/api/v1/drive/upload";
+        return this.client.post(url, formData, {
+            headers: formData.getHeaders(),
+        });
+    }
+    /**
+     * Download a file
+     */
+    async download(path) {
+        const url = `/api/v1/drive/download/${encodeURIComponent(path)}`;
+        // Use the internal axios client to handle arraybuffer response
+        const response = await this.client.client.get(url, {
+            responseType: "arraybuffer",
+        });
+        return Buffer.from(response.data);
+    }
+    /**
+     * Delete a file or directory
+     */
+    async delete(path) {
+        const url = `/api/v1/drive/delete/${encodeURIComponent(path)}`;
+        return this.client.delete(url);
+    }
+    /**
+     * Create a directory
+     */
+    async createDirectory(name, path) {
+        const url = path ? `/api/v1/drive/mkdir/${encodeURIComponent(path)}` : "/api/v1/drive/mkdir";
+        return this.client.post(url, { name });
+    }
+    /**
+     * Rename a file or directory
+     */
+    async rename(oldPath, newName) {
+        return this.client.post("/api/v1/drive/rename", {
+            oldPath,
+            newName,
+        });
+    }
+    /**
+     * Move a file or directory
+     */
+    async move(sourcePath, destPath) {
+        return this.client.post("/api/v1/drive/move", {
+            sourcePath,
+            destPath,
+        });
+    }
+    /**
+     * Get storage statistics
+     */
+    async getStats() {
+        return this.client.get("/api/v1/drive/stats");
+    }
+    /**
+     * Create a public sharing link for a file
+     */
+    async createPublicLink(filePath, expiresInDays) {
+        return this.client.post("/api/v1/drive/links", {
+            filePath,
+            expiresInDays,
+        });
+    }
+    /**
+     * List all public links
+     */
+    async listPublicLinks() {
+        return this.client.get("/api/v1/drive/links");
+    }
+    /**
+     * Revoke a public link
+     */
+    async revokePublicLink(linkId) {
+        return this.client.delete(`/api/v1/drive/links/${linkId}`);
+    }
+    /**
+     * Get public file URL (for direct access without authentication)
+     * Note: This requires the baseURL from the SDK configuration to construct the full URL
+     */
+    getPublicFileUrl(linkId, baseURL) {
+        if (baseURL) {
+            return `${baseURL}/api/v1/drive/public/${linkId}`;
+        }
+        // If baseURL is not provided, return relative path
+        return `/api/v1/drive/public/${linkId}`;
+    }
+}
+exports.DriveModule = DriveModule;

package/dist/modules/ipfs.d.ts

@@ -3,7 +3,13 @@ export declare class IpfsModule {
     private readonly client;
     constructor(client: ApiClient);
     getStatus(): Promise<any>;
-    uploadFile(fileBuffer: Buffer, filename: string, contentType: string, userAddress?: string): Promise<any>;
+    uploadFile(fileBuffer: Buffer, filename: string, contentType: string, options?: {
+        userAddress?: string;
+        walletSignature?: string;
+        isDealUpload?: boolean;
+        encrypted?: boolean;
+        encryptionToken?: string;
+    }): Promise<any>;
     /**
      * Upload multiple files as a directory to IPFS
      * Maintains directory structure using relative paths
@@ -17,7 +23,11 @@ export declare class IpfsModule {
         filename: string;
         path: string;
         contentType?: string;
-    }>, userAddress?: string): Promise<any>;
+    }>, options?: {
+        userAddress?: string;
+        walletSignature?: string;
+        isDealUpload?: boolean;
+    }): Promise<any>;
     cat(cid: string): Promise<Buffer>;
     /**
      * Cat a file from an IPFS directory using a relative path
@@ -37,19 +47,29 @@ export declare class IpfsModule {
     /**
      * Upload a file using browser FormData (for browser environments)
      * @param file File object from browser File API
-     * @param userAddress Optional user address for authentication
+     * @param options Upload options including authentication
      * @returns Promise with upload result
      */
-    uploadFileBrowser(file: File, userAddress?: string): Promise<any>;
+    uploadFileBrowser(file: File, options?: {
+        userAddress?: string;
+        walletSignature?: string;
+        isDealUpload?: boolean;
+        encrypted?: boolean;
+        encryptionToken?: string;
+    }): Promise<any>;
     /**
      * Upload multiple files as a directory using browser FormData (for browser environments)
      * Maintains directory structure using relative paths from File.webkitRelativePath or file.name
      *
      * @param files Array of File objects from browser File API
-     * @param userAddress Optional user address for authentication
+     * @param options Upload options including authentication
      * @returns Promise with directory CID and file information
      */
-    uploadDirectoryBrowser(files: File[], userAddress?: string): Promise<any>;
+    uploadDirectoryBrowser(files: File[], options?: {
+        userAddress?: string;
+        walletSignature?: string;
+        isDealUpload?: boolean;
+    }): Promise<any>;
     /**
      * Cat a file and return as Blob (for browser environments)
      * @param cid The CID of the file

package/dist/modules/ipfs.js

@@ -12,17 +12,31 @@ class IpfsModule {
     async getStatus() {
         return this.client.get("/api/v1/ipfs/status");
     }
-    async uploadFile(fileBuffer, filename, contentType, userAddress) {
+    async uploadFile(fileBuffer, filename, contentType, options) {
         const form = new form_data_1.default();
         form.append("file", fileBuffer, {
             filename: filename,
             contentType: contentType,
         });
         const headers = form.getHeaders();
-        if (userAddress) {
-            headers["x-user-address"] = userAddress;
+        if (options?.userAddress) {
+            headers["x-user-address"] = options.userAddress;
+        }
+        if (options?.walletSignature) {
+            headers["x-wallet-signature"] = options.walletSignature;
+        }
+        if (options?.isDealUpload) {
+            headers["x-deal-upload"] = "true";
+        }
+        if (options?.encrypted) {
+            form.append("encrypted", "true");
+            form.append("encryptionMethod", "SEA");
+            if (options.encryptionToken) {
+                form.append("encryptionToken", options.encryptionToken);
+            }
         }
-        return this.client.post("/api/v1/ipfs/upload", form, {
+        const queryParams = options?.isDealUpload ? "?deal=true" : "";
+        return this.client.post(`/api/v1/ipfs/upload${queryParams}`, form, {
             headers: headers,
         });
     }
@@ -34,7 +48,7 @@ class IpfsModule {
      * @param userAddress Optional user address for authentication
      * @returns Promise with directory CID and file information
      */
-    async uploadDirectory(files, userAddress) {
+    async uploadDirectory(files, options) {
         if (!files || files.length === 0) {
             throw new Error("At least one file is required for directory upload");
         }
@@ -47,8 +61,14 @@ class IpfsModule {
             });
         });
         const headers = form.getHeaders();
-        if (userAddress) {
-            headers["x-user-address"] = userAddress;
+        if (options?.userAddress) {
+            headers["x-user-address"] = options.userAddress;
+        }
+        if (options?.walletSignature) {
+            headers["x-wallet-signature"] = options.walletSignature;
+        }
+        if (options?.isDealUpload) {
+            headers["x-deal-upload"] = "true";
         }
         return this.client.post("/api/v1/ipfs/upload-directory", form, {
             headers: headers,
@@ -124,18 +144,32 @@ class IpfsModule {
     /**
      * Upload a file using browser FormData (for browser environments)
      * @param file File object from browser File API
-     * @param userAddress Optional user address for authentication
+     * @param options Upload options including authentication
      * @returns Promise with upload result
      */
-    async uploadFileBrowser(file, userAddress) {
+    async uploadFileBrowser(file, options) {
         const formData = new form_data_1.default();
         formData.append("file", file, file.name);
         const headers = {};
-        if (userAddress) {
-            headers["x-user-address"] = userAddress;
+        if (options?.userAddress) {
+            headers["x-user-address"] = options.userAddress;
+        }
+        if (options?.walletSignature) {
+            headers["x-wallet-signature"] = options.walletSignature;
+        }
+        if (options?.isDealUpload) {
+            headers["x-deal-upload"] = "true";
+        }
+        if (options?.encrypted) {
+            formData.append("encrypted", "true");
+            formData.append("encryptionMethod", "SEA");
+            if (options.encryptionToken) {
+                formData.append("encryptionToken", options.encryptionToken);
+            }
         }
+        const queryParams = options?.isDealUpload ? "?deal=true" : "";
         // Explicitly don't set Content-Type - let browser set it with boundary for FormData
-        return this.client.post("/api/v1/ipfs/upload", formData, {
+        return this.client.post(`/api/v1/ipfs/upload${queryParams}`, formData, {
             headers: headers,
             // Ensure axios doesn't serialize FormData as JSON
             transformRequest: [(data) => {
@@ -152,10 +186,10 @@ class IpfsModule {
      * Maintains directory structure using relative paths from File.webkitRelativePath or file.name
      *
      * @param files Array of File objects from browser File API
-     * @param userAddress Optional user address for authentication
+     * @param options Upload options including authentication
      * @returns Promise with directory CID and file information
      */
-    async uploadDirectoryBrowser(files, userAddress) {
+    async uploadDirectoryBrowser(files, options) {
         if (!files || files.length === 0) {
             throw new Error("At least one file is required for directory upload");
         }
@@ -167,8 +201,14 @@ class IpfsModule {
             formData.append("files", file, relativePath);
         });
         const headers = {};
-        if (userAddress) {
-            headers["x-user-address"] = userAddress;
+        if (options?.userAddress) {
+            headers["x-user-address"] = options.userAddress;
+        }
+        if (options?.walletSignature) {
+            headers["x-wallet-signature"] = options.walletSignature;
+        }
+        if (options?.isDealUpload) {
+            headers["x-deal-upload"] = "true";
         }
         // Explicitly don't set Content-Type - let browser set it with boundary for FormData
         return this.client.post("/api/v1/ipfs/upload-directory", formData, {

package/dist/utils/wallet.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Wallet utility functions for Shogun Relay SDK
+ */
+/**
+ * Message that must be signed for wallet authentication
+ */
+export declare const WALLET_AUTH_MESSAGE = "I Love Shogun";
+/**
+ * Generate wallet signature for authentication
+ *
+ * @param signer - Ethers.js Signer instance or similar that implements signMessage
+ * @returns Promise<string> - EIP-191 signature of the auth message
+ *
+ * @example
+ * ```typescript
+ * import { ethers } from 'ethers';
+ * import { generateWalletSignature } from '@shogun/relay-sdk/utils/wallet';
+ *
+ * const provider = new ethers.BrowserProvider(window.ethereum);
+ * const signer = await provider.getSigner();
+ * const signature = await generateWalletSignature(signer);
+ * ```
+ */
+export declare function generateWalletSignature(signer: {
+    signMessage: (message: string) => Promise<string>;
+}): Promise<string>;
+/**
+ * Verify wallet signature
+ *
+ * @param address - Ethereum wallet address
+ * @param signature - EIP-191 signature
+ * @returns Promise<boolean> - True if signature is valid for the address
+ *
+ * @example
+ * ```typescript
+ * import { ethers } from 'ethers';
+ * import { verifyWalletSignature } from '@shogun/relay-sdk/utils/wallet';
+ *
+ * const isValid = await verifyWalletSignature(address, signature);
+ * ```
+ */
+export declare function verifyWalletSignature(address: string, signature: string): Promise<boolean>;
+/**
+ * Get wallet address from signature
+ *
+ * @param signature - EIP-191 signature
+ * @returns Promise<string | null> - Recovered wallet address or null if invalid
+ *
+ * @example
+ * ```typescript
+ * import { getAddressFromSignature } from '@shogun/relay-sdk/utils/wallet';
+ *
+ * const address = await getAddressFromSignature(signature);
+ * ```
+ */
+export declare function getAddressFromSignature(signature: string): Promise<string | null>;

package/dist/utils/wallet.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Wallet utility functions for Shogun Relay SDK
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WALLET_AUTH_MESSAGE = void 0;
+exports.generateWalletSignature = generateWalletSignature;
+exports.verifyWalletSignature = verifyWalletSignature;
+exports.getAddressFromSignature = getAddressFromSignature;
+/**
+ * Message that must be signed for wallet authentication
+ */
+exports.WALLET_AUTH_MESSAGE = "I Love Shogun";
+/**
+ * Generate wallet signature for authentication
+ *
+ * @param signer - Ethers.js Signer instance or similar that implements signMessage
+ * @returns Promise<string> - EIP-191 signature of the auth message
+ *
+ * @example
+ * ```typescript
+ * import { ethers } from 'ethers';
+ * import { generateWalletSignature } from '@shogun/relay-sdk/utils/wallet';
+ *
+ * const provider = new ethers.BrowserProvider(window.ethereum);
+ * const signer = await provider.getSigner();
+ * const signature = await generateWalletSignature(signer);
+ * ```
+ */
+async function generateWalletSignature(signer) {
+    return await signer.signMessage(exports.WALLET_AUTH_MESSAGE);
+}
+/**
+ * Verify wallet signature
+ *
+ * @param address - Ethereum wallet address
+ * @param signature - EIP-191 signature
+ * @returns Promise<boolean> - True if signature is valid for the address
+ *
+ * @example
+ * ```typescript
+ * import { ethers } from 'ethers';
+ * import { verifyWalletSignature } from '@shogun/relay-sdk/utils/wallet';
+ *
+ * const isValid = await verifyWalletSignature(address, signature);
+ * ```
+ */
+async function verifyWalletSignature(address, signature) {
+    try {
+        const { ethers } = await Promise.resolve().then(() => __importStar(require("ethers")));
+        const recoveredAddress = ethers.verifyMessage(exports.WALLET_AUTH_MESSAGE, signature);
+        return recoveredAddress.toLowerCase() === address.toLowerCase();
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Get wallet address from signature
+ *
+ * @param signature - EIP-191 signature
+ * @returns Promise<string | null> - Recovered wallet address or null if invalid
+ *
+ * @example
+ * ```typescript
+ * import { getAddressFromSignature } from '@shogun/relay-sdk/utils/wallet';
+ *
+ * const address = await getAddressFromSignature(signature);
+ * ```
+ */
+async function getAddressFromSignature(signature) {
+    try {
+        const { ethers } = await Promise.resolve().then(() => __importStar(require("ethers")));
+        return ethers.verifyMessage(exports.WALLET_AUTH_MESSAGE, signature);
+    }
+    catch (error) {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shogun-relay-sdk",
-  "version": "1.2.11",
+  "version": "1.4.0",
   "description": "SDK for interacting with Shogun Relay API - HTTP client for IPFS, deals, registry, and network operations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",