@nullclear/shared 0.0.0-stage → 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nullclear-Protocol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,9 @@
-# Temporary Holding Version
+# @nullclear/shared
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Core shared constants, CAIP-2 network configurations, ABIs, and cryptographic schemas for the NullClear protocol.
+
+## Features
+- **Networks (`chains.ts`)**: Base Mainnet (8453) & Base Sepolia (84532) contract addresses.
+- **ERC-8004 ABIs (`erc8004-abi.ts`)**: Official viem `parseAbi` definitions for Identity and Reputation Registries.
+- **x402 V2 Types (`x402-types.ts`)**: Payment options, signatures, EIP-3009 typed data schemas, and Base64 helpers.
+- **EIP-712 KYA Schemas (`eip712-kya.ts`)**: Corporate Mandate and Arbiter Clearing Attestation schemas.

package/dist/index.cjs

@@ -0,0 +1,264 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ARBITER_ATTESTATION_TYPES: () => ARBITER_ATTESTATION_TYPES,
+  ARBITER_DOMAIN: () => ARBITER_DOMAIN,
+  BASE_MAINNET: () => BASE_MAINNET,
+  BASE_SEPOLIA: () => BASE_SEPOLIA,
+  CAIP2_TO_CHAIN_ID: () => CAIP2_TO_CHAIN_ID,
+  ClearRequestSchema: () => ClearRequestSchema,
+  EIP3009_ABI: () => EIP3009_ABI,
+  EIP3009_TYPES: () => EIP3009_TYPES,
+  ERC8004_IDENTITY_ABI: () => ERC8004_IDENTITY_ABI,
+  ERC8004_REPUTATION_ABI: () => ERC8004_REPUTATION_ABI,
+  FallbackTargetSchema: () => FallbackTargetSchema,
+  InvariantRuleSchema: () => InvariantRuleSchema,
+  KYA_DOMAIN: () => KYA_DOMAIN,
+  KYA_MANDATE_TYPES: () => KYA_MANDATE_TYPES,
+  NULLCLEAR_ARBITER_ADDRESS: () => NULLCLEAR_ARBITER_ADDRESS,
+  NULLCLEAR_TREASURY_ADDRESS: () => NULLCLEAR_TREASURY_ADDRESS,
+  SUPPORTED_CHAINS: () => SUPPORTED_CHAINS,
+  SpendPolicySchema: () => SpendPolicySchema,
+  ValidationConfigSchema: () => ValidationConfigSchema,
+  decodeBase64Json: () => decodeBase64Json,
+  encodeBase64Json: () => encodeBase64Json,
+  getChainConfig: () => getChainConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/chains.ts
+var NULLCLEAR_TREASURY_ADDRESS = "0xB586eFcCa41dF27ad3873BEcA54da0c30bf04d5c";
+var NULLCLEAR_ARBITER_ADDRESS = "0xfd74fF802EA0E735514C070AF04E0D6528deD145";
+var BASE_MAINNET = {
+  name: "Base Mainnet",
+  chainId: 8453,
+  caip2: "eip155:8453",
+  erc8004Identity: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+  erc8004Reputation: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63",
+  usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  usdcDomain: {
+    name: "USD Coin",
+    version: "2",
+    chainId: 8453,
+    verifyingContract: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+  },
+  rpcUrl: "https://mainnet.base.org",
+  blockExplorer: "https://basescan.org"
+};
+var BASE_SEPOLIA = {
+  name: "Base Sepolia",
+  chainId: 84532,
+  caip2: "eip155:84532",
+  erc8004Identity: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+  erc8004Reputation: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
+  usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  usdcDomain: {
+    name: "USDC",
+    version: "2",
+    chainId: 84532,
+    verifyingContract: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+  },
+  rpcUrl: "https://sepolia.base.org",
+  blockExplorer: "https://sepolia.basescan.org"
+};
+var SUPPORTED_CHAINS = {
+  8453: BASE_MAINNET,
+  84532: BASE_SEPOLIA
+};
+var CAIP2_TO_CHAIN_ID = {
+  "eip155:8453": 8453,
+  "eip155:84532": 84532
+};
+function getChainConfig(chainIdOrCaip2) {
+  let chainId;
+  if (typeof chainIdOrCaip2 === "string") {
+    if (chainIdOrCaip2.startsWith("eip155:")) {
+      chainId = CAIP2_TO_CHAIN_ID[chainIdOrCaip2] ?? parseInt(chainIdOrCaip2.slice(7), 10);
+    } else {
+      chainId = parseInt(chainIdOrCaip2, 10);
+    }
+  } else {
+    chainId = chainIdOrCaip2;
+  }
+  const config = SUPPORTED_CHAINS[chainId];
+  if (!config) {
+    throw new Error(`Unsupported chain ID or CAIP-2 identifier: ${chainIdOrCaip2}`);
+  }
+  return config;
+}
+
+// src/erc8004-abi.ts
+var import_viem = require("viem");
+var ERC8004_IDENTITY_ABI = (0, import_viem.parseAbi)([
+  "function register(string agentURI) external returns (uint256 agentId)",
+  "function ownerOf(uint256 tokenId) external view returns (address)",
+  "function tokenURI(uint256 tokenId) external view returns (string)",
+  "function getAgentWallet(uint256 agentId) external view returns (address)",
+  "event Registered(uint256 indexed agentId, string agentURI, address indexed owner)"
+]);
+var ERC8004_REPUTATION_ABI = (0, import_viem.parseAbi)([
+  "function giveFeedback(uint256 agentId, int128 value, uint8 valueDecimals, string tag1, string tag2, string endpoint, string feedbackURI, bytes32 feedbackHash) external",
+  "function getSummary(uint256 agentId, address[] clientAddresses, string tag1, string tag2) external view returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals)",
+  "function readFeedback(uint256 agentId, address clientAddress, uint64 feedbackIndex) external view returns (int128 value, uint8 valueDecimals, string tag1, string tag2, bool isRevoked)",
+  "event NewFeedback(uint256 indexed agentId, address indexed clientAddress, uint64 feedbackIndex, int128 value, uint8 valueDecimals, string indexed indexedTag1, string tag1, string tag2, string endpoint, string feedbackURI, bytes32 feedbackHash)"
+]);
+
+// src/x402-types.ts
+var import_viem2 = require("viem");
+var EIP3009_ABI = (0, import_viem2.parseAbi)([
+  "function transferWithAuthorization(address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external"
+]);
+var EIP3009_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function encodeBase64Json(obj) {
+  const json = JSON.stringify(obj);
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(json, "utf-8").toString("base64");
+  }
+  return btoa(unescape(encodeURIComponent(json)));
+}
+function decodeBase64Json(base64) {
+  let json;
+  if (typeof Buffer !== "undefined") {
+    json = Buffer.from(base64, "base64").toString("utf-8");
+  } else {
+    json = decodeURIComponent(escape(atob(base64)));
+  }
+  return JSON.parse(json);
+}
+
+// src/eip712-kya.ts
+var KYA_MANDATE_TYPES = {
+  CorporateMandate: [
+    { name: "corporateEntity", type: "string" },
+    { name: "entityRegistrationNumber", type: "string" },
+    { name: "agentId", type: "string" },
+    { name: "agentWallet", type: "address" },
+    { name: "maxTxLimitUsd", type: "uint256" },
+    { name: "liabilityCoverageUsd", type: "uint256" },
+    { name: "validUntil", type: "uint256" },
+    { name: "jurisdiction", type: "string" }
+  ]
+};
+var KYA_DOMAIN = {
+  name: "NullClear KYA Registry",
+  version: "1",
+  chainId: 8453
+};
+var ARBITER_ATTESTATION_TYPES = {
+  ClearingAttestation: [
+    { name: "clearingId", type: "string" },
+    { name: "buyer", type: "address" },
+    { name: "sellerAgentId", type: "string" },
+    { name: "amountAtomic", type: "uint256" },
+    { name: "feeAtomic", type: "uint256" },
+    { name: "responseHash", type: "bytes32" },
+    { name: "timestamp", type: "uint256" },
+    { name: "cleared", type: "bool" }
+  ]
+};
+var ARBITER_DOMAIN = {
+  name: "NullClear Arbiter",
+  version: "1",
+  chainId: 8453
+};
+
+// src/schemas.ts
+var import_zod = require("zod");
+var InvariantRuleSchema = import_zod.z.object({
+  path: import_zod.z.string(),
+  gt: import_zod.z.number().optional(),
+  gte: import_zod.z.number().optional(),
+  lt: import_zod.z.number().optional(),
+  lte: import_zod.z.number().optional(),
+  eq: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()]).optional(),
+  neq: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()]).optional(),
+  minLength: import_zod.z.number().optional(),
+  maxLength: import_zod.z.number().optional(),
+  pattern: import_zod.z.string().optional(),
+  notContains: import_zod.z.array(import_zod.z.string()).optional(),
+  maxStalenessSeconds: import_zod.z.number().optional()
+});
+var ValidationConfigSchema = import_zod.z.object({
+  expectedStatus: import_zod.z.array(import_zod.z.number()).optional(),
+  jsonSchema: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
+  requiredFields: import_zod.z.array(import_zod.z.string()).optional(),
+  sha256Match: import_zod.z.string().optional(),
+  rejectRefusals: import_zod.z.boolean().optional(),
+  invariants: import_zod.z.array(InvariantRuleSchema).optional()
+});
+var FallbackTargetSchema = import_zod.z.object({
+  targetUrl: import_zod.z.string(),
+  sellerAgentId: import_zod.z.string().optional(),
+  paymentSignatureHeader: import_zod.z.string(),
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+});
+var SpendPolicySchema = import_zod.z.object({
+  maxPerCallAtomic: import_zod.z.string().optional(),
+  maxDailyWalletAtomic: import_zod.z.string().optional()
+});
+var ClearRequestSchema = import_zod.z.object({
+  targetUrl: import_zod.z.string(),
+  method: import_zod.z.enum(["GET", "POST", "PUT", "DELETE"]).optional().default("GET"),
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  body: import_zod.z.unknown().optional(),
+  paymentSignatureHeader: import_zod.z.string(),
+  sellerAgentId: import_zod.z.string().optional(),
+  minTrustScore: import_zod.z.number().optional().default(50),
+  twoPhaseRelease: import_zod.z.boolean().optional().default(false),
+  validation: ValidationConfigSchema.optional(),
+  fallbacks: import_zod.z.array(FallbackTargetSchema).max(3).optional(),
+  spendPolicy: SpendPolicySchema.optional()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARBITER_ATTESTATION_TYPES,
+  ARBITER_DOMAIN,
+  BASE_MAINNET,
+  BASE_SEPOLIA,
+  CAIP2_TO_CHAIN_ID,
+  ClearRequestSchema,
+  EIP3009_ABI,
+  EIP3009_TYPES,
+  ERC8004_IDENTITY_ABI,
+  ERC8004_REPUTATION_ABI,
+  FallbackTargetSchema,
+  InvariantRuleSchema,
+  KYA_DOMAIN,
+  KYA_MANDATE_TYPES,
+  NULLCLEAR_ARBITER_ADDRESS,
+  NULLCLEAR_TREASURY_ADDRESS,
+  SUPPORTED_CHAINS,
+  SpendPolicySchema,
+  ValidationConfigSchema,
+  decodeBase64Json,
+  encodeBase64Json,
+  getChainConfig
+});