opacity-issuer-core 0.2.1

package/dist/chunk-7ODYBEZH.js

@@ -0,0 +1,889 @@
+import { assertDocHash, assertSessionWindow, assertAddress, assertChainId, assertNonce, DOCUMENT_ACCEPTANCE_PRIMARY_TYPE, DOCUMENT_ACCEPTANCE_TYPES, DOCUMENT_ATTESTOR_DOMAIN_VERSION, DOCUMENT_ATTESTOR_DOMAIN_NAME, EIP712_DOMAIN_TYPE, assertTraitId, assertBoolean, assertServerSignature, assertUserSignature } from './chunk-2STMWRIV.js';
+import { OpacityAttestationError, OpacityConfigError } from './chunk-54Q3MU62.js';
+import { keccak256, toBytes, encodeFunctionData, getAddress, hashTypedData, numberToHex, encodePacked, size, BaseError, ExecutionRevertedError, isHex, decodeFunctionResult, decodeErrorResult } from 'viem';
+
+// src/documents/abi.ts
+var documentAttestorAbi = [
+  {
+    type: "function",
+    name: "attestDocument",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "wallet", type: "address" },
+      { name: "traitId", type: "bytes32" },
+      { name: "docHash", type: "bytes32" },
+      { name: "nonce", type: "bytes32" },
+      { name: "issuedAt", type: "uint256" },
+      { name: "deadline", type: "uint256" },
+      { name: "serverSignature", type: "bytes" },
+      { name: "userSignature", type: "bytes" }
+    ],
+    outputs: []
+  },
+  // ── Reads ────────────────────────────────────────────────────────────────────────────────────
+  {
+    type: "function",
+    name: "serverSigner",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "address" }]
+  },
+  {
+    type: "function",
+    name: "usedNonces",
+    stateMutability: "view",
+    inputs: [{ name: "nonce", type: "bytes32" }],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "retiredSigners",
+    stateMutability: "view",
+    inputs: [{ name: "signer", type: "address" }],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "allowlistRegistry",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "address" }]
+  },
+  {
+    type: "function",
+    name: "MAX_ATTESTATION_LIFETIME",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "DOCUMENT_ACCEPTANCE_TYPEHASH",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "bytes32" }]
+  },
+  {
+    type: "function",
+    name: "ATTESTATION_AUTHORIZATION_TYPEHASH",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "bytes32" }]
+  },
+  {
+    // ERC-5267, inherited from OpenZeppelin's EIP712. Lets a consumer confirm the domain the SDK
+    // builds locally matches the one the deployed contract verifies against.
+    type: "function",
+    name: "eip712Domain",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { name: "fields", type: "bytes1" },
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" },
+      { name: "salt", type: "bytes32" },
+      { name: "extensions", type: "uint256[]" }
+    ]
+  },
+  // ── Events ───────────────────────────────────────────────────────────────────────────────────
+  {
+    type: "event",
+    name: "DocumentAttested",
+    inputs: [
+      { name: "userId", type: "bytes32", indexed: true },
+      { name: "wallet", type: "address", indexed: true },
+      { name: "traitId", type: "bytes32", indexed: true },
+      { name: "docHash", type: "bytes32", indexed: false },
+      { name: "nonce", type: "bytes32", indexed: false }
+    ],
+    anonymous: false
+  },
+  // ── Errors: DocumentAttestor ─────────────────────────────────────────────────────────────────
+  { type: "error", name: "ZeroAddress", inputs: [] },
+  { type: "error", name: "InvalidTraitId", inputs: [] },
+  { type: "error", name: "InvalidDocHash", inputs: [] },
+  { type: "error", name: "NonceAlreadyUsed", inputs: [] },
+  { type: "error", name: "AttestationExpired", inputs: [{ name: "deadline", type: "uint256" }] },
+  {
+    type: "error",
+    name: "AttestationDeadlineTooFar",
+    inputs: [
+      { name: "deadline", type: "uint256" },
+      { name: "maxAllowed", type: "uint256" }
+    ]
+  },
+  {
+    type: "error",
+    name: "AttestationIssuedInFuture",
+    inputs: [{ name: "issuedAt", type: "uint256" }]
+  },
+  { type: "error", name: "WalletNotOnboarded", inputs: [{ name: "wallet", type: "address" }] },
+  { type: "error", name: "InvalidServerSignature", inputs: [] },
+  { type: "error", name: "SignerRetired", inputs: [{ name: "signer", type: "address" }] },
+  { type: "error", name: "InvalidUserSignature", inputs: [] },
+  // ── Errors: OpenZeppelin ECDSA, raised while recovering the server signature ─────────────────
+  { type: "error", name: "ECDSAInvalidSignature", inputs: [] },
+  {
+    type: "error",
+    name: "ECDSAInvalidSignatureLength",
+    inputs: [{ name: "length", type: "uint256" }]
+  },
+  { type: "error", name: "ECDSAInvalidSignatureS", inputs: [{ name: "s", type: "bytes32" }] },
+  // ── Errors: bubbled up from AllowlistRegistry.enableTraitAsWriter ────────────────────────────
+  { type: "error", name: "NotTraitWriter", inputs: [] },
+  { type: "error", name: "TraitNotWriterEnableable", inputs: [] },
+  { type: "error", name: "EnforcedPause", inputs: [] }
+];
+function documentTraitId(name) {
+  return keccak256(toBytes(name));
+}
+function hashDocument(content) {
+  return keccak256(typeof content === "string" ? toBytes(content) : content);
+}
+
+// src/documents/verify.ts
+function assertDocumentContent(content) {
+  if (typeof content !== "string" && !(content instanceof Uint8Array)) {
+    throw new OpacityAttestationError(
+      "MalformedInput",
+      "`content` must be a `Uint8Array` of document bytes or a `string` hashed as UTF-8.",
+      { field: "content" }
+    );
+  }
+  if (content.length === 0) {
+    throw new OpacityAttestationError(
+      "MalformedInput",
+      "`content` is empty. An executed document is never zero bytes, so this is a failed read or a render that produced nothing, rather than a document worth hashing.",
+      { field: "content" }
+    );
+  }
+  return content;
+}
+function assertDocumentMatchesHash(content, expectedDocHash) {
+  const expected = assertDocHash(expectedDocHash);
+  const actual = hashDocument(assertDocumentContent(content));
+  if (actual.toLowerCase() !== expected.toLowerCase()) {
+    throw new OpacityAttestationError(
+      "DocHashMismatch",
+      `The rendered document does not match the session \`docHash\`. The session commits to ${expected}, but the supplied content hashes to ${actual}. Do not raise the wallet prompt \u2014 the investor would be signing for a document they were never shown. The client is the source of this hash, so either the session echoed back a different \`docHash\` than the one posted to \`POST /attestations\`, or these are not the bytes that were hashed for it: a template, a re-encoded PDF, or a truncated read each hash differently. Re-hash the exact executed artifact that was submitted; if it still does not match, abandon the session and escalate \u2014 the backend is not committing to the document being signed.`,
+      { field: "docHash" }
+    );
+  }
+}
+function toUnixSeconds(value, field) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value)) {
+      throw new OpacityAttestationError(
+        "MalformedInput",
+        `\`${field}\` must be a whole number of unix seconds; received ${value}.`,
+        { field }
+      );
+    }
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^[0-9]+$/.test(value)) {
+    return BigInt(value);
+  }
+  throw new OpacityAttestationError(
+    "MalformedInput",
+    `\`${field}\` must be unix seconds as a bigint, a whole number, or a decimal string.`,
+    { field }
+  );
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function isTimestampLike(value) {
+  return typeof value === "bigint" || typeof value === "number" || typeof value === "string";
+}
+function readSessionFields(session) {
+  const record = asRecord(session);
+  if (record === void 0) {
+    throw new OpacityAttestationError(
+      "MalformedInput",
+      "`session` must be the object returned by `POST /attestations`.",
+      { field: "session" }
+    );
+  }
+  const message = asRecord(asRecord(record["typedData"])?.["message"]);
+  return {
+    docHash: readSessionDocHash(message?.["docHash"], record["docHash"]),
+    deadline: readSessionDeadline(record["deadline"], message?.["deadline"])
+  };
+}
+function readSessionDocHash(signed, echoed) {
+  const signedHash = typeof signed === "string" ? signed : void 0;
+  const echoedHash = typeof echoed === "string" ? echoed : void 0;
+  if (signedHash !== void 0 && echoedHash !== void 0 && signedHash.toLowerCase() !== echoedHash.toLowerCase()) {
+    throw new OpacityAttestationError(
+      "DocHashMismatch",
+      `The session disagrees with itself about \`docHash\`: the top-level field says ${echoedHash} while \`typedData.message\`, the copy the wallet actually signs, says ${signedHash}. A UI that displays one and prompts for the other is exactly the gap this check exists to close. Abandon the session and escalate.`,
+      { field: "docHash" }
+    );
+  }
+  const docHash = signedHash ?? echoedHash;
+  if (docHash === void 0) {
+    throw new OpacityAttestationError(
+      "MalformedInput",
+      "`session` carries no usable `docHash`. It is read from `typedData.message.docHash`, falling back to the top-level `docHash`.",
+      { field: "docHash" }
+    );
+  }
+  return docHash;
+}
+function readSessionDeadline(top, signed) {
+  const topDeadline = isTimestampLike(top) ? toUnixSeconds(top, "deadline") : void 0;
+  const signedDeadline = isTimestampLike(signed) ? toUnixSeconds(signed, "deadline") : void 0;
+  if (topDeadline !== void 0 && signedDeadline !== void 0 && topDeadline !== signedDeadline) {
+    throw new OpacityAttestationError(
+      "MalformedInput",
+      `The session disagrees with itself about \`deadline\`: the top level says ${topDeadline} while \`typedData.message\`, the copy the wallet signs and the contract enforces, says ${signedDeadline}.`,
+      { field: "deadline" }
+    );
+  }
+  const deadline = topDeadline ?? signedDeadline;
+  if (deadline === void 0) {
+    throw new OpacityAttestationError(
+      "MalformedInput",
+      "`session` carries no usable `deadline`. It is read from the top-level `deadline`, falling back to `typedData.message.deadline`.",
+      { field: "deadline" }
+    );
+  }
+  return deadline;
+}
+function verifyAttestationSession(params) {
+  const { docHash, deadline } = "session" in params ? readSessionFields(params.session) : { docHash: params.docHash, deadline: toUnixSeconds(params.deadline, "deadline") };
+  assertDocumentMatchesHash(params.content, docHash);
+  assertSessionWindow(
+    {
+      issuedAt: params.issuedAt === void 0 ? void 0 : toUnixSeconds(params.issuedAt, "issuedAt"),
+      deadline
+    },
+    params.now === void 0 ? {} : { now: params.now }
+  );
+}
+function buildDocumentAcceptanceTypedData(params) {
+  const verifyingContract = assertAddress(params.attestorAddress, "attestorAddress");
+  const chainId = assertChainId(params.chainId);
+  const nonce = assertNonce(params.nonce);
+  const docHash = assertDocHash(params.docHash);
+  assertSessionWindow(
+    { issuedAt: params.issuedAt, deadline: params.deadline },
+    params.now === void 0 ? {} : { now: params.now }
+  );
+  return {
+    domain: {
+      name: DOCUMENT_ATTESTOR_DOMAIN_NAME,
+      version: DOCUMENT_ATTESTOR_DOMAIN_VERSION,
+      chainId,
+      verifyingContract
+    },
+    types: DOCUMENT_ACCEPTANCE_TYPES,
+    primaryType: DOCUMENT_ACCEPTANCE_PRIMARY_TYPE,
+    message: { nonce, docHash, deadline: params.deadline }
+  };
+}
+function hashDocumentAcceptance(typedData) {
+  return hashTypedData(typedData);
+}
+function toEthersTypedData(typedData) {
+  return {
+    domain: typedData.domain,
+    types: {
+      DocumentAcceptance: typedData.types.DocumentAcceptance.map((field) => ({ ...field }))
+    },
+    value: typedData.message
+  };
+}
+function toEip712JsonPayload(typedData) {
+  return {
+    types: {
+      EIP712Domain: EIP712_DOMAIN_TYPE,
+      ...typedData.types
+    },
+    primaryType: typedData.primaryType,
+    domain: {
+      name: typedData.domain.name,
+      version: typedData.domain.version,
+      chainId: typedData.domain.chainId,
+      verifyingContract: typedData.domain.verifyingContract
+    },
+    message: {
+      nonce: typedData.message.nonce,
+      docHash: typedData.message.docHash,
+      deadline: typedData.message.deadline.toString()
+    }
+  };
+}
+function toEip712Json(typedData) {
+  return JSON.stringify(toEip712JsonPayload(typedData));
+}
+function toArgs(params) {
+  const wallet = assertAddress(params.wallet, "wallet");
+  const traitId = assertTraitId(params.traitId);
+  const docHash = assertDocHash(params.docHash);
+  const nonce = assertNonce(params.nonce);
+  const serverSignature = assertServerSignature(params.serverSignature);
+  const userSignature = assertUserSignature(params.userSignature);
+  assertSessionWindow(
+    { issuedAt: params.issuedAt, deadline: params.deadline },
+    params.now === void 0 ? {} : { now: params.now }
+  );
+  return [
+    wallet,
+    traitId,
+    docHash,
+    nonce,
+    params.issuedAt,
+    params.deadline,
+    serverSignature,
+    userSignature
+  ];
+}
+function buildAttestDocumentTransaction(params) {
+  const to = assertAddress(params.attestorAddress, "attestorAddress");
+  const chainId = assertChainId(params.chainId);
+  const from = params.from === void 0 ? void 0 : assertAddress(params.from, "from");
+  const request = {
+    to,
+    data: encodeFunctionData({
+      abi: documentAttestorAbi,
+      functionName: "attestDocument",
+      args: toArgs(params)
+    }),
+    value: 0n,
+    chainId
+  };
+  return from === void 0 ? request : { ...request, from };
+}
+function toWriteContractRequest(params) {
+  return {
+    address: assertAddress(params.attestorAddress, "attestorAddress"),
+    abi: documentAttestorAbi,
+    functionName: "attestDocument",
+    args: toArgs(params),
+    chainId: assertChainId(params.chainId)
+  };
+}
+function toJsonRpcTransaction(transaction, options) {
+  return {
+    from: assertAddress(options.from, "from"),
+    to: transaction.to,
+    data: transaction.data,
+    value: numberToHex(transaction.value),
+    chainId: numberToHex(transaction.chainId)
+  };
+}
+var sandboxAllowlistRegistryAbi = [
+  {
+    type: "function",
+    name: "sandboxRegisterIssuer",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "sandboxAddSelf",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "sandboxSetSelfTrait",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "traitId", type: "bytes32" },
+      { name: "enabled", type: "bool" }
+    ],
+    outputs: []
+  },
+  // ── Marker ───────────────────────────────────────────────────────────────────────────────────
+  //
+  // Present ONLY on the sandbox implementation, so tooling can tell it apart from the stock
+  // `AllowlistRegistry` behind a proxy with one staticcall instead of a storage probe. The marker
+  // landed as version 1 in contracts commit 281e9c5; the self-trait surface advances it to 2.
+  // Sandbox v3 adds issuer self-registration. Older implementations deployed before the marker
+  // revert on it while `sandboxAddSelf()` works; `probeSandboxRegistry` copes with both.
+  {
+    type: "function",
+    name: "sandboxVersion",
+    stateMutability: "pure",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  // ── Reads ────────────────────────────────────────────────────────────────────────────────────
+  {
+    type: "function",
+    name: "isAllowed",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "getUserId",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ type: "bytes32" }]
+  },
+  {
+    type: "function",
+    name: "hasGlobalTrait",
+    stateMutability: "view",
+    inputs: [
+      { name: "userId", type: "bytes32" },
+      { name: "traitId", type: "bytes32" }
+    ],
+    outputs: [{ type: "bool" }]
+  },
+  // ── Events ───────────────────────────────────────────────────────────────────────────────────
+  {
+    type: "event",
+    name: "GlobalTraitSet",
+    anonymous: false,
+    inputs: [
+      { name: "userId", type: "bytes32", indexed: true },
+      { name: "traitId", type: "bytes32", indexed: true },
+      { name: "enabled", type: "bool", indexed: false },
+      { name: "updatedBy", type: "address", indexed: false }
+    ]
+  },
+  // ── Errors reachable from the sandbox writes ─────────────────────────────────────────────────
+  { type: "error", name: "EnforcedPause", inputs: [] },
+  { type: "error", name: "AddressNotEligible", inputs: [{ name: "account", type: "address" }] },
+  { type: "error", name: "AddressNotVerified", inputs: [{ name: "account", type: "address" }] },
+  { type: "error", name: "InvalidUserId", inputs: [] },
+  { type: "error", name: "InvalidTraitId", inputs: [] }
+];
+var SANDBOX_IMPLEMENTATION_VERSION = 3n;
+var SANDBOX_TRAIT_IDS = Object.freeze({
+  /** `keccak256("trait.accredited")` — the contracts' canonical accredited-investor trait. */
+  accreditedInvestor: keccak256(toBytes("trait.accredited")),
+  /** `keccak256("doc.mmf.subscription.v1")` — the current MMF subscription document trait. */
+  mmfDocumentSigned: keccak256(toBytes("doc.mmf.subscription.v1"))
+});
+function buildSandboxAddSelfTransaction(params) {
+  const to = assertAddress(params.registryAddress, "registryAddress");
+  const chainId = assertChainId(params.chainId);
+  const from = params.from === void 0 ? void 0 : assertAddress(params.from, "from");
+  const request = {
+    to,
+    data: SANDBOX_ADD_SELF_CALLDATA,
+    value: 0n,
+    chainId
+  };
+  return from === void 0 ? request : { ...request, from };
+}
+function toSandboxAddSelfWriteContractRequest(params) {
+  const address = assertAddress(params.registryAddress, "registryAddress");
+  const chainId = assertChainId(params.chainId);
+  const account = params.from === void 0 ? void 0 : assertAddress(params.from, "from");
+  const request = {
+    address,
+    abi: sandboxAllowlistRegistryAbi,
+    functionName: "sandboxAddSelf",
+    args: [],
+    chainId
+  };
+  return account === void 0 ? request : { ...request, account };
+}
+function buildSandboxRegisterIssuerTransaction(params) {
+  return {
+    ...buildSandboxAddSelfTransaction(params),
+    data: encodeFunctionData({
+      abi: sandboxAllowlistRegistryAbi,
+      functionName: "sandboxRegisterIssuer"
+    })
+  };
+}
+function toSandboxRegisterIssuerWriteContractRequest(params) {
+  return { ...toSandboxAddSelfWriteContractRequest(params), functionName: "sandboxRegisterIssuer" };
+}
+function buildSandboxSetSelfTraitTransaction(params) {
+  const to = assertAddress(params.registryAddress, "registryAddress");
+  const chainId = assertChainId(params.chainId);
+  const traitId = assertTraitId(params.traitId);
+  const enabled = assertBoolean(params.enabled, "enabled");
+  const from = params.from === void 0 ? void 0 : assertAddress(params.from, "from");
+  const request = {
+    to,
+    data: encodeFunctionData({
+      abi: sandboxAllowlistRegistryAbi,
+      functionName: "sandboxSetSelfTrait",
+      args: [traitId, enabled]
+    }),
+    value: 0n,
+    chainId
+  };
+  return from === void 0 ? request : { ...request, from };
+}
+function toSandboxSetSelfTraitWriteContractRequest(params) {
+  const address = assertAddress(params.registryAddress, "registryAddress");
+  const chainId = assertChainId(params.chainId);
+  const traitId = assertTraitId(params.traitId);
+  const enabled = assertBoolean(params.enabled, "enabled");
+  const account = params.from === void 0 ? void 0 : assertAddress(params.from, "from");
+  const request = {
+    address,
+    abi: sandboxAllowlistRegistryAbi,
+    functionName: "sandboxSetSelfTrait",
+    args: [traitId, enabled],
+    chainId
+  };
+  return account === void 0 ? request : { ...request, account };
+}
+function sandboxUserId(wallet) {
+  const normalized = assertAddress(wallet, "wallet");
+  return keccak256(encodePacked(["string", "address"], ["sandbox.user.", normalized]));
+}
+var SANDBOX_ADD_SELF_CALLDATA = encodeFunctionData({
+  abi: sandboxAllowlistRegistryAbi,
+  functionName: "sandboxAddSelf",
+  args: []
+});
+var SANDBOX_VERSION_CALLDATA = encodeFunctionData({
+  abi: sandboxAllowlistRegistryAbi,
+  functionName: "sandboxVersion",
+  args: []
+});
+var PROBE_SENDER = "0x1000000000000000000000000000000000000001";
+async function probeSandboxRegistry(client, params) {
+  const registryAddress = assertAddress(params.registryAddress, "registryAddress");
+  const expectedChainId = assertChainId(params.chainId);
+  const from = params.from === void 0 ? PROBE_SENDER : assertAddress(params.from, "from");
+  const actualChainId = await client.getChainId();
+  if (actualChainId !== expectedChainId) {
+    throw new OpacityConfigError(
+      `Sandbox registry ${registryAddress} was resolved for chain ${expectedChainId}, but the probe RPC client is connected to chain ${actualChainId}. Pass a public client for chain ${expectedChainId}.`
+    );
+  }
+  const code = await client.getBytecode({ address: registryAddress });
+  if (code === void 0 || size(code) === 0) {
+    return { registryAddress, attached: false, version: null, evidence: "no_code" };
+  }
+  const marker = await tryCall(client, { to: registryAddress, data: SANDBOX_VERSION_CALLDATA });
+  if (marker.outcome === "returned") {
+    if (marker.data === void 0 || size(marker.data) === 0) {
+      return { registryAddress, attached: false, version: null, evidence: "not_sandbox" };
+    }
+    const version = decodeVersion(marker.data);
+    return version === void 0 ? { registryAddress, attached: false, version: null, evidence: "not_sandbox" } : { registryAddress, attached: true, version, evidence: "marker" };
+  }
+  const legacy = await tryCall(client, {
+    to: registryAddress,
+    data: SANDBOX_ADD_SELF_CALLDATA,
+    account: from
+  });
+  if (legacy.outcome === "returned") {
+    return legacy.data === void 0 || size(legacy.data) === 0 ? { registryAddress, attached: true, version: null, evidence: "self_add_call" } : { registryAddress, attached: false, version: null, evidence: "not_sandbox" };
+  }
+  if (legacy.data !== void 0 && isSandboxRegistryError(legacy.data)) {
+    return { registryAddress, attached: true, version: null, evidence: "self_add_revert" };
+  }
+  return { registryAddress, attached: false, version: null, evidence: "not_sandbox" };
+}
+async function tryCall(client, args) {
+  try {
+    const { data } = await client.call(args);
+    return { outcome: "returned", data };
+  } catch (error) {
+    const revert = asExecutionRevert(error);
+    if (revert === void 0) throw error;
+    return { outcome: "reverted", data: revert.data };
+  }
+}
+function asExecutionRevert(error) {
+  const root = error instanceof BaseError ? error.walk() : error;
+  const reverted = error instanceof BaseError && error.walk((e) => e instanceof ExecutionRevertedError) !== null || hasRevertCode(root) || hasRevertMessage(root) || hasRevertMessage(error);
+  if (!reverted) return void 0;
+  return { data: revertData(root) ?? revertData(error) };
+}
+function hasRevertCode(value) {
+  return typeof value === "object" && value !== null && value.code === ExecutionRevertedError.code;
+}
+function hasRevertMessage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return [record.message, record.details, record.shortMessage].some(
+    (text) => typeof text === "string" && ExecutionRevertedError.nodeMessage.test(text.toLowerCase())
+  );
+}
+function revertData(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const data = value.data;
+  if (typeof data === "string" && isHex(data)) return data;
+  if (typeof data === "object" && data !== null) {
+    const nested = data.data;
+    if (typeof nested === "string" && isHex(nested)) return nested;
+  }
+  return void 0;
+}
+function decodeVersion(data) {
+  if (size(data) !== 32) return void 0;
+  try {
+    const version = decodeFunctionResult({
+      abi: sandboxAllowlistRegistryAbi,
+      functionName: "sandboxVersion",
+      data
+    });
+    return version > 0n ? version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isSandboxRegistryError(data) {
+  try {
+    const decoded = decodeErrorResult({ abi: sandboxAllowlistRegistryAbi, data });
+    return decoded.errorName === "EnforcedPause" || decoded.errorName === "AddressNotEligible";
+  } catch {
+    return false;
+  }
+}
+var SEPOLIA_SANDBOX_MANIFEST = Object.freeze({
+  chainId: 11155111,
+  contractsCommit: "ee48b026312447f4b98259c5b69c5b3dd909e7ac",
+  startBlock: 11704186,
+  deploymentEndBlock: 11704251,
+  seedEndBlock: 11704261,
+  verifiedAtBlock: 11704261,
+  verifiedAtBlockHash: "0x2be898f65c42951b74f5638840b580f50a3d67e6a3fdacb23a93c91d5d30e584",
+  sandboxVersion: 3,
+  contractsPr: "https://github.com/OpacityLabs/pilot-evm/pull/163",
+  mmfTokenId: 1n,
+  defaultBeaconVariant: "0x9710c10589ba16449491db61cd49910e5850d89fd101354fd502e443315ef1a7",
+  documentTraitId: "0x07a0e2ce63cbf806e2e785550e9037052acefbf71086a0b714149f62d2511603",
+  addresses: Object.freeze({
+    registry: getAddress("0x4f471f8719192965c7ee1c3ab460d55d9734ac17"),
+    registryImplementation: getAddress("0x580ee27e862052c3454e99be374785394b490e5c"),
+    securityTokenImplementation: getAddress("0xf388b72cc6043c97f33e2bd74c73b102efc0540a"),
+    timelockBeacon: getAddress("0x8362deb9ddde9a37cc104ac5f567596d295e9f2f"),
+    beaconRegistry: getAddress("0xc7e3f9802e637cd63096008cc2fb0e4b5da91c79"),
+    factoryImplementation: getAddress("0x5b0db45654ac926405c270de0947767ef8edde12"),
+    policyRegistry: getAddress("0x23f059b4a2962b2801804b69db78200cc4ca5308"),
+    policyEngineImplementation: getAddress("0x7b1bc77a3934b7c04aebfa783ae1c9047962fe80"),
+    orchestratorImplementation: getAddress("0x1c3dc8c8e87a1e2840283f1418b3787d3825f492"),
+    securityTokenLens: getAddress("0xa3d006def1b1330a52776271cc43e1c76d505c59"),
+    overrideHelperImplementation: getAddress("0x0d9c174129bab0c6005ad228a5457f53dcebf3c5"),
+    tokenTraitRegistry: getAddress("0x5d491bc34df171e0657e26911bd6821b8257d139"),
+    documentAttestor: getAddress("0x0de5ac323a4756e44620b2da5845fe8c3bdcc229"),
+    mockUSDC: getAddress("0x88043845880c5a23ba54bcbf68570c882d3e6ae5"),
+    vault: getAddress("0xfb8a78e328c0d8894cd3c87244d67e79e7d0c6af"),
+    factory: getAddress("0xb5554c9ea27d3797cdd7b9582098bedd8e487213"),
+    policyEngine: getAddress("0x1fc164c13cdd0fb72a68b7ab29f141446613b691"),
+    orchestrator: getAddress("0x6378a86ff255107df40a8c442710a3f2dea14ded"),
+    overrideHelper: getAddress("0x47f535716d1115bb5416317b784819c934c3ced5"),
+    helperTimelock: getAddress("0xcca60edb282d18dec3d92515d2fc328e981cf56e"),
+    engineTimelock: getAddress("0x74d8a771245b836b1bf5811812025d11d056e371"),
+    orchestratorTimelock: getAddress("0x48d66185eb49999d21db44ccf5a67dc81ace2953"),
+    factoryTimelock: getAddress("0x70b081d01b7dda17e5beaf66b006e58dc18911a1"),
+    registryProxyAdmin: getAddress("0x6bd7489a9882dbf7102dc173e770963ba626f179"),
+    innerBeacon: getAddress("0x5d0d62913f3e347bfbb3289b1e74c8a3a2823201"),
+    mmfToken: getAddress("0x490b0b9396cb1b1ee717acd1376c3f21de4ee808")
+  }),
+  policies: Object.freeze({
+    TradingDisabledPolicy: getAddress("0xba5798564c819f886f93aad71a074ebc874a19e3"),
+    AllowedTransfereeTypePolicy: getAddress("0x2645026dc2eb3233bce7ead874715a485984bbc6"),
+    HolderCountCapPolicy: getAddress("0x631ccf8d3a44e5b03df176d915b09d30f34c94c3"),
+    FloorBalancePolicy: getAddress("0xcc33aa099db0cdadf0e124f9aa64cb130f0bf513"),
+    CeilingBalancePolicy: getAddress("0xb4806408c9a80442ed277df4cb33a7e6b69d1d08"),
+    DenylistPolicy: getAddress("0xfedf6f0df8473ba96bc2c379f9a41b1947a53af7"),
+    InsiderTradingFreezePolicy: getAddress("0xd560c8fb46f9d61e1067177c9ccb09ba0a4c4489"),
+    SelfTransferOnlyPolicy: getAddress("0xc1bf4aad716407984e020b38c27b165f0716265a")
+  })
+});
+
+// src/documents/sandbox-deployments.ts
+var SEPOLIA_CHAIN_ID = 11155111;
+var SANDBOX_CHAIN_ID = SEPOLIA_CHAIN_ID;
+var SANDBOX_DEPLOYMENTS = Object.freeze({
+  [SEPOLIA_CHAIN_ID]: Object.freeze({
+    chainId: SEPOLIA_CHAIN_ID,
+    allowlistRegistry: SEPOLIA_SANDBOX_MANIFEST.addresses.registry,
+    documentAttestor: SEPOLIA_SANDBOX_MANIFEST.addresses.documentAttestor
+  })
+});
+function getSandboxDeployment(chainId) {
+  return SANDBOX_DEPLOYMENTS[chainId];
+}
+function requireSandboxDeployment(chainId) {
+  const deployment = getSandboxDeployment(chainId);
+  if (deployment !== void 0) return deployment;
+  const known = Object.keys(SANDBOX_DEPLOYMENTS).join(", ");
+  throw new OpacityConfigError(
+    `No built-in sandbox deployment for chain ${chainId}. This SDK ships sandbox addresses for chain(s) ${known} only. Point the client at one of those, pass \`registryAddress\` explicitly, or rely on discovery (\`GET /chains/:chain_id/attestor\`) for a chain whose backend serves one.`
+  );
+}
+
+// src/documents/adapters.ts
+function toViemTypedData(typedData, options = {}) {
+  const record = asRecord2(typedData);
+  if (record === void 0) {
+    throw typedDataError("`typedData` is not an object.", "typedData");
+  }
+  if (record["primaryType"] !== DOCUMENT_ACCEPTANCE_PRIMARY_TYPE) {
+    throw typedDataError(
+      `\`primaryType\` must be \`${DOCUMENT_ACCEPTANCE_PRIMARY_TYPE}\`; received ${describe(record["primaryType"])}.`,
+      "typedData.primaryType"
+    );
+  }
+  const types = asRecord2(record["types"]);
+  assertAcceptanceFields(types?.[DOCUMENT_ACCEPTANCE_PRIMARY_TYPE]);
+  assertDomainFieldsIfDeclared(types?.[EIP712_DOMAIN_TYPE_NAME]);
+  const domain = asRecord2(record["domain"]);
+  if (domain === void 0) {
+    throw typedDataError("`domain` is missing or is not an object.", "typedData.domain");
+  }
+  if (domain["name"] !== DOCUMENT_ATTESTOR_DOMAIN_NAME) {
+    throw typedDataError(
+      `\`domain.name\` must be \`${DOCUMENT_ATTESTOR_DOMAIN_NAME}\`; received ${describe(domain["name"])}. A different domain name is a different contract.`,
+      "typedData.domain.name"
+    );
+  }
+  if (domain["version"] !== DOCUMENT_ATTESTOR_DOMAIN_VERSION) {
+    throw typedDataError(
+      `\`domain.version\` must be \`${DOCUMENT_ATTESTOR_DOMAIN_VERSION}\`; received ${describe(domain["version"])}.`,
+      "typedData.domain.version"
+    );
+  }
+  const chainId = assertChainId(asNumber(domain["chainId"]) ?? Number.NaN);
+  const verifyingContract = assertAddress(
+    domain["verifyingContract"],
+    "domain.verifyingContract"
+  );
+  if (options.expectedChainId !== void 0) {
+    const expected = assertChainId(options.expectedChainId);
+    if (expected !== chainId) {
+      throw typedDataError(
+        `\`domain.chainId\` is ${chainId}, but this client is pinned to ${expected}. Refusing to prompt: a signature for another chain is not the one you asked for.`,
+        "typedData.domain.chainId"
+      );
+    }
+  }
+  if (options.expectedAttestor !== void 0) {
+    const expected = assertAddress(options.expectedAttestor, "expectedAttestor");
+    if (expected !== verifyingContract) {
+      throw typedDataError(
+        `\`domain.verifyingContract\` is ${verifyingContract}, but this client is pinned to ${expected}. Refusing to prompt: the investor would be authorising a different \`DocumentAttestor\` deployment than the one this integration trusts.`,
+        "typedData.domain.verifyingContract"
+      );
+    }
+  }
+  const message = asRecord2(record["message"]);
+  if (message === void 0) {
+    throw typedDataError("`message` is missing or is not an object.", "typedData.message");
+  }
+  return {
+    domain: {
+      name: DOCUMENT_ATTESTOR_DOMAIN_NAME,
+      version: DOCUMENT_ATTESTOR_DOMAIN_VERSION,
+      chainId,
+      verifyingContract
+    },
+    types: DOCUMENT_ACCEPTANCE_TYPES,
+    primaryType: DOCUMENT_ACCEPTANCE_PRIMARY_TYPE,
+    message: {
+      nonce: assertNonce(message["nonce"]),
+      docHash: assertDocHash(message["docHash"]),
+      deadline: toDeadlineBigInt(message["deadline"])
+    }
+  };
+}
+function toEip1193TypedData(typedData, options = {}) {
+  return toEip712JsonPayload(toViemTypedData(typedData, options));
+}
+function toEip1193Json(typedData, options = {}) {
+  return toEip712Json(toViemTypedData(typedData, options));
+}
+function assertAcceptanceFields(fields) {
+  const expected = DOCUMENT_ACCEPTANCE_TYPES.DocumentAcceptance;
+  if (!Array.isArray(fields)) {
+    throw typedDataError(
+      `\`types.${DOCUMENT_ACCEPTANCE_PRIMARY_TYPE}\` is missing or is not an array.`,
+      `typedData.types.${DOCUMENT_ACCEPTANCE_PRIMARY_TYPE}`
+    );
+  }
+  if (fields.length !== expected.length) {
+    throw typedDataError(
+      `\`types.${DOCUMENT_ACCEPTANCE_PRIMARY_TYPE}\` must declare exactly ${expected.length} fields; received ${fields.length}. The field list is part of the type hash.`,
+      `typedData.types.${DOCUMENT_ACCEPTANCE_PRIMARY_TYPE}`
+    );
+  }
+  for (const [index, want] of expected.entries()) {
+    const got = asRecord2(fields[index]);
+    if (got?.["name"] !== want.name || got?.["type"] !== want.type) {
+      throw typedDataError(
+        `\`types.${DOCUMENT_ACCEPTANCE_PRIMARY_TYPE}[${index}]\` must be \`${want.type} ${want.name}\`; received \`${describe(got?.["type"])} ${describe(got?.["name"])}\`. Names, types and ORDER are all part of the type hash, so a reordered list signs a different struct.`,
+        `typedData.types.${DOCUMENT_ACCEPTANCE_PRIMARY_TYPE}[${index}]`
+      );
+    }
+  }
+}
+var EIP712_DOMAIN_TYPE_NAME = "EIP712Domain";
+function assertDomainFieldsIfDeclared(fields) {
+  if (fields === void 0) return;
+  const detail = "Declaring it differently is not additive: it replaces the domain type the wallet would derive, which changes the domain hash and therefore the digest \u2014 a well-formed signature over the wrong message, caught only when the relay simulates the attestation.";
+  const matches = Array.isArray(fields) && fields.length === EIP712_DOMAIN_TYPE.length && EIP712_DOMAIN_TYPE.every((want, index) => {
+    const got = asRecord2(fields[index]);
+    return got?.["name"] === want.name && got?.["type"] === want.type;
+  });
+  if (!matches) {
+    const encoded = EIP712_DOMAIN_TYPE.map((field) => `${field.type} ${field.name}`).join(",");
+    throw typedDataError(
+      `\`types.${EIP712_DOMAIN_TYPE_NAME}\`, when present, must be exactly \`${encoded}\`; received ${describeFieldList(fields)}. ${detail}`,
+      `typedData.types.${EIP712_DOMAIN_TYPE_NAME}`
+    );
+  }
+}
+function describeFieldList(fields) {
+  if (!Array.isArray(fields)) return describe(fields);
+  if (fields.length === 0) return "an EMPTY field list";
+  return `\`${fields.map((field) => {
+    const got = asRecord2(field);
+    return `${String(got?.["type"])} ${String(got?.["name"])}`;
+  }).join(",")}\``;
+}
+function toDeadlineBigInt(value) {
+  if (typeof value === "bigint" && value >= 0n) return value;
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return BigInt(value);
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) return BigInt(value.trim());
+  throw typedDataError(
+    `\`message.deadline\` must be a non-negative integer of unix seconds; received ${describe(value)}. The backend sends it as a DECIMAL STRING \u2014 that is the form \`eth_signTypedData_v4\` is specified in terms of \u2014 and this is where it is checked and normalised into the \`bigint\` the viem-shaped payload carries.`,
+    "typedData.message.deadline"
+  );
+}
+function typedDataError(detail, field) {
+  return new OpacityAttestationError(
+    "MalformedInput",
+    `The server's \`typedData\` cannot be trusted: ${detail} Refusing to hand it to a wallet.`,
+    { field }
+  );
+}
+function describe(value) {
+  if (typeof value === "string") return `\`${value}\``;
+  if (value === void 0) return "nothing";
+  if (value === null) return "null";
+  if (typeof value === "object") return Array.isArray(value) ? "an array" : "an object";
+  return `\`${String(value)}\``;
+}
+function asRecord2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  return value;
+}
+function asNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+
+export { SANDBOX_CHAIN_ID, SANDBOX_DEPLOYMENTS, SANDBOX_IMPLEMENTATION_VERSION, SANDBOX_TRAIT_IDS, SEPOLIA_CHAIN_ID, SEPOLIA_SANDBOX_MANIFEST, assertDocumentMatchesHash, buildAttestDocumentTransaction, buildDocumentAcceptanceTypedData, buildSandboxAddSelfTransaction, buildSandboxRegisterIssuerTransaction, buildSandboxSetSelfTraitTransaction, documentAttestorAbi, documentTraitId, getSandboxDeployment, hashDocument, hashDocumentAcceptance, probeSandboxRegistry, requireSandboxDeployment, sandboxAllowlistRegistryAbi, sandboxUserId, toEip1193Json, toEip1193TypedData, toEip712Json, toEip712JsonPayload, toEthersTypedData, toJsonRpcTransaction, toSandboxAddSelfWriteContractRequest, toSandboxRegisterIssuerWriteContractRequest, toSandboxSetSelfTraitWriteContractRequest, toViemTypedData, toWriteContractRequest, verifyAttestationSession };
+//# sourceMappingURL=chunk-7ODYBEZH.js.map
+//# sourceMappingURL=chunk-7ODYBEZH.js.map