@invariance/sdk 0.0.1

package/dist/chunk-3ONNY6AX.js

@@ -0,0 +1,849 @@
+import {
+  InvarianceAtomicVerifierAbi,
+  InvarianceCompactLedgerAbi,
+  InvarianceIntentAbi,
+  InvarianceLedgerAbi,
+  InvarianceRegistryAbi,
+  InvarianceReviewAbi
+} from "./chunk-GHYGRZHM.js";
+
+// src/utils/contract-helpers.ts
+import { keccak256, toHex, decodeEventLog, stringToHex, hexToString } from "viem";
+
+// ../packages/common/dist/index.js
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["IDENTITY_NOT_FOUND"] = "IDENTITY_NOT_FOUND";
+  ErrorCode2["IDENTITY_SUSPENDED"] = "IDENTITY_SUSPENDED";
+  ErrorCode2["INVALID_ACTOR_TYPE"] = "INVALID_ACTOR_TYPE";
+  ErrorCode2["WALLET_NOT_CONNECTED"] = "WALLET_NOT_CONNECTED";
+  ErrorCode2["INSUFFICIENT_BALANCE"] = "INSUFFICIENT_BALANCE";
+  ErrorCode2["INTENT_REJECTED"] = "INTENT_REJECTED";
+  ErrorCode2["INTENT_EXPIRED"] = "INTENT_EXPIRED";
+  ErrorCode2["APPROVAL_TIMEOUT"] = "APPROVAL_TIMEOUT";
+  ErrorCode2["POLICY_VIOLATION"] = "POLICY_VIOLATION";
+  ErrorCode2["BUDGET_EXCEEDED"] = "BUDGET_EXCEEDED";
+  ErrorCode2["ACTION_NOT_ALLOWED"] = "ACTION_NOT_ALLOWED";
+  ErrorCode2["TARGET_BLOCKED"] = "TARGET_BLOCKED";
+  ErrorCode2["COOLDOWN_ACTIVE"] = "COOLDOWN_ACTIVE";
+  ErrorCode2["RATE_LIMITED"] = "RATE_LIMITED";
+  ErrorCode2["STATE_GATE_FAILED"] = "STATE_GATE_FAILED";
+  ErrorCode2["ATTESTATION_REQUIRED"] = "ATTESTATION_REQUIRED";
+  ErrorCode2["ESCROW_NOT_FOUND"] = "ESCROW_NOT_FOUND";
+  ErrorCode2["ESCROW_WRONG_STATE"] = "ESCROW_WRONG_STATE";
+  ErrorCode2["NOT_AUTHORIZED_SIGNER"] = "NOT_AUTHORIZED_SIGNER";
+  ErrorCode2["NO_ESCROW_FOR_REVIEW"] = "NO_ESCROW_FOR_REVIEW";
+  ErrorCode2["ALREADY_REVIEWED"] = "ALREADY_REVIEWED";
+  ErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  ErrorCode2["TX_REVERTED"] = "TX_REVERTED";
+  ErrorCode2["VERIFICATION_FAILED"] = "VERIFICATION_FAILED";
+  ErrorCode2["PAYMENT_REQUIRED"] = "PAYMENT_REQUIRED";
+  ErrorCode2["PAYMENT_FAILED"] = "PAYMENT_FAILED";
+  ErrorCode2["PAYMENT_VERIFICATION_FAILED"] = "PAYMENT_VERIFICATION_FAILED";
+  ErrorCode2["ERC8004_NOT_DEPLOYED"] = "ERC8004_NOT_DEPLOYED";
+  ErrorCode2["ERC8004_AGENT_NOT_FOUND"] = "ERC8004_AGENT_NOT_FOUND";
+  ErrorCode2["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
+  ErrorCode2["INVALID_INPUT"] = "INVALID_INPUT";
+  return ErrorCode2;
+})(ErrorCode || {});
+var BASE_MAINNET = {
+  id: 8453,
+  name: "Base",
+  rpcUrl: "https://mainnet.base.org",
+  explorerUrl: "https://basescan.org",
+  testnet: false,
+  pollingInterval: 2e3
+};
+var BASE_SEPOLIA = {
+  id: 84532,
+  name: "Base Sepolia",
+  rpcUrl: "https://sepolia.base.org",
+  explorerUrl: "https://sepolia.basescan.org",
+  testnet: true,
+  pollingInterval: 2e3
+};
+var SUPPORTED_CHAINS = {
+  [BASE_MAINNET.id]: BASE_MAINNET,
+  [BASE_SEPOLIA.id]: BASE_SEPOLIA
+};
+function getChainConfig(chainId) {
+  return SUPPORTED_CHAINS[chainId];
+}
+var BASE_MAINNET_CONTRACTS = {
+  identity: "0x0000000000000000000000000000000000000000",
+  intent: "0x0000000000000000000000000000000000000000",
+  policy: "0x0000000000000000000000000000000000000000",
+  escrow: "0x0000000000000000000000000000000000000000",
+  ledger: "0x0000000000000000000000000000000000000000",
+  review: "0x0000000000000000000000000000000000000000",
+  registry: "0x0000000000000000000000000000000000000000"
+};
+var BASE_SEPOLIA_CONTRACTS = {
+  identity: "0x98082761AC9ef71f5D2FD0D81Fa68DDe0a5f549d",
+  intent: "0xBd6f5e95C18Bb7E913d56fdFa7a9e9b726Cf5F1D",
+  policy: "0x476b03fa71f65D34AE95Cbd5E8c6833Fe5a0b7d9",
+  escrow: "0x72E55D252385E761C1DEf0b705D3a6e7b341bbF6",
+  ledger: "0xf9eeCe4534e43B8683d035D847EB80cf1d2591Bf",
+  review: "0xB8A7246CAA56764c4b6ef18dc72379Cfc03505D3",
+  registry: "0xd5Ea9F94B51B8aDb441d74450066173863509043",
+  usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+};
+var CONTRACT_ADDRESSES = {
+  8453: BASE_MAINNET_CONTRACTS,
+  84532: BASE_SEPOLIA_CONTRACTS
+};
+function getContractAddresses(chainId) {
+  return CONTRACT_ADDRESSES[chainId];
+}
+var MAX_UINT256 = BigInt(
+  "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+);
+
+// src/errors/InvarianceError.ts
+var InvarianceError = class _InvarianceError extends Error {
+  /** Structured error code for programmatic handling */
+  code;
+  /** Public explorer URL relevant to the error context */
+  explorerUrl;
+  /** On-chain transaction hash related to the error */
+  txHash;
+  constructor(code, message, opts) {
+    super(message);
+    this.name = "InvarianceError";
+    this.code = code;
+    this.explorerUrl = opts?.explorerUrl;
+    this.txHash = opts?.txHash;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _InvarianceError);
+    }
+  }
+};
+
+// src/utils/contract-helpers.ts
+var ACTOR_TYPE_MAP = {
+  agent: 0,
+  human: 1,
+  device: 2,
+  service: 3,
+  any: 255
+};
+var REVERSE_ACTOR_TYPE_MAP = {
+  0: "agent",
+  1: "human",
+  2: "device",
+  3: "service"
+};
+var IDENTITY_STATUS_MAP = {
+  0: "active",
+  1: "suspended",
+  2: "deactivated"
+};
+function actorTypeToEnum(type) {
+  const val = ACTOR_TYPE_MAP[type];
+  if (val === void 0) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_ACTOR_TYPE,
+      `Unknown actor type: ${type}`
+    );
+  }
+  return val;
+}
+function enumToActorType(val) {
+  const type = REVERSE_ACTOR_TYPE_MAP[val];
+  if (!type) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_ACTOR_TYPE,
+      `Unknown on-chain actor type enum: ${val}`
+    );
+  }
+  return type;
+}
+function identityStatusFromEnum(val) {
+  const status = IDENTITY_STATUS_MAP[val];
+  if (!status) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown on-chain identity status enum: ${val}`
+    );
+  }
+  return status;
+}
+function toBytes32(id) {
+  if (id.startsWith("0x") && id.length === 66) {
+    return id;
+  }
+  if (id.startsWith("0x") && /^0x[0-9a-fA-F]+$/.test(id)) {
+    const hexPart = id.slice(2);
+    if (hexPart.length > 64) {
+      throw new InvarianceError(
+        ErrorCode.INVALID_INPUT,
+        `Hex ID exceeds 32 bytes: "${id}". Use a shorter identifier or hash it first.`
+      );
+    }
+    return `0x${hexPart.padStart(64, "0")}`;
+  }
+  const hex = stringToHex(id);
+  const hexBody = hex.slice(2);
+  if (hexBody.length > 64) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `ID exceeds 32 bytes: "${id}" (${hexBody.length / 2} bytes). Use a shorter identifier or hash it first.`
+    );
+  }
+  return `0x${hexBody.padEnd(64, "0")}`;
+}
+function fromBytes32(bytes) {
+  const hex = bytes.slice(2);
+  const trimmed = hex.replace(/(00)+$/, "");
+  if (trimmed.length === 0) return "";
+  let decoded;
+  try {
+    decoded = hexToString(`0x${trimmed}`);
+  } catch {
+    console.warn(`[Invariance] fromBytes32: failed to decode hex as UTF-8 string, returning raw hex: ${bytes}`);
+    return bytes;
+  }
+  const reencoded = stringToHex(decoded).slice(2);
+  if (/[\uFFFD]/.test(decoded) || reencoded.toLowerCase() !== trimmed.toLowerCase()) {
+    console.warn(`[Invariance] fromBytes32: round-trip decode mismatch, returning raw hex: ${bytes}`);
+    return bytes;
+  }
+  return decoded;
+}
+async function waitForReceipt(publicClient, txHash, options) {
+  if (options?.optimistic) {
+    return {
+      txHash,
+      blockNumber: 0,
+      gasUsed: "0",
+      status: "success",
+      logs: []
+    };
+  }
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash: txHash,
+    timeout: options?.timeout ?? 3e4,
+    confirmations: 1
+  });
+  const result = {
+    txHash: receipt.transactionHash,
+    blockNumber: Number(receipt.blockNumber),
+    gasUsed: receipt.gasUsed.toString(),
+    status: receipt.status,
+    logs: receipt.logs.map((log) => ({
+      topics: log.topics,
+      data: log.data
+    }))
+  };
+  if (receipt.status === "reverted") {
+    throw new InvarianceError(
+      ErrorCode.TX_REVERTED,
+      `Transaction reverted: ${txHash}`,
+      { txHash }
+    );
+  }
+  return result;
+}
+var POLICY_STATE_MAP = {
+  0: "active",
+  1: "revoked",
+  2: "expired"
+};
+var POLICY_RULE_TYPE_MAP = {
+  "max-spend": 0,
+  "max-per-tx": 1,
+  "daily-limit": 2,
+  "action-whitelist": 3,
+  "action-blacklist": 4,
+  "target-whitelist": 5,
+  "target-blacklist": 6,
+  "time-window": 7,
+  "cooldown": 8,
+  "rate-limit": 9,
+  "require-state": 10,
+  "require-balance": 11,
+  "require-approval": 12,
+  "require-attestation": 13,
+  // Off-chain only: encoded as Custom on-chain
+  "require-payment": 14,
+  "custom": 14
+};
+var REVERSE_POLICY_RULE_TYPE_MAP = {
+  0: "max-spend",
+  1: "max-per-tx",
+  2: "daily-limit",
+  3: "action-whitelist",
+  4: "action-blacklist",
+  5: "target-whitelist",
+  6: "target-blacklist",
+  7: "time-window",
+  8: "cooldown",
+  9: "rate-limit",
+  10: "require-state",
+  11: "require-balance",
+  12: "require-approval",
+  13: "require-attestation",
+  14: "custom"
+};
+function policyRuleTypeToEnum(type) {
+  const val = POLICY_RULE_TYPE_MAP[type];
+  if (val === void 0) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown policy rule type: ${type}`
+    );
+  }
+  return val;
+}
+function enumToPolicyRuleType(val) {
+  const type = REVERSE_POLICY_RULE_TYPE_MAP[val];
+  if (!type) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown on-chain policy rule type enum: ${val}`
+    );
+  }
+  return type;
+}
+function policyStateFromEnum(val) {
+  const state = POLICY_STATE_MAP[val];
+  if (!state) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown on-chain policy state enum: ${val}`
+    );
+  }
+  return state;
+}
+function mapActorTypesToEnums(types) {
+  return types.map(actorTypeToEnum);
+}
+var ESCROW_STATE_MAP = {
+  0: "created",
+  1: "funded",
+  2: "active",
+  3: "released",
+  4: "refunded",
+  5: "disputed",
+  6: "resolved"
+};
+var ESCROW_CONDITION_TYPE_MAP = {
+  "task-completion": 0,
+  "multi-sig": 1,
+  "intent-verified": 2,
+  "milestone": 3
+};
+var REVERSE_ESCROW_CONDITION_TYPE_MAP = {
+  0: "task-completion",
+  1: "multi-sig",
+  2: "intent-verified",
+  3: "milestone"
+};
+function escrowConditionTypeToEnum(type) {
+  const val = ESCROW_CONDITION_TYPE_MAP[type];
+  if (val === void 0) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown escrow condition type: ${type}`
+    );
+  }
+  return val;
+}
+function enumToEscrowConditionType(val) {
+  const type = REVERSE_ESCROW_CONDITION_TYPE_MAP[val];
+  if (!type) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown on-chain escrow condition type enum: ${val}`
+    );
+  }
+  return type;
+}
+function escrowStateFromEnum(val) {
+  const state = ESCROW_STATE_MAP[val];
+  if (state === void 0) {
+    throw new InvarianceError(
+      ErrorCode.ESCROW_NOT_FOUND,
+      `Unknown on-chain escrow state enum: ${val}`
+    );
+  }
+  return state;
+}
+var CONTRACT_ERROR_MAP = {
+  IdentityNotFound: ErrorCode.IDENTITY_NOT_FOUND,
+  NotIdentityOwner: ErrorCode.NOT_AUTHORIZED_SIGNER,
+  AddressAlreadyRegistered: ErrorCode.INVALID_INPUT,
+  IdentityNotActive: ErrorCode.IDENTITY_SUSPENDED,
+  IdentityAlreadyDeactivated: ErrorCode.IDENTITY_SUSPENDED,
+  IdentityNotSuspended: ErrorCode.IDENTITY_NOT_FOUND,
+  InvalidAddress: ErrorCode.INVALID_INPUT,
+  AttestationNotFound: ErrorCode.IDENTITY_NOT_FOUND,
+  AttestationAlreadyRevoked: ErrorCode.IDENTITY_NOT_FOUND,
+  NotAttester: ErrorCode.NOT_AUTHORIZED_SIGNER,
+  AccessControlUnauthorizedAccount: ErrorCode.NOT_AUTHORIZED_SIGNER,
+  // Escrow-specific errors
+  EscrowNotFound: ErrorCode.ESCROW_NOT_FOUND,
+  InvalidAmount: ErrorCode.INVALID_INPUT,
+  InvalidBeneficiary: ErrorCode.INVALID_INPUT,
+  NotDepositor: ErrorCode.NOT_AUTHORIZED_SIGNER,
+  NotBeneficiary: ErrorCode.NOT_AUTHORIZED_SIGNER,
+  NotParty: ErrorCode.NOT_AUTHORIZED_SIGNER,
+  InvalidState: ErrorCode.ESCROW_WRONG_STATE,
+  AlreadyFunded: ErrorCode.ESCROW_WRONG_STATE,
+  NotFunded: ErrorCode.ESCROW_WRONG_STATE,
+  AlreadyApproved: ErrorCode.ESCROW_WRONG_STATE,
+  NotSigner: ErrorCode.NOT_AUTHORIZED_SIGNER,
+  ThresholdNotMet: ErrorCode.ESCROW_WRONG_STATE,
+  EscrowExpired: ErrorCode.ESCROW_WRONG_STATE,
+  DisputeAlreadyExists: ErrorCode.ESCROW_WRONG_STATE,
+  DisputeNotFound: ErrorCode.ESCROW_NOT_FOUND,
+  DisputeAlreadyResolved: ErrorCode.ESCROW_WRONG_STATE,
+  // Policy-specific errors
+  PolicyNotFound: ErrorCode.POLICY_VIOLATION,
+  PolicyNotActive: ErrorCode.POLICY_VIOLATION,
+  PolicyAlreadyAttached: ErrorCode.POLICY_VIOLATION,
+  PolicyNotAttached: ErrorCode.POLICY_VIOLATION,
+  NotPolicyCreator: ErrorCode.NOT_AUTHORIZED_SIGNER,
+  NoRulesProvided: ErrorCode.POLICY_VIOLATION,
+  InvalidExpiresAt: ErrorCode.POLICY_VIOLATION,
+  // Intent-specific errors
+  IntentNotFound: ErrorCode.INVALID_INPUT,
+  IntentNotPending: ErrorCode.INTENT_REJECTED,
+  IntentNotApproved: ErrorCode.INTENT_REJECTED,
+  IntentNotExecuting: ErrorCode.INTENT_REJECTED,
+  IntentExpiredError: ErrorCode.INTENT_EXPIRED,
+  NotRequester: ErrorCode.NOT_AUTHORIZED_SIGNER,
+  PolicyDenied: ErrorCode.POLICY_VIOLATION,
+  InvalidExpiration: ErrorCode.INVALID_INPUT,
+  // Registry-specific errors
+  ListingNotFound: ErrorCode.INVALID_INPUT,
+  NotListingOwner: ErrorCode.NOT_AUTHORIZED_SIGNER,
+  ListingAlreadyInactive: ErrorCode.INVALID_INPUT,
+  EmptyName: ErrorCode.INVALID_INPUT,
+  // Review-specific errors
+  ReviewNotFound: ErrorCode.INVALID_INPUT,
+  EscrowNotCompleted: ErrorCode.ESCROW_WRONG_STATE,
+  NotEscrowParty: ErrorCode.NOT_AUTHORIZED_SIGNER,
+  AlreadyReviewed: ErrorCode.ALREADY_REVIEWED
+};
+function mapContractError(error) {
+  if (error instanceof InvarianceError) {
+    return error;
+  }
+  if (error !== null && typeof error === "object" && "name" in error && error.name === "ContractFunctionRevertedError") {
+    const revertError = error;
+    const errorName = revertError.data?.errorName;
+    if (errorName && errorName in CONTRACT_ERROR_MAP) {
+      const mapped3 = new InvarianceError(CONTRACT_ERROR_MAP[errorName], errorName);
+      mapped3.cause = error;
+      return mapped3;
+    }
+    const mapped2 = new InvarianceError(ErrorCode.TX_REVERTED, revertError.message);
+    mapped2.cause = error;
+    return mapped2;
+  }
+  const message = error instanceof Error ? error.message : "Unknown contract error";
+  const mapped = new InvarianceError(ErrorCode.NETWORK_ERROR, message);
+  mapped.cause = error;
+  return mapped;
+}
+var INTENT_STATUS_MAP = {
+  0: "pending",
+  1: "approved",
+  2: "executing",
+  3: "completed",
+  4: "rejected",
+  5: "expired"
+};
+function intentStatusFromEnum(val) {
+  const status = INTENT_STATUS_MAP[val];
+  if (!status) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown on-chain intent status enum: ${val}`
+    );
+  }
+  return status;
+}
+function parseIntentIdFromLogs(logs) {
+  for (const log of logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: InvarianceIntentAbi,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName === "IntentRequested") {
+        return decoded.args.intentId;
+      }
+    } catch {
+      continue;
+    }
+  }
+  throw new InvarianceError(
+    ErrorCode.TX_REVERTED,
+    "IntentRequested event not found in transaction logs"
+  );
+}
+function hashMetadata(metadata) {
+  const json = JSON.stringify(metadata);
+  return keccak256(toHex(json));
+}
+var SEVERITY_MAP = {
+  info: 0,
+  warn: 1,
+  error: 2
+};
+function mapSeverity(severity) {
+  return SEVERITY_MAP[severity];
+}
+function parseEntryIdFromLogs(logs) {
+  for (const log of logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: InvarianceLedgerAbi,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName === "EntryLogged") {
+        return decoded.args.entryId;
+      }
+    } catch {
+      continue;
+    }
+  }
+  throw new InvarianceError(
+    ErrorCode.TX_REVERTED,
+    "EntryLogged event not found in transaction logs"
+  );
+}
+var COMPACT_LEDGER_TYPES = {
+  LogEntry: [
+    { name: "actorIdentityId", type: "bytes32" },
+    { name: "actorAddress", type: "address" },
+    { name: "action", type: "string" },
+    { name: "category", type: "string" },
+    { name: "metadataHash", type: "bytes32" },
+    { name: "proofHash", type: "bytes32" },
+    { name: "severity", type: "uint8" }
+  ]
+};
+async function generateActorSignatureEIP712(input, domain, walletClient) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new InvarianceError(
+      ErrorCode.WALLET_NOT_CONNECTED,
+      "EIP-712 signing requires a connected wallet account. No keccak fallback is available for CompactLedger."
+    );
+  }
+  return walletClient.signTypedData({
+    account,
+    domain,
+    types: COMPACT_LEDGER_TYPES,
+    primaryType: "LogEntry",
+    message: {
+      actorIdentityId: input.actorIdentityId,
+      actorAddress: input.actorAddress,
+      action: input.action,
+      category: input.category,
+      metadataHash: input.metadataHash,
+      proofHash: input.proofHash,
+      severity: input.severity
+    }
+  });
+}
+async function generatePlatformAttestationEIP712(input, apiKey, apiBaseUrl) {
+  if (!apiKey) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      "CompactLedger requires an API key for platform attestation. The keccak256 fallback is not a valid ECDSA signature and will revert on-chain. Set apiKey in your Invariance config."
+    );
+  }
+  const envUrl = typeof process !== "undefined" ? process.env["INVARIANCE_API_URL"] : void 0;
+  const baseUrl = apiBaseUrl ?? envUrl ?? "https://api.useinvariance.com";
+  const response = await fetch(`${baseUrl}/v1/attest`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      mode: "eip712",
+      input: {
+        actorIdentityId: input.actorIdentityId,
+        actorAddress: input.actorAddress,
+        action: input.action,
+        category: input.category,
+        metadataHash: input.metadataHash,
+        proofHash: input.proofHash,
+        severity: input.severity
+      }
+    })
+  });
+  if (!response.ok) {
+    throw new InvarianceError(
+      ErrorCode.NETWORK_ERROR,
+      `Platform attestation API returned ${response.status}. CompactLedger requires a valid platform signature.`
+    );
+  }
+  const result = await response.json();
+  return result.data.signature;
+}
+function parseCompactEntryIdFromLogs(logs) {
+  for (const log of logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: InvarianceCompactLedgerAbi,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName === "EntryLogged") {
+        return decoded.args.entryId;
+      }
+    } catch {
+      continue;
+    }
+  }
+  throw new InvarianceError(
+    ErrorCode.TX_REVERTED,
+    "CompactLedger EntryLogged event not found in transaction logs"
+  );
+}
+function parseAtomicEntryIdFromLogs(logs) {
+  for (const log of logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: InvarianceAtomicVerifierAbi,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName === "AtomicVerification") {
+        return decoded.args.entryId;
+      }
+    } catch {
+      continue;
+    }
+  }
+  throw new InvarianceError(
+    ErrorCode.TX_REVERTED,
+    "AtomicVerification event not found in transaction logs"
+  );
+}
+async function generateActorSignature(event, walletClient) {
+  const message = JSON.stringify({ action: event.action, metadata: event.metadata ?? {} });
+  const account = walletClient.account;
+  if (!account) {
+    return keccak256(toHex(message));
+  }
+  return walletClient.signMessage({ account, message });
+}
+function generatePlatformCommitment(event) {
+  const payload = JSON.stringify({ action: event.action, metadata: event.metadata ?? {}, platform: "Invariance" });
+  return keccak256(toHex(payload));
+}
+async function generatePlatformAttestation(event, apiKey, apiBaseUrl) {
+  if (!apiKey) {
+    return generatePlatformCommitment(event);
+  }
+  const envUrl = typeof process !== "undefined" ? process.env["INVARIANCE_API_URL"] : void 0;
+  const baseUrl = apiBaseUrl ?? envUrl ?? "https://api.useinvariance.com";
+  try {
+    const response = await fetch(`${baseUrl}/v1/attest`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        action: event.action,
+        metadata: event.metadata ?? {}
+      })
+    });
+    if (!response.ok) {
+      throw new InvarianceError(
+        ErrorCode.NETWORK_ERROR,
+        `Attestation API returned ${response.status}. Cannot generate platform signature.`
+      );
+    }
+    const result = await response.json();
+    const data = result["data"];
+    if (!data || typeof data["signature"] !== "string") {
+      throw new InvarianceError(
+        ErrorCode.NETWORK_ERROR,
+        "Attestation API returned invalid response shape. Expected { data: { signature: string } }."
+      );
+    }
+    return data["signature"];
+  } catch (err) {
+    if (err instanceof InvarianceError) throw err;
+    throw new InvarianceError(
+      ErrorCode.NETWORK_ERROR,
+      `Attestation API unreachable: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function convertToCSV(entries) {
+  if (entries.length === 0) return "entryId,action,timestamp,txHash\n";
+  const sanitize = (v) => {
+    const first = v.charAt(0);
+    if (first === "=" || first === "+" || first === "-" || first === "@") {
+      return `'${v}`;
+    }
+    return v.includes(",") || v.includes('"') ? `"${v.replace(/"/g, '""')}"` : v;
+  };
+  const headers = "entryId,action,timestamp,txHash\n";
+  const rows = entries.map((e) => `${sanitize(e.entryId)},${sanitize(e.action)},${e.timestamp},${sanitize(e.txHash)}`).join("\n");
+  return headers + rows;
+}
+function parseReviewIdFromLogs(logs) {
+  for (const log of logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: InvarianceReviewAbi,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName === "ReviewSubmitted") {
+        return decoded.args.reviewId;
+      }
+    } catch {
+      continue;
+    }
+  }
+  throw new InvarianceError(
+    ErrorCode.TX_REVERTED,
+    "ReviewSubmitted event not found in transaction logs"
+  );
+}
+var LISTING_CATEGORY_MAP = {
+  trading: 0,
+  content: 1,
+  analysis: 2,
+  automation: 3,
+  research: 4,
+  creative: 5,
+  development: 6,
+  custom: 7
+};
+var REVERSE_LISTING_CATEGORY_MAP = {
+  0: "trading",
+  1: "content",
+  2: "analysis",
+  3: "automation",
+  4: "research",
+  5: "creative",
+  6: "development",
+  7: "custom"
+};
+var PRICING_TYPE_MAP = {
+  fixed: 0,
+  hourly: 1,
+  "per-task": 2,
+  subscription: 3
+};
+var REVERSE_PRICING_TYPE_MAP = {
+  0: "fixed",
+  1: "hourly",
+  2: "per-task",
+  3: "subscription"
+};
+function listingCategoryToEnum(category) {
+  const val = LISTING_CATEGORY_MAP[category];
+  if (val === void 0) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown listing category: ${category}`
+    );
+  }
+  return val;
+}
+function enumToListingCategory(val) {
+  const category = REVERSE_LISTING_CATEGORY_MAP[val];
+  if (!category) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown on-chain listing category enum: ${val}`
+    );
+  }
+  return category;
+}
+function pricingTypeToEnum(type) {
+  const val = PRICING_TYPE_MAP[type];
+  if (val === void 0) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown pricing type: ${type}`
+    );
+  }
+  return val;
+}
+function enumToPricingType(val) {
+  const type = REVERSE_PRICING_TYPE_MAP[val];
+  if (!type) {
+    throw new InvarianceError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown on-chain pricing type enum: ${val}`
+    );
+  }
+  return type;
+}
+function parseListingIdFromLogs(logs) {
+  for (const log of logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: InvarianceRegistryAbi,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName === "ListingRegistered") {
+        return decoded.args.listingId;
+      }
+    } catch {
+      continue;
+    }
+  }
+  throw new InvarianceError(
+    ErrorCode.TX_REVERTED,
+    "ListingRegistered event not found in transaction logs"
+  );
+}
+
+export {
+  ErrorCode,
+  getChainConfig,
+  getContractAddresses,
+  InvarianceError,
+  actorTypeToEnum,
+  enumToActorType,
+  identityStatusFromEnum,
+  toBytes32,
+  fromBytes32,
+  waitForReceipt,
+  policyRuleTypeToEnum,
+  enumToPolicyRuleType,
+  policyStateFromEnum,
+  mapActorTypesToEnums,
+  escrowConditionTypeToEnum,
+  enumToEscrowConditionType,
+  escrowStateFromEnum,
+  mapContractError,
+  intentStatusFromEnum,
+  parseIntentIdFromLogs,
+  hashMetadata,
+  mapSeverity,
+  parseEntryIdFromLogs,
+  generateActorSignatureEIP712,
+  generatePlatformAttestationEIP712,
+  parseCompactEntryIdFromLogs,
+  parseAtomicEntryIdFromLogs,
+  generateActorSignature,
+  generatePlatformCommitment,
+  generatePlatformAttestation,
+  convertToCSV,
+  parseReviewIdFromLogs,
+  listingCategoryToEnum,
+  enumToListingCategory,
+  pricingTypeToEnum,
+  enumToPricingType,
+  parseListingIdFromLogs
+};
+//# sourceMappingURL=chunk-3ONNY6AX.js.map