shogun-relay-sdk 1.0.0

package/dist/client.d.ts

@@ -0,0 +1,16 @@
+import { AxiosRequestConfig } from 'axios';
+export interface ApiClientConfig {
+    baseURL: string;
+    token?: string;
+    timeout?: number;
+}
+export declare class ApiClient {
+    private client;
+    private config;
+    constructor(config: ApiClientConfig);
+    setToken(token: string): void;
+    get<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    put<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    delete<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+}

package/dist/client.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class ApiClient {
+    constructor(config) {
+        this.config = config;
+        this.client = axios_1.default.create({
+            baseURL: config.baseURL,
+            timeout: config.timeout || 30000,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        // Add auth interceptor
+        this.client.interceptors.request.use((req) => {
+            if (this.config.token) {
+                req.headers['Authorization'] = `Bearer ${this.config.token}`;
+            }
+            return req;
+        });
+    }
+    setToken(token) {
+        this.config.token = token;
+    }
+    async get(url, config) {
+        const response = await this.client.get(url, config);
+        return response.data;
+    }
+    async post(url, data, config) {
+        const response = await this.client.post(url, data, config);
+        return response.data;
+    }
+    async put(url, data, config) {
+        const response = await this.client.put(url, data, config);
+        return response.data;
+    }
+    async delete(url, config) {
+        const response = await this.client.delete(url, config);
+        return response.data;
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { ApiClientConfig } from './client';
+import { SystemModule } from './modules/system';
+import { IpfsModule } from './modules/ipfs';
+import { X402Module } from './modules/x402';
+import { NetworkModule } from './modules/network';
+import { DealsModule } from './modules/deals';
+import { RegistryModule } from './modules/registry';
+import { UploadsModule } from './modules/uploads';
+export declare class ShogunRelaySDK {
+    private client;
+    system: SystemModule;
+    ipfs: IpfsModule;
+    x402: X402Module;
+    network: NetworkModule;
+    deals: DealsModule;
+    registry: RegistryModule;
+    uploads: UploadsModule;
+    constructor(config: ApiClientConfig);
+    setToken(token: string): void;
+}
+export default ShogunRelaySDK;

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShogunRelaySDK = void 0;
+const client_1 = require("./client");
+const system_1 = require("./modules/system");
+const ipfs_1 = require("./modules/ipfs");
+const x402_1 = require("./modules/x402");
+const network_1 = require("./modules/network");
+const deals_1 = require("./modules/deals");
+const registry_1 = require("./modules/registry");
+const uploads_1 = require("./modules/uploads");
+class ShogunRelaySDK {
+    constructor(config) {
+        this.client = new client_1.ApiClient(config);
+        this.system = new system_1.SystemModule(this.client);
+        this.ipfs = new ipfs_1.IpfsModule(this.client);
+        this.x402 = new x402_1.X402Module(this.client);
+        this.network = new network_1.NetworkModule(this.client);
+        this.deals = new deals_1.DealsModule(this.client);
+        this.registry = new registry_1.RegistryModule(this.client);
+        this.uploads = new uploads_1.UploadsModule(this.client);
+    }
+    setToken(token) {
+        this.client.setToken(token);
+    }
+}
+exports.ShogunRelaySDK = ShogunRelaySDK;
+exports.default = ShogunRelaySDK;

package/dist/modules/deals.d.ts

@@ -0,0 +1,23 @@
+import { ApiClient } from '../client';
+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>;
+    createDeal(dealParams: {
+        cid: string;
+        clientAddress: string;
+        sizeMB: number;
+        durationDays: number;
+        tier?: string;
+    }): Promise<any>;
+    activateDeal(dealId: string, payment: any): Promise<any>;
+    getDealsByCid(cid: string): Promise<any>;
+    getDealsByClient(address: string): Promise<any>;
+    getDeal(dealId: string): Promise<any>;
+    verifyDeal(dealId: string, clientAddress?: string): Promise<any>;
+    renewDeal(dealId: string, additionalDays: number, payment?: any): Promise<any>;
+    cancelDeal(dealId: string, clientAddress: string, reason?: string): Promise<any>;
+    getDealStats(): Promise<any>;
+    getLeaderboard(limit?: number): Promise<any>;
+}

package/dist/modules/deals.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DealsModule = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+class DealsModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async getPricing(sizeMB, durationDays, tier) {
+        const params = {};
+        if (sizeMB)
+            params.sizeMB = sizeMB;
+        if (durationDays)
+            params.durationDays = durationDays;
+        if (tier)
+            params.tier = tier;
+        return this.client.get('/api/v1/deals/pricing', { params });
+    }
+    async uploadForDeal(fileBuffer, filename, contentType, walletAddress) {
+        const form = new form_data_1.default();
+        form.append('file', fileBuffer, {
+            filename: filename,
+            contentType: contentType,
+        });
+        return this.client.post('/api/v1/deals/upload', form, {
+            headers: {
+                ...form.getHeaders(),
+                'x-wallet-address': walletAddress,
+            },
+        });
+    }
+    async createDeal(dealParams) {
+        return this.client.post('/api/v1/deals/create', dealParams);
+    }
+    async activateDeal(dealId, payment) {
+        return this.client.post(`/api/v1/deals/${dealId}/activate`, { payment });
+    }
+    async getDealsByCid(cid) {
+        return this.client.get(`/api/v1/deals/by-cid/${cid}`);
+    }
+    async getDealsByClient(address) {
+        return this.client.get(`/api/v1/deals/by-client/${address}`);
+    }
+    async getDeal(dealId) {
+        return this.client.get(`/api/v1/deals/${dealId}`);
+    }
+    async verifyDeal(dealId, clientAddress) {
+        const params = {};
+        if (clientAddress)
+            params.clientAddress = clientAddress;
+        return this.client.get(`/api/v1/deals/${dealId}/verify`, { params });
+    }
+    async renewDeal(dealId, additionalDays, payment) {
+        return this.client.post(`/api/v1/deals/${dealId}/renew`, {
+            additionalDays,
+            payment,
+        });
+    }
+    async cancelDeal(dealId, clientAddress, reason) {
+        return this.client.post(`/api/v1/deals/${dealId}/cancel`, {
+            clientAddress,
+            reason: reason || 'User requested cancellation',
+        });
+    }
+    async getDealStats() {
+        return this.client.get('/api/v1/deals/stats');
+    }
+    async getLeaderboard(limit) {
+        const params = {};
+        if (limit)
+            params.limit = limit;
+        return this.client.get('/api/v1/deals/leaderboard', { params });
+    }
+}
+exports.DealsModule = DealsModule;

package/dist/modules/ipfs.d.ts

@@ -0,0 +1,16 @@
+import { ApiClient } from '../client';
+export declare class IpfsModule {
+    private client;
+    constructor(client: ApiClient);
+    getStatus(): Promise<any>;
+    uploadFile(fileBuffer: Buffer, filename: string, contentType: string, userAddress?: string): Promise<any>;
+    cat(cid: string): Promise<Buffer>;
+    pinAdd(cid: string): Promise<any>;
+    pinRm(cid: string): Promise<any>;
+    pinLs(): Promise<any>;
+    catJson(cid: string): Promise<any>;
+    catDecrypt(cid: string, token: string, userAddress?: string): Promise<Buffer>;
+    repoGC(): Promise<any>;
+    repoStat(): Promise<any>;
+    getVersion(): Promise<any>;
+}

package/dist/modules/ipfs.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IpfsModule = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+class IpfsModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async getStatus() {
+        return this.client.get('/api/v1/ipfs/status');
+    }
+    async uploadFile(fileBuffer, filename, contentType, userAddress) {
+        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;
+        }
+        return this.client.post('/api/v1/ipfs/upload', form, {
+            headers: headers,
+        });
+    }
+    async cat(cid) {
+        return this.client.get(`/api/v1/ipfs/cat/${cid}`, {
+            responseType: 'arraybuffer',
+        });
+    }
+    async pinAdd(cid) {
+        return this.client.post('/api/v1/ipfs/pin/add', { cid });
+    }
+    async pinRm(cid) {
+        return this.client.post('/api/v1/ipfs/pin/rm', { cid });
+    }
+    async pinLs() {
+        // Note: relay's pin/ls endpoint lists all pins and doesn't support filtering by CID
+        return this.client.get('/api/v1/ipfs/pin/ls');
+    }
+    async catJson(cid) {
+        return this.client.get(`/api/v1/ipfs/cat/${cid}/json`);
+    }
+    async catDecrypt(cid, token, userAddress) {
+        const params = { token };
+        const headers = {};
+        if (userAddress) {
+            headers['x-user-address'] = userAddress;
+        }
+        return this.client.get(`/api/v1/ipfs/cat/${cid}/decrypt`, {
+            params,
+            headers,
+            responseType: 'arraybuffer',
+        });
+    }
+    async repoGC() {
+        return this.client.post('/api/v1/ipfs/repo/gc');
+    }
+    async repoStat() {
+        return this.client.get('/api/v1/ipfs/repo/stat');
+    }
+    async getVersion() {
+        return this.client.get('/api/v1/ipfs/version');
+    }
+}
+exports.IpfsModule = IpfsModule;

