irsb-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,436 @@
+// src/client.ts
+import { ethers, Contract } from "ethers";
+
+// src/types.ts
+var SolverStatus = /* @__PURE__ */ ((SolverStatus3) => {
+  SolverStatus3[SolverStatus3["Inactive"] = 0] = "Inactive";
+  SolverStatus3[SolverStatus3["Active"] = 1] = "Active";
+  SolverStatus3[SolverStatus3["Jailed"] = 2] = "Jailed";
+  SolverStatus3[SolverStatus3["Banned"] = 3] = "Banned";
+  return SolverStatus3;
+})(SolverStatus || {});
+var ReceiptStatus = /* @__PURE__ */ ((ReceiptStatus3) => {
+  ReceiptStatus3[ReceiptStatus3["None"] = 0] = "None";
+  ReceiptStatus3[ReceiptStatus3["Posted"] = 1] = "Posted";
+  ReceiptStatus3[ReceiptStatus3["Challenged"] = 2] = "Challenged";
+  ReceiptStatus3[ReceiptStatus3["Finalized"] = 3] = "Finalized";
+  ReceiptStatus3[ReceiptStatus3["Slashed"] = 4] = "Slashed";
+  return ReceiptStatus3;
+})(ReceiptStatus || {});
+var DisputeReason = /* @__PURE__ */ ((DisputeReason3) => {
+  DisputeReason3[DisputeReason3["None"] = 0] = "None";
+  DisputeReason3[DisputeReason3["Timeout"] = 1] = "Timeout";
+  DisputeReason3[DisputeReason3["MinOutViolation"] = 2] = "MinOutViolation";
+  DisputeReason3[DisputeReason3["WrongToken"] = 3] = "WrongToken";
+  DisputeReason3[DisputeReason3["WrongChain"] = 4] = "WrongChain";
+  DisputeReason3[DisputeReason3["WrongRecipient"] = 5] = "WrongRecipient";
+  DisputeReason3[DisputeReason3["ReceiptForgery"] = 6] = "ReceiptForgery";
+  DisputeReason3[DisputeReason3["InvalidSignature"] = 7] = "InvalidSignature";
+  return DisputeReason3;
+})(DisputeReason || {});
+var DisputeStatus = /* @__PURE__ */ ((DisputeStatus2) => {
+  DisputeStatus2[DisputeStatus2["None"] = 0] = "None";
+  DisputeStatus2[DisputeStatus2["Open"] = 1] = "Open";
+  DisputeStatus2[DisputeStatus2["EvidenceSubmitted"] = 2] = "EvidenceSubmitted";
+  DisputeStatus2[DisputeStatus2["Escalated"] = 3] = "Escalated";
+  DisputeStatus2[DisputeStatus2["Resolved"] = 4] = "Resolved";
+  return DisputeStatus2;
+})(DisputeStatus || {});
+var DisputeResolution = /* @__PURE__ */ ((DisputeResolution2) => {
+  DisputeResolution2[DisputeResolution2["None"] = 0] = "None";
+  DisputeResolution2[DisputeResolution2["SolverWins"] = 1] = "SolverWins";
+  DisputeResolution2[DisputeResolution2["ChallengerWins"] = 2] = "ChallengerWins";
+  DisputeResolution2[DisputeResolution2["Split"] = 3] = "Split";
+  DisputeResolution2[DisputeResolution2["Timeout"] = 4] = "Timeout";
+  return DisputeResolution2;
+})(DisputeResolution || {});
+var CHAIN_CONFIGS = {
+  sepolia: {
+    chainId: 11155111,
+    rpcUrl: "https://rpc.sepolia.org",
+    solverRegistry: "0xB6ab964832808E49635fF82D1996D6a888ecB745",
+    intentReceiptHub: "0xD66A1e880AA3939CA066a9EA1dD37ad3d01D977c",
+    disputeModule: "0x144DfEcB57B08471e2A75E78fc0d2A74A89DB79D"
+  }
+  // mainnet: { ... } // Add after mainnet deployment
+};
+var CONSTANTS = {
+  MINIMUM_BOND: BigInt("100000000000000000"),
+  // 0.1 ETH
+  WITHDRAWAL_COOLDOWN: BigInt(7 * 24 * 60 * 60),
+  // 7 days
+  MAX_JAILS: 3,
+  CHALLENGE_WINDOW: BigInt(60 * 60),
+  // 1 hour
+  CHALLENGER_BOND_BPS: 1e3,
+  // 10%
+  EVIDENCE_WINDOW: BigInt(24 * 60 * 60),
+  // 24 hours
+  ARBITRATION_TIMEOUT: BigInt(7 * 24 * 60 * 60)
+  // 7 days
+};
+
+// src/contracts/abis.ts
+var SOLVER_REGISTRY_ABI = [
+  // Read functions
+  "function MINIMUM_BOND() view returns (uint256)",
+  "function WITHDRAWAL_COOLDOWN() view returns (uint64)",
+  "function MAX_JAILS() view returns (uint8)",
+  "function solvers(address) view returns (uint256 bondAmount, uint256 lockedAmount, uint256 reputation, uint64 registrationTime, uint64 lastActiveTime, uint64 totalIntents, uint64 successfulIntents, uint8 jailCount, uint8 status, uint256 pendingWithdrawal, uint64 withdrawalRequestTime)",
+  "function isActiveSolver(address solver) view returns (bool)",
+  "function getSolverBond(address solver) view returns (uint256)",
+  "function getAvailableBond(address solver) view returns (uint256)",
+  "function owner() view returns (address)",
+  // Write functions
+  "function register() payable",
+  "function depositBond() payable",
+  "function requestWithdrawal(uint256 amount)",
+  "function cancelWithdrawal()",
+  "function executeWithdrawal()",
+  "function unjail() payable",
+  // Events
+  "event SolverRegistered(address indexed solver, uint256 bondAmount)",
+  "event BondDeposited(address indexed solver, uint256 amount, uint256 newTotal)",
+  "event WithdrawalRequested(address indexed solver, uint256 amount)",
+  "event WithdrawalExecuted(address indexed solver, uint256 amount)",
+  "event WithdrawalCancelled(address indexed solver)",
+  "event SolverSlashed(address indexed solver, uint256 amount, bytes32 reason)",
+  "event SolverJailed(address indexed solver, uint8 jailCount)",
+  "event SolverUnjailed(address indexed solver)",
+  "event SolverBanned(address indexed solver)"
+];
+var INTENT_RECEIPT_HUB_ABI = [
+  // Read functions
+  "function challengeWindow() view returns (uint64)",
+  "function challengerBondBps() view returns (uint16)",
+  "function receipts(bytes32) view returns (address solver, bytes32 intentHash, bytes32 constraintsHash, bytes32 outcomeHash, bytes32 evidenceHash, uint64 postedAt, uint64 deadline, bytes solverSig, uint8 status)",
+  "function challenges(bytes32) view returns (address challenger, uint8 reason, uint256 bond, uint64 timestamp)",
+  "function getReceipt(bytes32 intentHash) view returns (tuple(address solver, bytes32 intentHash, bytes32 constraintsHash, bytes32 outcomeHash, bytes32 evidenceHash, uint64 postedAt, uint64 deadline, bytes solverSig, uint8 status))",
+  "function getChallenge(bytes32 intentHash) view returns (tuple(address challenger, uint8 reason, uint256 bond, uint64 timestamp))",
+  "function solverRegistry() view returns (address)",
+  // Write functions
+  "function postReceipt(bytes32 intentHash, bytes32 constraintsHash, bytes32 outcomeHash, bytes32 evidenceHash, uint64 deadline, bytes solverSig)",
+  "function challengeReceipt(bytes32 intentHash, uint8 reason) payable",
+  "function finalizeReceipt(bytes32 intentHash)",
+  "function resolveDeterministic(bytes32 intentHash, bytes settlementProof)",
+  // Events
+  "event ReceiptPosted(bytes32 indexed intentHash, address indexed solver, uint64 deadline)",
+  "event ReceiptChallenged(bytes32 indexed intentHash, address indexed challenger, uint8 reason, uint256 bond)",
+  "event ReceiptFinalized(bytes32 indexed intentHash)",
+  "event ReceiptSlashed(bytes32 indexed intentHash, address indexed solver, uint256 slashAmount)",
+  "event ChallengeResolved(bytes32 indexed intentHash, bool solverWins)"
+];
+var DISPUTE_MODULE_ABI = [
+  // Read functions
+  "function evidenceWindow() view returns (uint64)",
+  "function arbitrationTimeout() view returns (uint64)",
+  "function arbitrator() view returns (address)",
+  "function disputes(bytes32) view returns (bytes32 intentHash, address challenger, address solver, uint8 reason, bytes32 solverEvidence, bytes32 challengerEvidence, uint64 createdAt, uint64 evidenceDeadline, uint8 status, uint8 resolution)",
+  "function getDispute(bytes32 intentHash) view returns (tuple(bytes32 intentHash, address challenger, address solver, uint8 reason, bytes32 solverEvidence, bytes32 challengerEvidence, uint64 createdAt, uint64 evidenceDeadline, uint8 status, uint8 resolution))",
+  // Write functions
+  "function submitEvidence(bytes32 intentHash, bytes32 evidenceHash)",
+  "function escalateToArbitration(bytes32 intentHash)",
+  "function resolveArbitration(bytes32 intentHash, uint8 resolution, uint16 solverShareBps)",
+  "function resolveByTimeout(bytes32 intentHash)",
+  // Events
+  "event DisputeCreated(bytes32 indexed intentHash, address indexed challenger, address indexed solver, uint8 reason)",
+  "event EvidenceSubmitted(bytes32 indexed intentHash, address indexed submitter, bytes32 evidenceHash)",
+  "event DisputeEscalated(bytes32 indexed intentHash)",
+  "event DisputeResolved(bytes32 indexed intentHash, uint8 resolution)"
+];
+
+// src/client.ts
+var IRSBClient = class {
+  config;
+  provider;
+  signer;
+  solverRegistry;
+  intentReceiptHub;
+  disputeModule;
+  constructor(options) {
+    if (typeof options.chain === "string") {
+      const config = CHAIN_CONFIGS[options.chain];
+      if (!config) {
+        throw new Error(`Unknown chain: ${options.chain}. Available: ${Object.keys(CHAIN_CONFIGS).join(", ")}`);
+      }
+      this.config = config;
+    } else {
+      this.config = options.chain;
+    }
+    if (options.signer) {
+      this.signer = options.signer;
+      this.provider = options.signer.provider;
+    } else if (options.provider) {
+      this.provider = options.provider;
+    } else {
+      this.provider = new ethers.JsonRpcProvider(this.config.rpcUrl);
+    }
+    const signerOrProvider = this.signer || this.provider;
+    this.solverRegistry = new Contract(
+      this.config.solverRegistry,
+      SOLVER_REGISTRY_ABI,
+      signerOrProvider
+    );
+    this.intentReceiptHub = new Contract(
+      this.config.intentReceiptHub,
+      INTENT_RECEIPT_HUB_ABI,
+      signerOrProvider
+    );
+    this.disputeModule = new Contract(
+      this.config.disputeModule,
+      DISPUTE_MODULE_ABI,
+      signerOrProvider
+    );
+  }
+  // ============ Solver Registry - Read ============
+  /**
+   * Get solver information
+   */
+  async getSolver(address) {
+    const data = await this.solverRegistry.solvers(address);
+    return {
+      bondAmount: data.bondAmount,
+      lockedAmount: data.lockedAmount,
+      reputation: data.reputation,
+      registrationTime: data.registrationTime,
+      lastActiveTime: data.lastActiveTime,
+      totalIntents: data.totalIntents,
+      successfulIntents: data.successfulIntents,
+      jailCount: Number(data.jailCount),
+      status: Number(data.status),
+      pendingWithdrawal: data.pendingWithdrawal,
+      withdrawalRequestTime: data.withdrawalRequestTime
+    };
+  }
+  /**
+   * Check if address is an active solver
+   */
+  async isActiveSolver(address) {
+    return this.solverRegistry.isActiveSolver(address);
+  }
+  /**
+   * Get solver's total bond amount
+   */
+  async getSolverBond(address) {
+    return this.solverRegistry.getSolverBond(address);
+  }
+  /**
+   * Get solver's available (unlocked) bond
+   */
+  async getAvailableBond(address) {
+    return this.solverRegistry.getAvailableBond(address);
+  }
+  /**
+   * Get minimum bond required for registration
+   */
+  async getMinimumBond() {
+    return this.solverRegistry.MINIMUM_BOND();
+  }
+  // ============ Solver Registry - Write ============
+  /**
+   * Register as a solver with initial bond
+   * @param options.value - ETH to deposit as bond (must be >= MINIMUM_BOND)
+   */
+  async register(options) {
+    this.requireSigner();
+    return this.solverRegistry.register({ value: options.value });
+  }
+  /**
+   * Deposit additional bond
+   * @param options.value - ETH to deposit
+   */
+  async depositBond(options) {
+    this.requireSigner();
+    return this.solverRegistry.depositBond({ value: options.value });
+  }
+  /**
+   * Request withdrawal of bond (starts cooldown)
+   * @param amount - Amount to withdraw
+   */
+  async requestWithdrawal(amount) {
+    this.requireSigner();
+    return this.solverRegistry.requestWithdrawal(amount);
+  }
+  /**
+   * Cancel pending withdrawal
+   */
+  async cancelWithdrawal() {
+    this.requireSigner();
+    return this.solverRegistry.cancelWithdrawal();
+  }
+  /**
+   * Execute withdrawal after cooldown
+   */
+  async executeWithdrawal() {
+    this.requireSigner();
+    return this.solverRegistry.executeWithdrawal();
+  }
+  /**
+   * Unjail solver by paying penalty
+   * @param options.value - Unjail penalty amount
+   */
+  async unjail(options) {
+    this.requireSigner();
+    return this.solverRegistry.unjail({ value: options.value });
+  }
+  // ============ Intent Receipt Hub - Read ============
+  /**
+   * Get receipt by intent hash
+   */
+  async getReceipt(intentHash) {
+    try {
+      const data = await this.intentReceiptHub.getReceipt(intentHash);
+      if (data.solver === ethers.ZeroAddress) return null;
+      return {
+        solver: data.solver,
+        intentHash: data.intentHash,
+        constraintsHash: data.constraintsHash,
+        outcomeHash: data.outcomeHash,
+        evidenceHash: data.evidenceHash,
+        postedAt: data.postedAt,
+        deadline: data.deadline,
+        solverSig: data.solverSig,
+        status: Number(data.status)
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get challenge for an intent
+   */
+  async getChallenge(intentHash) {
+    try {
+      const data = await this.intentReceiptHub.getChallenge(intentHash);
+      if (data.challenger === ethers.ZeroAddress) return null;
+      return {
+        challenger: data.challenger,
+        reason: Number(data.reason),
+        bond: data.bond,
+        timestamp: data.timestamp
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get challenge window duration
+   */
+  async getChallengeWindow() {
+    return this.intentReceiptHub.challengeWindow();
+  }
+  // ============ Intent Receipt Hub - Write ============
+  /**
+   * Post a receipt for an executed intent
+   */
+  async postReceipt(params) {
+    this.requireSigner();
+    return this.intentReceiptHub.postReceipt(
+      params.intentHash,
+      params.constraintsHash,
+      params.outcomeHash,
+      params.evidenceHash,
+      params.deadline,
+      params.solverSig
+    );
+  }
+  /**
+   * Challenge a receipt
+   * @param intentHash - Hash of the intent to challenge
+   * @param reason - Dispute reason code
+   * @param options.value - Challenger bond (must meet minimum)
+   */
+  async challengeReceipt(intentHash, reason, options) {
+    this.requireSigner();
+    return this.intentReceiptHub.challengeReceipt(intentHash, reason, {
+      value: options.value
+    });
+  }
+  /**
+   * Finalize a receipt after challenge window
+   */
+  async finalizeReceipt(intentHash) {
+    this.requireSigner();
+    return this.intentReceiptHub.finalizeReceipt(intentHash);
+  }
+  // ============ Dispute Module - Read ============
+  /**
+   * Get dispute details
+   */
+  async getDispute(intentHash) {
+    try {
+      const data = await this.disputeModule.getDispute(intentHash);
+      if (data.challenger === ethers.ZeroAddress) return null;
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  // ============ Dispute Module - Write ============
+  /**
+   * Submit evidence for a dispute
+   */
+  async submitEvidence(intentHash, evidenceHash) {
+    this.requireSigner();
+    return this.disputeModule.submitEvidence(intentHash, evidenceHash);
+  }
+  /**
+   * Escalate dispute to arbitration
+   */
+  async escalateToArbitration(intentHash) {
+    this.requireSigner();
+    return this.disputeModule.escalateToArbitration(intentHash);
+  }
+  // ============ Utilities ============
+  /**
+   * Create a signed receipt for posting
+   */
+  async signReceipt(params) {
+    this.requireSigner();
+    const message = ethers.solidityPackedKeccak256(
+      ["bytes32", "bytes32", "bytes32", "bytes32", "uint64"],
+      [
+        params.intentHash,
+        params.constraintsHash,
+        params.outcomeHash,
+        params.evidenceHash,
+        params.deadline
+      ]
+    );
+    return this.signer.signMessage(ethers.getBytes(message));
+  }
+  /**
+   * Calculate required challenger bond for a slash amount
+   */
+  calculateChallengerBond(slashAmount) {
+    return slashAmount * BigInt(CONSTANTS.CHALLENGER_BOND_BPS) / BigInt(1e4);
+  }
+  /**
+   * Get contract addresses
+   */
+  getAddresses() {
+    return {
+      solverRegistry: this.config.solverRegistry,
+      intentReceiptHub: this.config.intentReceiptHub,
+      disputeModule: this.config.disputeModule
+    };
+  }
+  requireSigner() {
+    if (!this.signer) {
+      throw new Error("Signer required for write operations");
+    }
+  }
+};
+export {
+  CHAIN_CONFIGS,
+  CONSTANTS,
+  DISPUTE_MODULE_ABI,
+  DisputeReason,
+  DisputeResolution,
+  DisputeStatus,
+  INTENT_RECEIPT_HUB_ABI,
+  IRSBClient,
+  ReceiptStatus,
+  SOLVER_REGISTRY_ABI,
+  SolverStatus
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "irsb-sdk",
+  "version": "0.1.0",
+  "description": "SDK for IRSB Protocol - Intent Receipts & Solver Bonds",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "eslint src/",
+    "test": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ethereum",
+    "intent",
+    "solver",
+    "erc-7683",
+    "defi",
+    "accountability"
+  ],
+  "author": "Intent Solutions IO <jeremy@intentsolutions.io>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/intent-solutions-io/irsb-protocol.git",
+    "directory": "sdk"
+  },
+  "homepage": "https://irsb-protocol.web.app",
+  "dependencies": {
+    "ethers": "^6.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}