@citrate/sdk 0.2.0

package/dist/sdk.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CitrateSDK = void 0;
+const events_1 = require("events");
+const axios_1 = __importDefault(require("axios"));
+const model_1 = require("./model");
+const contract_1 = require("./contract");
+const account_1 = require("./account");
+/**
+ * Main Citrate SDK class
+ */
+class CitrateSDK extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        const rpcEndpoint = config.rpcEndpoint ?? 'http://localhost:8545';
+        const chainId = config.chainId ?? 1337;
+        this.config = { ...config, rpcEndpoint, chainId };
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (this.config.apiKey) {
+            headers['Authorization'] = `Bearer ${this.config.apiKey}`;
+        }
+        this.rpcClient = axios_1.default.create({
+            baseURL: this.config.rpcEndpoint,
+            headers
+        });
+        // Initialize managers
+        this.models = new model_1.ModelRegistry(this.rpcClient, this.config);
+        this.contracts = new contract_1.ContractManager(this.rpcClient, this.config);
+        this.accounts = new account_1.AccountManager(this.rpcClient, this.config);
+    }
+    /**
+     * Deploy a model to the network
+     */
+    async deployModel(modelData, metadata) {
+        return this.models.deploy(modelData, metadata);
+    }
+    /**
+     * Run inference on a deployed model
+     */
+    async runInference(modelId, input, options) {
+        return this.models.runInference(modelId, input, options);
+    }
+    /**
+     * Get proof for an execution
+     */
+    async getProof(executionId) {
+        const response = await this.rpcCall('citrate_getProof', [{
+                execution_id: executionId
+            }]);
+        return response.proof;
+    }
+    /**
+     * Verify a proof
+     */
+    async verifyProof(proof, expectedOutput) {
+        const response = await this.rpcCall('citrate_verifyProof', [{
+                proof,
+                output_hash: expectedOutput
+            }]);
+        return response.valid;
+    }
+    // ======= Artifacts =======
+    async pinArtifact(cid, replicas = 1) {
+        const response = await this.rpcClient.post('', {
+            jsonrpc: '2.0', method: 'citrate_pinArtifact', params: [cid, replicas], id: Date.now()
+        });
+        if (response.data.error)
+            throw new Error(response.data.error.message);
+        return response.data.result;
+    }
+    async getArtifactStatus(cid) {
+        const response = await this.rpcClient.post('', {
+            jsonrpc: '2.0', method: 'citrate_getArtifactStatus', params: [cid], id: Date.now()
+        });
+        if (response.data.error)
+            throw new Error(response.data.error.message);
+        const result = response.data.result;
+        try {
+            return JSON.parse(typeof result === 'string' ? result : JSON.stringify(result));
+        }
+        catch {
+            return [];
+        }
+    }
+    async listModelArtifacts(modelIdHex) {
+        const response = await this.rpcClient.post('', {
+            jsonrpc: '2.0', method: 'citrate_listModelArtifacts', params: [modelIdHex], id: Date.now()
+        });
+        if (response.data.error)
+            throw new Error(response.data.error.message);
+        const result = response.data.result;
+        return Array.isArray(result) ? result : [];
+    }
+    /**
+     * Get network information
+     */
+    async getNetworkInfo() {
+        const [networkId, chainIdHex, blockNumber, syncing, peerCount] = await Promise.all([
+            this.rpcCall('net_version'),
+            this.rpcCall('eth_chainId'),
+            this.rpcCall('eth_blockNumber'),
+            this.rpcCall('eth_syncing'),
+            this.rpcCall('net_peerCount')
+        ]);
+        return {
+            networkId: parseInt(networkId),
+            chainId: parseInt(chainIdHex, 16),
+            blockNumber: parseInt(blockNumber, 16),
+            syncing: typeof syncing === 'object',
+            peerCount: parseInt(peerCount, 16)
+        };
+    }
+    /**
+     * Get block information
+     */
+    async getBlock(blockNumber) {
+        const tag = blockNumber === 'latest' ? 'latest' : `0x${blockNumber.toString(16)}`;
+        // For "latest", retry with a small delay if the RPC returns null.
+        // This handles the race condition where get_latest_height() reports a
+        // height whose block data hasn't been fully committed yet.
+        let block = await this.rpcCall('eth_getBlockByNumber', [tag, true]);
+        if (!block && blockNumber === 'latest') {
+            for (let attempt = 0; attempt < 3 && !block; attempt++) {
+                await new Promise(r => setTimeout(r, 200));
+                block = await this.rpcCall('eth_getBlockByNumber', [tag, true]);
+            }
+        }
+        if (!block) {
+            throw new Error(`Block not found: ${blockNumber}`);
+        }
+        return {
+            number: parseInt(block.number, 16),
+            hash: block.hash,
+            parentHash: block.parentHash,
+            timestamp: parseInt(block.timestamp, 16),
+            miner: block.miner,
+            transactions: block.transactions,
+            // GhostDAG specific
+            mergeParents: block.mergeParents || [],
+            blueScore: block.blueScore ? parseInt(block.blueScore, 16) : undefined
+        };
+    }
+    /**
+     * Get DAG statistics
+     */
+    async getDagStats() {
+        const stats = await this.rpcCall('citrate_getDagStats');
+        return {
+            totalBlocks: stats.totalBlocks,
+            blueBlocks: stats.blueBlocks,
+            redBlocks: stats.redBlocks,
+            tipsCount: stats.tipsCount,
+            maxBlueScore: stats.maxBlueScore,
+            currentTips: stats.currentTips || [],
+            height: stats.height,
+            ghostdagParams: stats.ghostdagParams
+        };
+    }
+    /**
+     * Subscribe to new blocks
+     */
+    subscribeToBlocks(callback) {
+        let intervalId;
+        let lastBlockNumber = 0;
+        const checkNewBlock = async () => {
+            try {
+                const block = await this.getBlock('latest');
+                if (block.number > lastBlockNumber) {
+                    lastBlockNumber = block.number;
+                    callback(block);
+                    this.emit('block', block);
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+            }
+        };
+        // Poll for new blocks
+        intervalId = setInterval(checkNewBlock, 2000);
+        checkNewBlock(); // Check immediately
+        // Return unsubscribe function
+        return () => {
+            clearInterval(intervalId);
+        };
+    }
+    /**
+     * Make an RPC call
+     */
+    async rpcCall(method, params = []) {
+        const response = await this.rpcClient.post('', {
+            jsonrpc: '2.0',
+            method,
+            params: Array.isArray(params) ? params : [params],
+            id: Date.now()
+        });
+        if (response.data.error) {
+            throw new Error(response.data.error.message);
+        }
+        return response.data.result;
+    }
+    /**
+     * Wait for a transaction to be mined
+     */
+    async waitForTransaction(txHash, confirmations = 1) {
+        let receipt = null;
+        let attempts = 0;
+        const maxAttempts = 60;
+        while (!receipt && attempts < maxAttempts) {
+            attempts++;
+            try {
+                receipt = await this.rpcCall('eth_getTransactionReceipt', [txHash]);
+                if (receipt && confirmations > 1) {
+                    // Wait for additional confirmations
+                    const currentBlock = await this.getBlock('latest');
+                    const txBlock = parseInt(receipt.blockNumber, 16);
+                    if (currentBlock.number - txBlock < confirmations - 1) {
+                        receipt = null; // Keep waiting
+                    }
+                }
+            }
+            catch (error) {
+                // Transaction not yet mined
+            }
+            if (!receipt) {
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+        }
+        if (!receipt) {
+            throw new Error('Transaction timeout');
+        }
+        return receipt;
+    }
+}
+exports.CitrateSDK = CitrateSDK;

package/dist/types.d.ts

@@ -0,0 +1,63 @@
+export interface CitrateConfig {
+    rpcEndpoint: string;
+    chainId: number;
+    defaultAccount?: string;
+    gasPrice?: string;
+    gasLimit?: number;
+    /** API key for authenticated RPC endpoints. Sent as Authorization: Bearer header. */
+    apiKey?: string;
+}
+export interface ArtifactProviderStatus {
+    provider: string;
+    status: 'pinned' | 'unpinned' | 'unknown';
+}
+export interface ArtifactPinResult {
+    status: 'ok' | 'error';
+    message?: string;
+}
+export interface NetworkInfo {
+    networkId: number;
+    chainId: number;
+    blockNumber: number;
+    syncing: boolean;
+    peerCount: number;
+}
+export interface BlockInfo {
+    number: number;
+    hash: string;
+    parentHash: string;
+    timestamp: number;
+    miner: string;
+    transactions: any[];
+    mergeParents?: string[];
+    blueScore?: number;
+}
+export interface ModelMetadata {
+    name: string;
+    version: string;
+    format: string;
+    description?: string;
+    author?: string;
+    license?: string;
+    tags?: string[];
+}
+export interface ModelInfo {
+    id: string;
+    owner: string;
+    metadata: ModelMetadata;
+    dataHash: string;
+    timestamp: number;
+    permissions: string[];
+}
+export interface InferenceResult {
+    output: any;
+    executionTime: number;
+    proofId?: string;
+    gasUsed?: number;
+}
+export interface ContractInfo {
+    address: string;
+    bytecode?: string;
+    abi?: any[];
+    verified?: boolean;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@citrate/sdk",
+  "version": "0.2.0",
+  "description": "JavaScript/TypeScript SDK for Citrate AI blockchain platform",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && rollup -c",
+    "build:types": "tsc --emitDeclarationOnly",
+    "test": "jest --testPathIgnorePatterns=tests/integration",
+    "test:unit": "jest --testPathIgnorePatterns=tests/integration",
+    "test:integration": "jest --testMatch='**/tests/integration/**/*.test.ts' --runInBand --testTimeout=120000",
+    "test:integration:devnet": "CITRATE_RPC_URL=http://localhost:8545 CITRATE_CHAIN_ID=1337 npm run test:integration",
+    "test:integration:testnet": "CITRATE_RPC_URL=https://testnet-rpc.citrate.ai CITRATE_CHAIN_ID=1338 npm run test:integration",
+    "test:all": "jest --testTimeout=120000",
+    "test:coverage": "jest --coverage --testPathIgnorePatterns=tests/integration",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "format": "prettier --write \"src/**/*.{ts,js,json}\"",
+    "prepublishOnly": "npm run build",
+    "release": "npm run build && npm publish --access public"
+  },
+  "keywords": [
+    "citrate",
+    "blockchain",
+    "ai",
+    "dag",
+    "web3",
+    "machine-learning",
+    "distributed-computing",
+    "cryptocurrency"
+  ],
+  "author": "Citrate Team <developers@citrate.ai>",
+  "license": "MIT",
+  "homepage": "https://citrate.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/citrate-ai/citrate.git",
+    "directory": "sdk/javascript"
+  },
+  "bugs": {
+    "url": "https://github.com/citrate-ai/citrate/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "ethers": "^6.9.0",
+    "events": "^3.3.0",
+    "ws": "^8.14.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.0",
+    "@rollup/plugin-node-resolve": "^15.2.0",
+    "@rollup/plugin-typescript": "^11.1.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.10.0",
+    "@types/ws": "^8.5.0",
+    "@typescript-eslint/eslint-plugin": "^6.14.0",
+    "@typescript-eslint/parser": "^6.14.0",
+    "eslint": "^8.55.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.1.0",
+    "rollup": "^4.6.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.3.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}