package/dist/modules/network.d.ts

@@ -0,0 +1,17 @@
+import { ApiClient } from '../client';
+export declare class NetworkModule {
+    private client;
+    constructor(client: ApiClient);
+    getRelays(timeout?: number, maxAge?: number): Promise<any>;
+    getRelay(host: string): Promise<any>;
+    getStats(): Promise<any>;
+    getProof(cid: string, challenge?: string): Promise<any>;
+    verifyProof(proof: any): Promise<any>;
+    getReputation(host: string): Promise<any>;
+    getReputationLeaderboard(minScore?: number, limit?: number): Promise<any>;
+    getBestRelays(count?: number, minScore?: number, excludeHost?: string): Promise<any>;
+    getOnChainRelays(chainId?: number): Promise<any>;
+    getOnChainRelay(address: string, chainId?: number): Promise<any>;
+    getOnChainParams(chainId?: number): Promise<any>;
+    getPinRequests(maxAge?: number): Promise<any>;
+}

package/dist/modules/network.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkModule = void 0;
+class NetworkModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async getRelays(timeout, maxAge) {
+        const params = {};
+        if (timeout)
+            params.timeout = timeout;
+        if (maxAge)
+            params.maxAge = maxAge;
+        return this.client.get('/api/v1/network/relays', { params });
+    }
+    async getRelay(host) {
+        return this.client.get(`/api/v1/network/relay/${host}`);
+    }
+    async getStats() {
+        return this.client.get('/api/v1/network/stats');
+    }
+    async getProof(cid, challenge) {
+        const params = {};
+        if (challenge)
+            params.challenge = challenge;
+        return this.client.get(`/api/v1/network/proof/${cid}`, { params });
+    }
+    async verifyProof(proof) {
+        return this.client.post('/api/v1/network/verify-proof', { proof });
+    }
+    async getReputation(host) {
+        return this.client.get(`/api/v1/network/reputation/${host}`);
+    }
+    async getReputationLeaderboard(minScore, limit) {
+        const params = {};
+        if (minScore)
+            params.minScore = minScore;
+        if (limit)
+            params.limit = limit;
+        return this.client.get('/api/v1/network/reputation', { params });
+    }
+    async getBestRelays(count, minScore, excludeHost) {
+        const params = {};
+        if (count)
+            params.count = count;
+        if (minScore)
+            params.minScore = minScore;
+        if (excludeHost)
+            params.exclude = excludeHost;
+        return this.client.get('/api/v1/network/best-relays', { params });
+    }
+    // Note: On-chain endpoints are not available in the relay API
+    // Use shogun-contracts-sdk for on-chain interactions instead
+    // These methods are kept for backward compatibility but will throw an error
+    async getOnChainRelays(chainId) {
+        throw new Error('On-chain endpoints are not available in relay API. Use shogun-contracts-sdk for on-chain interactions.');
+    }
+    async getOnChainRelay(address, chainId) {
+        throw new Error('On-chain endpoints are not available in relay API. Use shogun-contracts-sdk for on-chain interactions.');
+    }
+    async getOnChainParams(chainId) {
+        throw new Error('On-chain endpoints are not available in relay API. Use shogun-contracts-sdk for on-chain interactions.');
+    }
+    async getPinRequests(maxAge) {
+        const params = {};
+        if (maxAge)
+            params.maxAge = maxAge;
+        return this.client.get('/api/v1/network/pin-requests', { params });
+    }
+}
+exports.NetworkModule = NetworkModule;

