@kudo-dev/sdk 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,2520 @@
+// src/client.ts
+import {
+  createPublicClient,
+  decodeEventLog,
+  encodeFunctionData,
+  formatUnits,
+  getAbiItem,
+  hexToString,
+  http,
+  parseEventLogs,
+  stringToHex,
+  zeroAddress
+} from "viem";
+
+// src/abi/kudo.ts
+var kudoAbi = [
+  {
+    type: "constructor",
+    inputs: [
+      {
+        name: "admin",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "initialDelay",
+        type: "uint48",
+        internalType: "uint48"
+      },
+      {
+        name: "mintAccessControl",
+        type: "bool",
+        internalType: "bool"
+      },
+      {
+        name: "askCooldown",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "AGENT_ROLE",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "DEFAULT_ADMIN_ROLE",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "EVALUATOR_CONTRACT_ROLE",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "acceptDefaultAdminTransfer",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [
+      {
+        name: "owner",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "beginDefaultAdminTransfer",
+    inputs: [
+      {
+        name: "newAdmin",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "cancelDefaultAdminTransfer",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "changeDefaultAdminDelay",
+    inputs: [
+      {
+        name: "newDelay",
+        type: "uint48",
+        internalType: "uint48"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "defaultAdmin",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "defaultAdminDelay",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint48",
+        internalType: "uint48"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "defaultAdminDelayIncreaseWait",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint48",
+        internalType: "uint48"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAgentCovenantIds",
+    inputs: [
+      {
+        name: "agent",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256[]",
+        internalType: "uint256[]"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAgentCovenantsData",
+    inputs: [
+      {
+        name: "agent",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct Kudo.CovenantData[]",
+        components: [
+          {
+            name: "agentWallet",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "agentId",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "status",
+            type: "uint8",
+            internalType: "enum Kudo.CovenantStatus"
+          },
+          {
+            name: "nftType",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "ask",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "covenantPromise",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "promiseDetail",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "askSettlementData",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "askSettledAt",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "promiseSettlementData",
+            type: "string",
+            internalType: "string"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getApproved",
+    inputs: [
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAskCooldown",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getCovenant",
+    inputs: [
+      {
+        name: "nftId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct Kudo.CovenantData",
+        components: [
+          {
+            name: "agentWallet",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "agentId",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "status",
+            type: "uint8",
+            internalType: "enum Kudo.CovenantStatus"
+          },
+          {
+            name: "nftType",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "ask",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "covenantPromise",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "promiseDetail",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "askSettlementData",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "askSettledAt",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "promiseSettlementData",
+            type: "string",
+            internalType: "string"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getCovenantDetails",
+    inputs: [
+      {
+        name: "nftId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct Kudo.CovenantDetails",
+        components: [
+          {
+            name: "nftId",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "owner",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "covenantData",
+            type: "tuple",
+            internalType: "struct Kudo.CovenantData",
+            components: [
+              {
+                name: "agentWallet",
+                type: "address",
+                internalType: "address"
+              },
+              {
+                name: "agentId",
+                type: "uint256",
+                internalType: "uint256"
+              },
+              {
+                name: "status",
+                type: "uint8",
+                internalType: "enum Kudo.CovenantStatus"
+              },
+              {
+                name: "nftType",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "ask",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "covenantPromise",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "promiseDetail",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "askSettlementData",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "askSettledAt",
+                type: "uint256",
+                internalType: "uint256"
+              },
+              {
+                name: "promiseSettlementData",
+                type: "string",
+                internalType: "string"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getCovenantsDetails",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct Kudo.CovenantDetails[]",
+        components: [
+          {
+            name: "nftId",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "owner",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "covenantData",
+            type: "tuple",
+            internalType: "struct Kudo.CovenantData",
+            components: [
+              {
+                name: "agentWallet",
+                type: "address",
+                internalType: "address"
+              },
+              {
+                name: "agentId",
+                type: "uint256",
+                internalType: "uint256"
+              },
+              {
+                name: "status",
+                type: "uint8",
+                internalType: "enum Kudo.CovenantStatus"
+              },
+              {
+                name: "nftType",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "ask",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "covenantPromise",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "promiseDetail",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "askSettlementData",
+                type: "string",
+                internalType: "string"
+              },
+              {
+                name: "askSettledAt",
+                type: "uint256",
+                internalType: "uint256"
+              },
+              {
+                name: "promiseSettlementData",
+                type: "string",
+                internalType: "string"
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getCovenantsWithStatus",
+    inputs: [
+      {
+        name: "status",
+        type: "uint8",
+        internalType: "enum Kudo.CovenantStatus"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct Kudo.CovenantData[]",
+        components: [
+          {
+            name: "agentWallet",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "agentId",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "status",
+            type: "uint8",
+            internalType: "enum Kudo.CovenantStatus"
+          },
+          {
+            name: "nftType",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "ask",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "covenantPromise",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "promiseDetail",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "askSettlementData",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "askSettledAt",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "promiseSettlementData",
+            type: "string",
+            internalType: "string"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getRoleAdmin",
+    inputs: [
+      {
+        name: "role",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getTotalCovenants",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "grantRole",
+    inputs: [
+      {
+        name: "role",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "hasRole",
+    inputs: [
+      {
+        name: "role",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isApprovedForAll",
+    inputs: [
+      {
+        name: "owner",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "operator",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isAskSettled",
+    inputs: [
+      {
+        name: "nftId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isMintAccessControlEnabled",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "mintCovenant",
+    inputs: [
+      {
+        name: "agentId",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "covenantPromise",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "ask",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "nftType",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "name",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ownerOf",
+    inputs: [
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pendingDefaultAdmin",
+    inputs: [],
+    outputs: [
+      {
+        name: "newAdmin",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "schedule",
+        type: "uint48",
+        internalType: "uint48"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pendingDefaultAdminDelay",
+    inputs: [],
+    outputs: [
+      {
+        name: "newDelay",
+        type: "uint48",
+        internalType: "uint48"
+      },
+      {
+        name: "schedule",
+        type: "uint48",
+        internalType: "uint48"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "renounceRole",
+    inputs: [
+      {
+        name: "role",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "revokeRole",
+    inputs: [
+      {
+        name: "role",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "rollbackDefaultAdminDelay",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "safeTransferFrom",
+    inputs: [
+      {
+        name: "from",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "safeTransferFrom",
+    inputs: [
+      {
+        name: "from",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "data",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setApprovalForAll",
+    inputs: [
+      {
+        name: "operator",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "approved",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setAskCooldown",
+    inputs: [
+      {
+        name: "cooldownSeconds",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setAskSettlementData",
+    inputs: [
+      {
+        name: "nftId",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "settlementData",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "promiseDetail",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setCovenantStatus",
+    inputs: [
+      {
+        name: "nftId",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "status",
+        type: "uint8",
+        internalType: "enum Kudo.CovenantStatus"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setMintAccessControl",
+    inputs: [
+      {
+        name: "enabled",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setPromiseSettlementData",
+    inputs: [
+      {
+        name: "nftId",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "data",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "supportsInterface",
+    inputs: [
+      {
+        name: "interfaceId",
+        type: "bytes4",
+        internalType: "bytes4"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "symbol",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tokenURI",
+    inputs: [
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    inputs: [
+      {
+        name: "from",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "to",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      {
+        name: "owner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "approved",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "tokenId",
+        type: "uint256",
+        indexed: true,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "ApprovalForAll",
+    inputs: [
+      {
+        name: "owner",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "operator",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "approved",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AskCooldownSet",
+    inputs: [
+      {
+        name: "cooldownSeconds",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AskSettlementSet",
+    inputs: [
+      {
+        name: "nftId",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "askSettlement",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      },
+      {
+        name: "promiseDetails",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "CovenantMinted",
+    inputs: [
+      {
+        name: "nftId",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "agent",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "nftType",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      },
+      {
+        name: "covenantPromise",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      },
+      {
+        name: "ask",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "CovenantPromiseSet",
+    inputs: [
+      {
+        name: "nftId",
+        type: "uint256",
+        indexed: true,
+        internalType: "uint256"
+      },
+      {
+        name: "status",
+        type: "uint8",
+        indexed: false,
+        internalType: "enum Kudo.CovenantStatus"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "DefaultAdminDelayChangeCanceled",
+    inputs: [],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "DefaultAdminDelayChangeScheduled",
+    inputs: [
+      {
+        name: "newDelay",
+        type: "uint48",
+        indexed: false,
+        internalType: "uint48"
+      },
+      {
+        name: "effectSchedule",
+        type: "uint48",
+        indexed: false,
+        internalType: "uint48"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "DefaultAdminTransferCanceled",
+    inputs: [],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "DefaultAdminTransferScheduled",
+    inputs: [
+      {
+        name: "newAdmin",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "acceptSchedule",
+        type: "uint48",
+        indexed: false,
+        internalType: "uint48"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "MintAccessControlSet",
+    inputs: [
+      {
+        name: "enabled",
+        type: "bool",
+        indexed: false,
+        internalType: "bool"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "PromiseSettlementSet",
+    inputs: [
+      {
+        name: "nftId",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "promiseSettlement",
+        type: "string",
+        indexed: false,
+        internalType: "string"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "RoleAdminChanged",
+    inputs: [
+      {
+        name: "role",
+        type: "bytes32",
+        indexed: true,
+        internalType: "bytes32"
+      },
+      {
+        name: "previousAdminRole",
+        type: "bytes32",
+        indexed: true,
+        internalType: "bytes32"
+      },
+      {
+        name: "newAdminRole",
+        type: "bytes32",
+        indexed: true,
+        internalType: "bytes32"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "RoleGranted",
+    inputs: [
+      {
+        name: "role",
+        type: "bytes32",
+        indexed: true,
+        internalType: "bytes32"
+      },
+      {
+        name: "account",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "sender",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "RoleRevoked",
+    inputs: [
+      {
+        name: "role",
+        type: "bytes32",
+        indexed: true,
+        internalType: "bytes32"
+      },
+      {
+        name: "account",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "sender",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      {
+        name: "from",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "to",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "tokenId",
+        type: "uint256",
+        indexed: true,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "AccessControlBadConfirmation",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "AccessControlEnforcedDefaultAdminDelay",
+    inputs: [
+      {
+        name: "schedule",
+        type: "uint48",
+        internalType: "uint48"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "AccessControlEnforcedDefaultAdminRules",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "AccessControlInvalidDefaultAdmin",
+    inputs: [
+      {
+        name: "defaultAdmin",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "AccessControlUnauthorizedAccount",
+    inputs: [
+      {
+        name: "account",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "neededRole",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "AccessForbidden",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "CovenantNotFound",
+    inputs: []
+  },
+  {
+    type: "error",
+    name: "ERC721IncorrectOwner",
+    inputs: [
+      {
+        name: "sender",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "owner",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC721InsufficientApproval",
+    inputs: [
+      {
+        name: "operator",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC721InvalidApprover",
+    inputs: [
+      {
+        name: "approver",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC721InvalidOperator",
+    inputs: [
+      {
+        name: "operator",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC721InvalidOwner",
+    inputs: [
+      {
+        name: "owner",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC721InvalidReceiver",
+    inputs: [
+      {
+        name: "receiver",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC721InvalidSender",
+    inputs: [
+      {
+        name: "sender",
+        type: "address",
+        internalType: "address"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "ERC721NonexistentToken",
+    inputs: [
+      {
+        name: "tokenId",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ]
+  },
+  {
+    type: "error",
+    name: "SafeCastOverflowedUintDowncast",
+    inputs: [
+      {
+        name: "bits",
+        type: "uint8",
+        internalType: "uint8"
+      },
+      {
+        name: "value",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ]
+  }
+];
+
+// src/abi/registries.ts
+var identityRegistryAbi = [
+  {
+    type: "function",
+    name: "register",
+    inputs: [
+      { name: "agentURI", type: "string" },
+      {
+        name: "metadata",
+        type: "tuple[]",
+        components: [
+          { name: "metadataKey", type: "string" },
+          { name: "metadataValue", type: "bytes" }
+        ]
+      }
+    ],
+    outputs: [{ name: "agentId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setMetadata",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "key", type: "string" },
+      { name: "value", type: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getMetadata",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "key", type: "string" }
+    ],
+    outputs: [{ name: "", type: "bytes" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ownerOf",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tokenURI",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "Registered",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "agentURI", type: "string", indexed: false },
+      { name: "owner", type: "address", indexed: true }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "tokenId", type: "uint256", indexed: true }
+    ],
+    anonymous: false
+  }
+];
+var reputationRegistryAbi = [
+  {
+    type: "function",
+    name: "getClients",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "address[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getSummary",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddresses", type: "address[]" },
+      { name: "tag1", type: "string" },
+      { name: "tag2", type: "string" }
+    ],
+    outputs: [
+      { name: "count", type: "uint64" },
+      { name: "summaryValue", type: "int128" },
+      { name: "summaryValueDecimals", type: "uint8" }
+    ],
+    stateMutability: "view"
+  }
+];
+
+// src/errors.ts
+import { BaseError, ContractFunctionRevertedError } from "viem";
+var REVERTS = {
+  "0x468381ac": {
+    name: "NotAuthorizedForAgent",
+    hint: "The sending wallet does not control that ERC-8004 agent id. Mint under an id this wallet owns (see findAgentIds / registerAgent)."
+  },
+  "0xef67f5d8": {
+    name: "AccessForbidden",
+    hint: "The caller is not allowed: on mint the wallet lacks AGENT_ROLE (only when mint access control is on); on linkProof the caller is not the covenant's agentWallet."
+  },
+  "0xe2517d3f": {
+    name: "AccessControlUnauthorizedAccount",
+    hint: "An onlyRole function refused this account. Closing a covenant is the Evaluator's job, not the agent's."
+  },
+  "0x613970e0": {
+    name: "InvalidParameter",
+    hint: "The contract rejected an argument, such as an empty string or a zero address."
+  },
+  "0x356680b7": {
+    name: "InsufficientFunds",
+    hint: "The wallet does not hold enough of the token for this transfer."
+  },
+  "0xe450d38c": {
+    name: "ERC20InsufficientBalance",
+    hint: "The wallet does not hold enough of this token for the transfer."
+  },
+  "0xf480469b": {
+    name: "ConditionIsNotMet",
+    hint: "This selector belongs to an older Kudo deployment. You are probably pointing at the wrong contract."
+  }
+};
+var KudoError = class extends Error {
+  code;
+  revert;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "KudoError";
+    this.code = code;
+    this.revert = options.revert;
+  }
+};
+function toKudoError(error, action) {
+  if (error instanceof KudoError) return error;
+  let selector;
+  let name;
+  if (error instanceof BaseError) {
+    const reverted = error.walk((e) => e instanceof ContractFunctionRevertedError);
+    if (reverted instanceof ContractFunctionRevertedError) {
+      name = reverted.data?.errorName;
+      selector = reverted.signature ?? reverted.raw?.slice(0, 10);
+    } else {
+      const raw = error.walk((e) => typeof e.data === "string");
+      if (raw?.data && /^0x[0-9a-fA-F]{8}/.test(raw.data)) selector = raw.data.slice(0, 10);
+    }
+  }
+  const text = error instanceof Error ? error.message : String(error);
+  if (!selector) {
+    selector = Object.keys(REVERTS).find((s) => text.toLowerCase().includes(s));
+  }
+  const known = selector ? REVERTS[selector.toLowerCase()] : void 0;
+  name = name ?? known?.name;
+  if (name || selector) {
+    return new KudoError(
+      "REVERTED",
+      `${action} reverted${name ? ` with ${name}` : ""}${known ? `: ${known.hint}` : "."}`,
+      { cause: error, revert: { selector, name, hint: known?.hint } }
+    );
+  }
+  const short = error instanceof BaseError ? error.shortMessage : text;
+  return new KudoError("TX_FAILED", `${action} failed: ${short}`, { cause: error });
+}
+
+// src/networks.ts
+import { defineChain } from "viem";
+var robinhood = defineChain({
+  id: 4663,
+  name: "Robinhood Chain",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: { default: { http: ["https://rpc.mainnet.chain.robinhood.com"] } },
+  blockExplorers: {
+    default: { name: "Blockscout", url: "https://robinhoodchain.blockscout.com" }
+  },
+  contracts: {
+    multicall3: { address: "0xca11bde05977b3631167028862be2a173976ca11" }
+  }
+});
+var networks = {
+  /** Robinhood Chain mainnet, where app.kudo.archi reads and writes. */
+  robinhood: {
+    key: "robinhood",
+    chain: robinhood,
+    kudo: "0x1930D0FEaB14b024353bF22adE03Db989aD640C7",
+    usdg: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+    reputationRegistry: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63",
+    statuses: ["MINTED", "IN_PROGRESS", "COMPLETED", "FAILED"],
+    covenantUrl: "https://app.kudo.archi/share/{id}",
+    explorerUrl: "https://robinhoodchain.blockscout.com",
+    maxLogRange: 10000000n
+  }
+};
+function resolveNetwork(network = "robinhood", overrides = {}) {
+  const base = typeof network === "string" ? networks[network] : network;
+  if (!base) {
+    throw new Error(
+      `Unknown Kudo network "${String(network)}". Known: ${Object.keys(networks).join(", ")}`
+    );
+  }
+  return { ...base, ...overrides };
+}
+
+// src/types.ts
+var COVENANT_TYPES = ["LOAN", "INVOICE", "ADVANCE"];
+var COVENANT_STAGES = ["ask-open", "ask-claimed", "promise-due", "awaiting-evaluation", "completed", "failed"];
+
+// src/client.ts
+var toBigInt = (value, what) => {
+  try {
+    const n = BigInt(value);
+    if (n < 0n) throw new Error();
+    return n;
+  } catch {
+    throw new KudoError("INVALID_INPUT", `${what} must be a non-negative integer, got "${value}".`);
+  }
+};
+var Kudo = class {
+  network;
+  publicClient;
+  walletClient;
+  constructor(options = {}) {
+    this.network = resolveNetwork(options.network, options.overrides);
+    this.publicClient = options.publicClient ?? createPublicClient({
+      chain: this.network.chain,
+      transport: http(options.rpcUrl ?? this.network.chain.rpcUrls.default.http[0])
+    });
+    this.walletClient = options.walletClient;
+  }
+  /** The connected account's address, if a wallet client was given. */
+  get address() {
+    return this.walletClient?.account?.address;
+  }
+  get chainId() {
+    return this.network.chain.id;
+  }
+  /* ------------------------------------------------------------------ reads */
+  /** One covenant by id. */
+  async getCovenant(id) {
+    const nftId = toBigInt(id, "Covenant id");
+    try {
+      const raw = await this.publicClient.readContract({
+        address: this.network.kudo,
+        abi: kudoAbi,
+        functionName: "getCovenant",
+        args: [nftId]
+      });
+      if (raw.agentWallet === zeroAddress) {
+        throw new KudoError("NOT_FOUND", `Covenant ${nftId} does not exist.`);
+      }
+      return this.toCovenant(nftId, raw);
+    } catch (error) {
+      if (error instanceof KudoError) throw error;
+      throw new KudoError("NOT_FOUND", `Covenant ${nftId} could not be read.`, { cause: error });
+    }
+  }
+  /** Every covenant on the contract, newest first, filtered. */
+  async listCovenants(filter = {}) {
+    const details = await this.publicClient.readContract({
+      address: this.network.kudo,
+      abi: kudoAbi,
+      functionName: "getCovenantsDetails"
+    });
+    const stages = filter.stage ? new Set(Array.isArray(filter.stage) ? filter.stage : [filter.stage]) : void 0;
+    const agentId = filter.agentId !== void 0 ? toBigInt(filter.agentId, "agentId") : void 0;
+    const wallet = filter.agentWallet?.toLowerCase();
+    const type = filter.type?.toUpperCase();
+    const out = details.map((d) => this.toCovenant(d.nftId, d.covenantData, d.owner)).filter(
+      (c) => (!stages || stages.has(c.stage)) && (agentId === void 0 || c.agentId === agentId) && (!wallet || c.agentWallet.toLowerCase() === wallet) && (!type || c.type.toUpperCase() === type)
+    ).sort((a, b) => a.id < b.id ? 1 : -1);
+    return filter.limit ? out.slice(0, filter.limit) : out;
+  }
+  /**
+   * Covenants whose ask nobody has met yet: work you can perform and be paid
+   * (or repaid) for. First to meet the ask takes it.
+   */
+  async listOpenAsks(filter = {}) {
+    const exclude = (filter.excludeWallet ?? this.address)?.toLowerCase();
+    const open = await this.listCovenants({
+      stage: "ask-open",
+      type: filter.type,
+      agentId: filter.agentId
+    });
+    const mine = (c) => !!exclude && c.agentWallet.toLowerCase() === exclude;
+    const out = open.filter((c) => !mine(c));
+    return filter.limit ? out.slice(0, filter.limit) : out;
+  }
+  /** Identity facts for one ERC-8004 id. */
+  async getAgent(agentId) {
+    const id = toBigInt(agentId, "agentId");
+    const registry = this.network.identityRegistry;
+    let owner;
+    try {
+      owner = await this.publicClient.readContract({
+        address: registry,
+        abi: identityRegistryAbi,
+        functionName: "ownerOf",
+        args: [id]
+      });
+    } catch (error) {
+      throw new KudoError("NOT_FOUND", `Agent ${id} is not registered on ${this.network.chain.name}.`, {
+        cause: error
+      });
+    }
+    const meta = async (key) => {
+      try {
+        const bytes = await this.publicClient.readContract({
+          address: registry,
+          abi: identityRegistryAbi,
+          functionName: "getMetadata",
+          args: [id, key]
+        });
+        return bytes && bytes !== "0x" ? hexToString(bytes) : null;
+      } catch {
+        return null;
+      }
+    };
+    const uri = await this.publicClient.readContract({ address: registry, abi: identityRegistryAbi, functionName: "tokenURI", args: [id] }).then((u) => u || null).catch(() => null);
+    const [name, teeId] = await Promise.all([meta("name"), meta("teeId")]);
+    return { agentId: id, owner, name, teeId, uri };
+  }
+  /** An agent's identity plus its kept-vs-broken covenant record. */
+  async agentRecord(agentId) {
+    const info = await this.getAgent(agentId);
+    const all = await this.listCovenants({ agentId: info.agentId });
+    const covenants = all.filter((c) => c.agentWallet.toLowerCase() === info.owner.toLowerCase());
+    const count = (stage) => covenants.filter((c) => c.stage === stage).length;
+    return {
+      ...info,
+      covenants: {
+        total: covenants.length,
+        kept: count("completed"),
+        broken: count("failed"),
+        open: covenants.length - count("completed") - count("failed")
+      },
+      reputation: await this.reputation(info.agentId),
+      recent: covenants.slice(0, 10)
+    };
+  }
+  async reputation(agentId) {
+    const registry = this.network.reputationRegistry;
+    if (!registry) return null;
+    try {
+      const clients = await this.publicClient.readContract({
+        address: registry,
+        abi: reputationRegistryAbi,
+        functionName: "getClients",
+        args: [agentId]
+      });
+      if (!clients.length) return null;
+      const [count, value, decimals] = await this.publicClient.readContract({
+        address: registry,
+        abi: reputationRegistryAbi,
+        functionName: "getSummary",
+        args: [agentId, clients, "", ""]
+      });
+      return { count: Number(count), value: Number(value) / 10 ** decimals };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * The ERC-8004 ids a wallet owns, oldest first.
+   *
+   * The registry has no reverse lookup, so this reads `Registered` events
+   * filtered on `owner` and `Transfer` events filtered on `to` (ids sent to
+   * the wallet), walking back one RPC-sized window at a time until it has
+   * found as many currently owned ids as `balanceOf` says exist.
+   */
+  async findAgentIds(wallet, options = {}) {
+    const owner = wallet ?? this.address;
+    if (!owner) throw new KudoError("NO_WALLET", "Pass a wallet address or connect a wallet.");
+    const registry = this.network.identityRegistry;
+    const balance = await this.publicClient.readContract({
+      address: registry,
+      abi: identityRegistryAbi,
+      functionName: "balanceOf",
+      args: [owner]
+    });
+    if (balance === 0n) return [];
+    const registered = getAbiItem({ abi: identityRegistryAbi, name: "Registered" });
+    const transfer = getAbiItem({ abi: identityRegistryAbi, name: "Transfer" });
+    const checked = /* @__PURE__ */ new Map();
+    const owns = (id) => this.publicClient.readContract({ address: registry, abi: identityRegistryAbi, functionName: "ownerOf", args: [id] }).then((o) => o.toLowerCase() === owner.toLowerCase()).catch(() => false);
+    const ownedCount = () => BigInt([...checked.values()].filter(Boolean).length);
+    const range = this.network.maxLogRange;
+    let to = await this.publicClient.getBlockNumber();
+    for (let i = 0; i < (options.maxWindows ?? 20) && to >= 0n; i++) {
+      const from = to > range ? to - range + 1n : 0n;
+      const [minted, received] = await Promise.all([
+        this.publicClient.getLogs({ address: registry, event: registered, args: { owner }, fromBlock: from, toBlock: to }),
+        this.publicClient.getLogs({ address: registry, event: transfer, args: { to: owner }, fromBlock: from, toBlock: to })
+      ]);
+      const candidates = /* @__PURE__ */ new Set();
+      for (const log of minted) if (log.args.agentId !== void 0) candidates.add(log.args.agentId);
+      for (const log of received) if (log.args.tokenId !== void 0) candidates.add(log.args.tokenId);
+      const fresh = [...candidates].filter((id) => !checked.has(id));
+      const results = await Promise.all(fresh.map(owns));
+      fresh.forEach((id, j) => checked.set(id, results[j]));
+      if (ownedCount() >= balance || from === 0n) break;
+      to = from - 1n;
+    }
+    return [...checked].filter(([, owned]) => owned).map(([id]) => id).sort((a, b) => a < b ? -1 : 1);
+  }
+  /** ETH balance (gas) as a decimal string. */
+  async ethBalance(wallet) {
+    const who = wallet ?? this.address;
+    if (!who) throw new KudoError("NO_WALLET", "Pass a wallet address or connect a wallet.");
+    return formatUnits(await this.publicClient.getBalance({ address: who }), 18);
+  }
+  /**
+   * The contract's ask cooldown setting, in seconds. Note: on the current
+   * mainnet contract it does not stop a second `setAskSettlementData` from
+   * replacing an earlier claim (tested on a fork), so never rely on it to
+   * protect a claim; `meetAsk` checks before and after instead.
+   */
+  async getAskCooldown() {
+    return await this.publicClient.readContract({
+      address: this.network.kudo,
+      abi: kudoAbi,
+      functionName: "getAskCooldown"
+    });
+  }
+  /**
+   * Throws unless a covenant is waiting for its promise proof: the Evaluator
+   * has accepted the claim on its ask (status IN_PROGRESS) and no promise
+   * proof is linked yet. A claim alone does not make the promise due, and
+   * linking twice replaces the first proof.
+   */
+  assertPromiseDue(covenant) {
+    if (covenant.stage === "completed" || covenant.stage === "failed") {
+      throw new KudoError("INVALID_INPUT", `Covenant ${covenant.id} is already closed as ${covenant.stage}.`);
+    }
+    if (covenant.promiseProof) {
+      throw new KudoError("ALREADY_PROVEN", `Covenant ${covenant.id} already has promise proof ${covenant.promiseProof}. Do not pay or link again.`);
+    }
+    if (covenant.status !== "IN_PROGRESS") {
+      throw new KudoError(
+        "ASK_NOT_MET",
+        covenant.askSettledAt ? `Covenant ${covenant.id}'s ask has been claimed but the Evaluator has not accepted it yet (status ${covenant.status}), so nothing is owed. Do not pay; wait for status IN_PROGRESS.` : `Covenant ${covenant.id}'s ask has not been met yet, so there is no promise to keep.`
+      );
+    }
+  }
+  /* --------------------------------------------------------------- builders */
+  /** Encodes any call on a Kudo or registry contract as an unsigned transaction. */
+  buildTx(call2) {
+    return {
+      to: call2.address,
+      data: encodeFunctionData({ abi: call2.abi, functionName: call2.functionName, args: call2.args }),
+      value: call2.value ?? 0n,
+      chainId: this.chainId,
+      description: call2.description
+    };
+  }
+  /** The mint transaction. Validates the text first; does not check ownership (see `mintCovenant`). */
+  buildMintCovenant(input) {
+    const agentId = toBigInt(input.agentId, "agentId");
+    const type = String(input.type).toUpperCase();
+    if (!COVENANT_TYPES.includes(type)) {
+      throw new KudoError(
+        "INVALID_INPUT",
+        `type must be one of ${COVENANT_TYPES.join(", ")}; got "${input.type}". Work on account is an INVOICE; money up front for later work is an ADVANCE.`
+      );
+    }
+    const ask = input.ask?.trim();
+    const promise = input.promise?.trim();
+    if (!ask) throw new KudoError("INVALID_INPUT", "ask is required: what the counterparty does.");
+    if (!promise) throw new KudoError("INVALID_INPUT", "promise is required: what you do in return.");
+    return this.buildTx({
+      address: this.network.kudo,
+      abi: kudoAbi,
+      functionName: "mintCovenant",
+      // The contract takes the promise before the ask.
+      args: [agentId, promise, ask, type],
+      description: `Mint a ${type} covenant under agent ${agentId}. Ask: "${ask}". Promise: "${promise}".`
+    });
+  }
+  /** The transaction a counterparty sends after performing a covenant's ask. */
+  buildMeetAsk(id, input) {
+    const nftId = toBigInt(id, "Covenant id");
+    const proof = input.proof?.trim();
+    if (!proof) throw new KudoError("INVALID_INPUT", "proof is required: a tx hash or a URL showing the ask was met.");
+    return this.buildTx({
+      address: this.network.kudo,
+      abi: kudoAbi,
+      functionName: "setAskSettlementData",
+      args: [nftId, proof, input.promiseDetail?.trim() ?? ""],
+      description: `Meet the ask of covenant ${nftId} with proof ${proof}${input.promiseDetail ? ` and payment instruction "${input.promiseDetail}"` : ""}.`
+    });
+  }
+  /** The transaction the promiser sends after keeping the promise. */
+  buildLinkProof(id, proof) {
+    const nftId = toBigInt(id, "Covenant id");
+    const value = proof?.trim();
+    if (!value) throw new KudoError("INVALID_INPUT", "proof is required: a tx hash or a URL showing the promise was kept.");
+    return this.buildTx({
+      address: this.network.kudo,
+      abi: kudoAbi,
+      functionName: "setPromiseSettlementData",
+      args: [nftId, value],
+      description: `Link proof ${value} that the promise of covenant ${nftId} was kept.`
+    });
+  }
+  /** Registers a new ERC-8004 identity owned by the signer. */
+  buildRegisterAgent(input) {
+    const name = input.name?.trim();
+    if (!name) throw new KudoError("INVALID_INPUT", "name is required.");
+    const metadata = Object.entries({ name, ...input.metadata ?? {} }).map(([metadataKey, value]) => ({
+      metadataKey,
+      metadataValue: stringToHex(value)
+    }));
+    return this.buildTx({
+      address: this.network.identityRegistry,
+      abi: identityRegistryAbi,
+      functionName: "register",
+      args: [input.uri ?? "", metadata],
+      description: `Register an ERC-8004 agent identity named "${name}".`
+    });
+  }
+  /** Sets one metadata entry (e.g. `teeId`, `endpoint`, `name`) on an ERC-8004 identity. */
+  buildSetAgentMetadata(agentId, key, value) {
+    const id = toBigInt(agentId, "agentId");
+    const k = key?.trim();
+    if (!k) throw new KudoError("INVALID_INPUT", "key is required.");
+    return this.buildTx({
+      address: this.network.identityRegistry,
+      abi: identityRegistryAbi,
+      functionName: "setMetadata",
+      args: [id, k, stringToHex(value ?? "")],
+      description: `Set "${k}" to "${value}" on agent ${id}.`
+    });
+  }
+  /* ------------------------------------------------------------------ sends */
+  requireWallet() {
+    const wallet = this.walletClient;
+    const account = wallet?.account;
+    if (!wallet || !account) {
+      throw new KudoError(
+        "NO_WALLET",
+        "This needs a signer. Pass a viem walletClient with an account to createKudo, or use the build* method and sign the transaction yourself."
+      );
+    }
+    return { wallet, account };
+  }
+  /**
+   * Simulates, signs, sends and waits for one transaction. Throws a KudoError
+   * naming the revert if the simulation or the receipt fails.
+   */
+  async send(tx) {
+    const { wallet, account } = this.requireWallet();
+    await this.simulate(tx, account.address);
+    let hash;
+    try {
+      hash = await wallet.sendTransaction({
+        account,
+        chain: this.network.chain,
+        to: tx.to,
+        data: tx.data,
+        value: tx.value
+      });
+    } catch (error) {
+      throw toKudoError(error, tx.description);
+    }
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    if (receipt.status !== "success") {
+      throw new KudoError("TX_FAILED", `${tx.description} \u2014 transaction ${hash} reverted.`);
+    }
+    return receipt;
+  }
+  /**
+   * Dry-runs a transaction as `from` without signing anything. Throws a
+   * KudoError naming the revert, so a bad mint costs nothing.
+   */
+  async simulate(tx, from) {
+    try {
+      await this.publicClient.call({ account: from, to: tx.to, data: tx.data, value: tx.value });
+    } catch (error) {
+      throw toKudoError(error, tx.description);
+    }
+  }
+  /** Broadcasts a transaction someone already signed. For agents that sign offline. */
+  async sendRawTransaction(serialized) {
+    try {
+      const hash = await this.publicClient.sendRawTransaction({ serializedTransaction: serialized });
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+      return { hash, status: receipt.status };
+    } catch (error) {
+      throw toKudoError(error, "Broadcasting the signed transaction");
+    }
+  }
+  /**
+   * Mints a covenant and returns its id.
+   *
+   * Checks first that the signer owns `agentId`: the contract refuses a mint
+   * under an id the caller does not control, and a mint is permanent — a
+   * second attempt adds a duplicate rather than replacing the first.
+   */
+  async mintCovenant(input) {
+    const { account } = this.requireWallet();
+    const tx = this.buildMintCovenant(input);
+    const agentId = toBigInt(input.agentId, "agentId");
+    const owner = await this.getAgent(agentId).then((a) => a.owner);
+    if (owner.toLowerCase() !== account.address.toLowerCase()) {
+      throw new KudoError(
+        "NOT_AGENT_OWNER",
+        `Agent ${agentId} belongs to ${owner}, not ${account.address}. Mint under an id this wallet owns.`
+      );
+    }
+    const receipt = await this.send(tx);
+    const covenantId = this.mintedId(receipt);
+    return { hash: receipt.transactionHash, covenantId, url: this.covenantUrl(covenantId) };
+  }
+  /** Reads the new covenant id out of a mint receipt. */
+  mintedId(receipt) {
+    const kudo = this.network.kudo.toLowerCase();
+    const minted = parseEventLogs({ abi: kudoAbi, eventName: "CovenantMinted", logs: receipt.logs }).find(
+      (l) => l.address.toLowerCase() === kudo
+    );
+    if (minted) return minted.args.nftId;
+    for (const log of receipt.logs) {
+      if (log.address.toLowerCase() !== kudo) continue;
+      try {
+        const e = decodeEventLog({ abi: kudoAbi, data: log.data, topics: log.topics });
+        if (e.eventName === "Transfer" && e.args.from === zeroAddress) {
+          return e.args.tokenId;
+        }
+      } catch {
+      }
+    }
+    throw new KudoError("NOT_FOUND", `Transaction ${receipt.transactionHash} minted no covenant.`);
+  }
+  /**
+   * Meets a covenant's ask: you did the work (or sent the money), now record
+   * the proof. Refuses if someone already met it — attesting over them would
+   * overwrite their claim (the contract does not prevent that) and restart
+   * the promiser's clock. After mining it re-reads the
+   * covenant and throws ALREADY_MET if the proof on chain is not yours.
+   */
+  async meetAsk(id, input) {
+    const { account } = this.requireWallet();
+    const tx = this.buildMeetAsk(id, input);
+    const covenant = await this.getCovenant(id);
+    if (covenant.askSettledAt) {
+      throw new KudoError("ALREADY_MET", `Covenant ${covenant.id}'s ask was already met at ${covenant.askSettledAt.toISOString()} with ${covenant.askProof}.`);
+    }
+    if (covenant.stage !== "ask-open") {
+      throw new KudoError("ALREADY_MET", `Covenant ${covenant.id} is ${covenant.status} (${covenant.stage}); its ask is no longer open.`);
+    }
+    if (covenant.agentWallet.toLowerCase() === account.address.toLowerCase()) {
+      throw new KudoError("INVALID_INPUT", `You minted covenant ${covenant.id}; you cannot be your own counterparty.`);
+    }
+    const receipt = await this.send(tx);
+    const after = await this.getCovenant(id);
+    if (after.askProof !== input.proof.trim()) {
+      throw new KudoError(
+        "ALREADY_MET",
+        `Transaction ${receipt.transactionHash} was mined, but covenant ${after.id}'s ask now carries ${after.askProof}, not your proof: another agent met it first.`
+      );
+    }
+    return { hash: receipt.transactionHash };
+  }
+  /**
+   * Links proof that you kept your promise. Only the covenant's agentWallet
+   * may, only once its ask is met, and only once.
+   */
+  async linkProof(id, proof) {
+    const { account } = this.requireWallet();
+    const tx = this.buildLinkProof(id, proof);
+    const covenant = await this.getCovenant(id);
+    if (covenant.agentWallet.toLowerCase() !== account.address.toLowerCase()) {
+      throw new KudoError("NOT_PROMISER", `Covenant ${covenant.id}'s promise is owed by ${covenant.agentWallet}; only that wallet can link its proof.`);
+    }
+    this.assertPromiseDue(covenant);
+    const receipt = await this.send(tx);
+    return { hash: receipt.transactionHash };
+  }
+  /**
+   * Registers an ERC-8004 identity and returns its id. Refuses if the wallet
+   * already has one, because a second registration cannot be undone; pass
+   * `allowAnother` to register anyway.
+   */
+  async registerAgent(input) {
+    const { account } = this.requireWallet();
+    const tx = this.buildRegisterAgent(input);
+    if (!input.allowAnother) {
+      const balance = await this.publicClient.readContract({
+        address: this.network.identityRegistry,
+        abi: identityRegistryAbi,
+        functionName: "balanceOf",
+        args: [account.address]
+      });
+      if (balance > 0n) {
+        throw new KudoError(
+          "ALREADY_REGISTERED",
+          `${account.address} already owns ${balance} agent identit${balance === 1n ? "y" : "ies"}. Use findAgentIds() to recover the id.`
+        );
+      }
+    }
+    const receipt = await this.send(tx);
+    const registered = parseEventLogs({ abi: identityRegistryAbi, eventName: "Registered", logs: receipt.logs })[0];
+    if (!registered) throw new KudoError("NOT_FOUND", `Transaction ${receipt.transactionHash} registered no identity.`);
+    return { hash: receipt.transactionHash, agentId: registered.args.agentId };
+  }
+  /**
+   * Sets one metadata entry on an identity this wallet owns. Refuses an id
+   * owned by anyone else before anything is signed.
+   */
+  async setAgentMetadata(agentId, key, value) {
+    const { account } = this.requireWallet();
+    const tx = this.buildSetAgentMetadata(agentId, key, value);
+    const id = toBigInt(agentId, "agentId");
+    const owner = (await this.getAgent(id)).owner;
+    if (owner.toLowerCase() !== account.address.toLowerCase()) {
+      throw new KudoError("NOT_AGENT_OWNER", `Agent ${id} belongs to ${owner}, not ${account.address}.`);
+    }
+    const receipt = await this.send(tx);
+    return { hash: receipt.transactionHash };
+  }
+  /**
+   * Resolves when a covenant reaches `until` (default: closed, i.e. completed
+   * or failed). Polls, so it works on any RPC.
+   */
+  async watchSettlement(id, options = {}) {
+    const until = new Set(options.until ?? ["completed", "failed"]);
+    const interval = options.intervalMs ?? 5e3;
+    const deadline = options.timeoutMs ? Date.now() + options.timeoutMs : Infinity;
+    let last;
+    for (; ; ) {
+      if (options.signal?.aborted) throw new KudoError("TIMEOUT", "Watching was cancelled.");
+      const covenant = await this.getCovenant(id);
+      if (covenant.stage !== last) {
+        last = covenant.stage;
+        options.onChange?.(covenant);
+      }
+      if (until.has(covenant.stage)) return covenant;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        throw new KudoError("TIMEOUT", `Covenant ${covenant.id} is still ${covenant.stage}.`);
+      }
+      await new Promise((resolve) => {
+        const done = () => {
+          clearTimeout(timer);
+          options.signal?.removeEventListener("abort", done);
+          resolve();
+        };
+        const timer = setTimeout(done, Math.min(interval, remaining));
+        options.signal?.addEventListener("abort", done, { once: true });
+      });
+    }
+  }
+  /* ---------------------------------------------------------------- helpers */
+  covenantUrl(id) {
+    return this.network.covenantUrl?.replace("{id}", id.toString());
+  }
+  txUrl(hash) {
+    return `${this.network.explorerUrl}/tx/${hash}`;
+  }
+  toCovenant(id, raw, owner) {
+    const status = this.network.statuses[raw.status] ?? "MINTED";
+    const askSettledAt = raw.askSettledAt > 0n ? new Date(Number(raw.askSettledAt) * 1e3) : null;
+    const stage = status === "FAILED" ? "failed" : status === "COMPLETED" ? "completed" : raw.promiseSettlementData ? "awaiting-evaluation" : status === "IN_PROGRESS" ? "promise-due" : askSettledAt ? "ask-claimed" : "ask-open";
+    return {
+      id,
+      owner,
+      agentWallet: raw.agentWallet,
+      agentId: raw.agentId,
+      status,
+      stage,
+      type: raw.nftType,
+      ask: raw.ask,
+      promise: raw.covenantPromise,
+      promiseDetail: raw.promiseDetail,
+      askProof: raw.askSettlementData,
+      askSettledAt,
+      promiseProof: raw.promiseSettlementData,
+      url: this.covenantUrl(id)
+    };
+  }
+};
+function createKudo(options = {}) {
+  return new Kudo(options);
+}
+
+// src/dstack.ts
+var DSTACK_SOCKET = "/var/run/dstack.sock";
+var DSTACK_KEY_PATH = "kudo/agent";
+async function call(path, body, options) {
+  const { request } = await import("http");
+  const socketPath = options.socket ?? DSTACK_SOCKET;
+  return new Promise((resolve, reject) => {
+    const payload = body === void 0 ? void 0 : JSON.stringify(body);
+    const req = request(
+      {
+        socketPath,
+        path,
+        method: payload ? "POST" : "GET",
+        headers: payload ? { "content-type": "application/json", "content-length": Buffer.byteLength(payload) } : {},
+        timeout: options.timeoutMs ?? 5e3
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          if (res.statusCode !== 200) return reject(new KudoError("NOT_FOUND", `dstack ${path} returned ${res.statusCode}.`));
+          try {
+            resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+          } catch {
+            reject(new KudoError("NOT_FOUND", `dstack ${path} did not return JSON.`));
+          }
+        });
+      }
+    );
+    req.on("timeout", () => req.destroy(new Error("timed out")));
+    req.on(
+      "error",
+      (e) => reject(new KudoError("NOT_FOUND", `Cannot reach dstack at ${socketPath} (${e.message}). Is this running in a Phala TEE?`))
+    );
+    req.end(payload);
+  });
+}
+async function dstackPrivateKey(path = DSTACK_KEY_PATH, options = {}) {
+  const { key } = await call("/GetKey", { path, purpose: "signing" }, options);
+  const hex = (key ?? "").replace(/^0x/i, "");
+  if (!/^[0-9a-fA-F]{64}$/.test(hex)) throw new KudoError("NOT_FOUND", "dstack GetKey did not return a 32-byte key.");
+  return `0x${hex}`;
+}
+async function dstackAppId(options = {}) {
+  const { app_id } = await call("/Info", void 0, options);
+  if (!app_id) throw new KudoError("NOT_FOUND", "dstack Info returned no app_id.");
+  return app_id.replace(/^0x/i, "").toLowerCase();
+}
+export {
+  COVENANT_STAGES,
+  COVENANT_TYPES,
+  DSTACK_KEY_PATH,
+  DSTACK_SOCKET,
+  Kudo,
+  KudoError,
+  REVERTS,
+  createKudo,
+  dstackAppId,
+  dstackPrivateKey,
+  identityRegistryAbi,
+  kudoAbi,
+  networks,
+  reputationRegistryAbi,
+  resolveNetwork,
+  robinhood,
+  toKudoError
+};
+//# sourceMappingURL=index.js.map