shogun-relay-sdk 1.2.10 → 1.3.0

package/README.md

@@ -0,0 +1,304 @@
+# 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)
+  }
+);
+```
+
+## 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
+- **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

@@ -7,7 +7,10 @@ import { DealsModule } from "./modules/deals";
 import { RegistryModule } from "./modules/registry";
 import { UploadsModule } from "./modules/uploads";
 import { BridgeModule } from "./modules/bridge";
+import { AnnasArchiveModule } from "./modules/annas-archive";
 export * from "./types";
+export * from "./modules/annas-archive";
+export * from "./utils/wallet";
 export declare class ShogunRelaySDK {
     private client;
     system: SystemModule;
@@ -18,6 +21,7 @@ export declare class ShogunRelaySDK {
     registry: RegistryModule;
     uploads: UploadsModule;
     bridge: BridgeModule;
+    annasArchive: AnnasArchiveModule;
     constructor(config: ApiClientConfig);
     setToken(token: string): void;
 }

package/dist/index.js

@@ -24,8 +24,12 @@ const deals_1 = require("./modules/deals");
 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");
 // Export types
 __exportStar(require("./types"), exports);
+__exportStar(require("./modules/annas-archive"), exports);
+// Export wallet utilities
+__exportStar(require("./utils/wallet"), exports);
 class ShogunRelaySDK {
     constructor(config) {
         this.client = new client_1.ApiClient(config);
@@ -37,6 +41,7 @@ class ShogunRelaySDK {
         this.registry = new registry_1.RegistryModule(this.client);
         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);
     }
     setToken(token) {
         this.client.setToken(token);

package/dist/modules/annas-archive.d.ts

@@ -0,0 +1,35 @@
+import { ApiClient } from "../client";
+export interface AnnasArchiveStatus {
+    enabled: boolean;
+    activeTorrents: number;
+    downloadSpeed: number;
+    uploadSpeed: number;
+    ratio: number;
+    torrents: {
+        infoHash: string;
+        name: string;
+        progress: number;
+        downloadSpeed: number;
+        uploadSpeed: number;
+        peers: number;
+    }[];
+}
+export declare class AnnasArchiveModule {
+    private client;
+    constructor(client: ApiClient);
+    /**
+     * Get Anna's Archive integration status
+     */
+    getStatus(): Promise<{
+        success: boolean;
+        data: AnnasArchiveStatus;
+    }>;
+    /**
+     * Add a manual torrent
+     * @param magnet Magnet link or URL
+     */
+    addTorrent(magnet: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}

package/dist/modules/annas-archive.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnnasArchiveModule = void 0;
+class AnnasArchiveModule {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get Anna's Archive integration status
+     */
+    async getStatus() {
+        return this.client.get("/api/v1/annas-archive/status");
+    }
+    /**
+     * Add a manual torrent
+     * @param magnet Magnet link or URL
+     */
+    async addTorrent(magnet) {
+        return this.client.post("/api/v1/annas-archive/add", { magnet });
+    }
+}
+exports.AnnasArchiveModule = AnnasArchiveModule;

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/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.10",
+  "version": "1.3.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",