package/dist/modules/registry.d.ts

@@ -0,0 +1,18 @@
+import { ApiClient } from '../client';
+export declare class RegistryModule {
+    private client;
+    constructor(client: ApiClient);
+    getStatus(): Promise<any>;
+    getBalance(): Promise<any>;
+    registerRelay(endpoint: string, gunPubKey: string, stakeAmount: string): Promise<any>;
+    updateRelay(newEndpoint?: string, newGunPubKey?: string): Promise<any>;
+    increaseStake(amount: string): Promise<any>;
+    requestUnstake(): Promise<any>;
+    withdrawStake(): Promise<any>;
+    getDeals(): Promise<any>;
+    griefMissedProof(relayAddress: string, dealId: string, evidence: string): Promise<any>;
+    griefDataLoss(relayAddress: string, dealId: string, evidence: string): Promise<any>;
+    griefDeal(dealId: string, slashAmount: string, reason: string): Promise<any>;
+    getParams(): Promise<any>;
+    getConfig(): Promise<any>;
+}

package/dist/modules/registry.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryModule = void 0;
+class RegistryModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async getStatus() {
+        return this.client.get('/api/v1/registry/status');
+    }
+    async getBalance() {
+        return this.client.get('/api/v1/registry/balance');
+    }
+    async registerRelay(endpoint, gunPubKey, stakeAmount) {
+        return this.client.post('/api/v1/registry/register', {
+            endpoint,
+            gunPubKey,
+            stakeAmount,
+        });
+    }
+    async updateRelay(newEndpoint, newGunPubKey) {
+        return this.client.post('/api/v1/registry/update', {
+            newEndpoint,
+            newGunPubKey,
+        });
+    }
+    async increaseStake(amount) {
+        return this.client.post('/api/v1/registry/stake/increase', { amount });
+    }
+    async requestUnstake() {
+        return this.client.post('/api/v1/registry/stake/unstake');
+    }
+    async withdrawStake() {
+        return this.client.post('/api/v1/registry/stake/withdraw');
+    }
+    async getDeals() {
+        return this.client.get('/api/v1/registry/deals');
+    }
+    async griefMissedProof(relayAddress, dealId, evidence) {
+        return this.client.post('/api/v1/registry/grief/missed-proof', {
+            relayAddress,
+            dealId,
+            evidence,
+        });
+    }
+    async griefDataLoss(relayAddress, dealId, evidence) {
+        return this.client.post('/api/v1/registry/grief/data-loss', {
+            relayAddress,
+            dealId,
+            evidence,
+        });
+    }
+    async griefDeal(dealId, slashAmount, reason) {
+        return this.client.post('/api/v1/registry/deal/grief', {
+            dealId,
+            slashAmount,
+            reason,
+        });
+    }
+    async getParams() {
+        return this.client.get('/api/v1/registry/params');
+    }
+    async getConfig() {
+        return this.client.get('/api/v1/registry/config');
+    }
+}
+exports.RegistryModule = RegistryModule;

package/dist/modules/system.d.ts

@@ -0,0 +1,16 @@
+import { ApiClient } from '../client';
+export interface HealthResponse {
+    success: boolean;
+    message: string;
+    data: {
+        timestamp: string;
+        version: string;
+        uptime: number;
+    };
+}
+export declare class SystemModule {
+    private client;
+    constructor(client: ApiClient);
+    getHealth(): Promise<HealthResponse>;
+    getStats(): Promise<any>;
+}

package/dist/modules/system.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemModule = void 0;
+class SystemModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async getHealth() {
+        // Use /api/v1/system/health (the correct endpoint in the relay)
+        return this.client.get('/api/v1/system/health');
+    }
+    async getStats() {
+        return this.client.get('/api/v1/system/stats');
+    }
+}
+exports.SystemModule = SystemModule;

package/dist/modules/uploads.d.ts

@@ -0,0 +1,8 @@
+import { ApiClient } from '../client';
+export declare class UploadsModule {
+    private client;
+    constructor(client: ApiClient);
+    getUserUploads(identifier: string): Promise<any>;
+    deleteUpload(identifier: string, hash: string): Promise<any>;
+    getSystemHashes(): Promise<any>;
+}

package/dist/modules/uploads.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadsModule = void 0;
+class UploadsModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async getUserUploads(identifier) {
+        return this.client.get(`/api/v1/user-uploads/${identifier}`);
+    }
+    async deleteUpload(identifier, hash) {
+        return this.client.delete(`/api/v1/user-uploads/${identifier}/${hash}`);
+    }
+    async getSystemHashes() {
+        return this.client.get('/api/v1/user-uploads/system-hashes');
+    }
+}
+exports.UploadsModule = UploadsModule;

package/dist/modules/x402.d.ts

@@ -0,0 +1,15 @@
+import { ApiClient } from '../client';
+export declare class X402Module {
+    private client;
+    constructor(client: ApiClient);
+    getTiers(): Promise<any>;
+    getSubscription(userAddress: string): Promise<any>;
+    subscribe(userAddress: string, tier: string, payment?: any): Promise<any>;
+    getPaymentRequirements(tier: string): Promise<any>;
+    canUpload(userAddress: string, sizeMB: number): Promise<any>;
+    getStorageUsage(userAddress: string): Promise<any>;
+    canUploadVerified(userAddress: string, sizeMB: number): Promise<any>;
+    getRecommendation(fileSizeMB: number, durationDays: number, userAddress?: string): Promise<any>;
+    getConfig(): Promise<any>;
+    getRelayStorage(): Promise<any>;
+}

package/dist/modules/x402.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.X402Module = void 0;
+class X402Module {
+    constructor(client) {
+        this.client = client;
+    }
+    async getTiers() {
+        return this.client.get('/api/v1/x402/tiers');
+    }
+    async getSubscription(userAddress) {
+        return this.client.get(`/api/v1/x402/subscription/${userAddress}`);
+    }
+    async subscribe(userAddress, tier, payment) {
+        return this.client.post('/api/v1/x402/subscribe', {
+            userAddress,
+            tier,
+            payment,
+        });
+    }
+    async getPaymentRequirements(tier) {
+        return this.client.get(`/api/v1/x402/payment-requirements/${tier}`);
+    }
+    async canUpload(userAddress, sizeMB) {
+        return this.client.get(`/api/v1/x402/can-upload/${userAddress}?size=${sizeMB}`);
+    }
+    async getStorageUsage(userAddress) {
+        return this.client.get(`/api/v1/x402/storage/${userAddress}`);
+    }
+    async canUploadVerified(userAddress, sizeMB) {
+        return this.client.get(`/api/v1/x402/can-upload-verified/${userAddress}?size=${sizeMB}`);
+    }
+    async getRecommendation(fileSizeMB, durationDays, userAddress) {
+        const params = {
+            fileSizeMB,
+            durationDays,
+        };
+        if (userAddress)
+            params.userAddress = userAddress;
+        return this.client.get('/api/v1/x402/recommend', { params });
+    }
+    async getConfig() {
+        return this.client.get('/api/v1/x402/config');
+    }
+    async getRelayStorage() {
+        return this.client.get('/api/v1/x402/relay-storage');
+    }
+}
+exports.X402Module = X402Module;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "shogun-relay-sdk",
+  "version": "1.0.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",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "shogun",
+    "relay",
+    "sdk",
+    "ipfs",
+    "gun",
+    "decentralized",
+    "storage",
+    "api-client"
+  ],
+  "author": "scobru",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shogun-network/shogun-2.git",
+    "directory": "shogun-relay/relay-sdk"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "form-data": "^4.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}