@trusset/sdk 0.1.0 → 0.5.0

package/dist/chunk-AI4ZNJLR.js

@@ -0,0 +1,678 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/utils/errors.ts
+var TrussetError = class _TrussetError extends Error {
+  constructor(message, code, statusCode, requestId, info) {
+    super(message);
+    this.name = "TrussetError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.requestId = _nullishCoalesce(requestId, () => ( null));
+    this.details = _nullishCoalesce(_optionalChain([info, 'optionalAccess', _ => _.details]), () => ( null));
+    this.data = _nullishCoalesce(_optionalChain([info, 'optionalAccess', _2 => _2.data]), () => ( null));
+    this.retryAfter = _nullishCoalesce(_optionalChain([info, 'optionalAccess', _3 => _3.retryAfter]), () => ( null));
+    Object.setPrototypeOf(this, _TrussetError.prototype);
+  }
+};
+var AuthError = class _AuthError extends TrussetError {
+  constructor(message, requestId) {
+    super(message, "AUTH_FAILED", 401, requestId);
+    this.name = "AuthError";
+    Object.setPrototypeOf(this, _AuthError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends TrussetError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR", 400);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends TrussetError {
+  constructor(message) {
+    super(message, "NETWORK_ERROR", 0);
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+var ConfirmationError = class _ConfirmationError extends TrussetError {
+  constructor(message, code, transactions, txHash, failure) {
+    const inner = failure instanceof TrussetError ? failure : null;
+    super(message, code, inner ? inner.statusCode : 0, _nullishCoalesce(_optionalChain([inner, 'optionalAccess', _4 => _4.requestId]), () => ( void 0)), inner ? { details: inner.details, data: inner.data, retryAfter: inner.retryAfter } : void 0);
+    this.name = "ConfirmationError";
+    this.transactions = transactions;
+    this.txHash = txHash;
+    this.failure = failure;
+    Object.setPrototypeOf(this, _ConfirmationError.prototype);
+  }
+};
+
+// src/utils/keccak.ts
+var MASK = (1n << 64n) - 1n;
+var ROUND_CONSTANTS = [
+  0x0000000000000001n,
+  0x0000000000008082n,
+  0x800000000000808an,
+  0x8000000080008000n,
+  0x000000000000808bn,
+  0x0000000080000001n,
+  0x8000000080008081n,
+  0x8000000000008009n,
+  0x000000000000008an,
+  0x0000000000000088n,
+  0x0000000080008009n,
+  0x000000008000000an,
+  0x000000008000808bn,
+  0x800000000000008bn,
+  0x8000000000008089n,
+  0x8000000000008003n,
+  0x8000000000008002n,
+  0x8000000000000080n,
+  0x000000000000800an,
+  0x800000008000000an,
+  0x8000000080008081n,
+  0x8000000000008080n,
+  0x0000000080000001n,
+  0x8000000080008008n
+];
+var ROTATIONS = [
+  0,
+  1,
+  62,
+  28,
+  27,
+  36,
+  44,
+  6,
+  55,
+  20,
+  3,
+  10,
+  43,
+  25,
+  39,
+  41,
+  45,
+  15,
+  21,
+  8,
+  18,
+  2,
+  61,
+  56,
+  14
+];
+var RATE_BYTES = 136;
+function rotl(value, shift) {
+  if (shift === 0) return value;
+  const s = BigInt(shift);
+  return (value << s | value >> 64n - s) & MASK;
+}
+function permute(state) {
+  const c = new Array(5);
+  const b = new Array(25);
+  for (let round = 0; round < 24; round++) {
+    for (let x = 0; x < 5; x++) {
+      c[x] = state[x] ^ state[x + 5] ^ state[x + 10] ^ state[x + 15] ^ state[x + 20];
+    }
+    for (let x = 0; x < 5; x++) {
+      const d = c[(x + 4) % 5] ^ rotl(c[(x + 1) % 5], 1);
+      for (let y = 0; y < 25; y += 5) state[y + x] ^= d;
+    }
+    for (let x = 0; x < 5; x++) {
+      for (let y = 0; y < 5; y++) {
+        const index = x + 5 * y;
+        b[y + 5 * ((2 * x + 3 * y) % 5)] = rotl(state[index], ROTATIONS[index]);
+      }
+    }
+    for (let x = 0; x < 5; x++) {
+      for (let y = 0; y < 25; y += 5) {
+        state[y + x] = b[y + x] ^ ~b[y + (x + 1) % 5] & MASK & b[y + (x + 2) % 5];
+      }
+    }
+    state[0] ^= ROUND_CONSTANTS[round];
+  }
+}
+function keccak256(input) {
+  const padded = new Uint8Array(Math.ceil((input.length + 1) / RATE_BYTES) * RATE_BYTES);
+  padded.set(input);
+  padded[input.length] ^= 1;
+  padded[padded.length - 1] ^= 128;
+  const state = new Array(25).fill(0n);
+  for (let offset = 0; offset < padded.length; offset += RATE_BYTES) {
+    for (let lane = 0; lane < RATE_BYTES / 8; lane++) {
+      let value = 0n;
+      for (let byte = 7; byte >= 0; byte--) {
+        value = value << 8n | BigInt(padded[offset + lane * 8 + byte]);
+      }
+      state[lane] ^= value;
+    }
+    permute(state);
+  }
+  const out = new Uint8Array(32);
+  for (let lane = 0; lane < 4; lane++) {
+    let value = state[lane];
+    for (let byte = 0; byte < 8; byte++) {
+      out[lane * 8 + byte] = Number(value & 0xffn);
+      value >>= 8n;
+    }
+  }
+  return out;
+}
+function keccak256Hex(text) {
+  const bytes = keccak256(new TextEncoder().encode(text));
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function toChecksumAddress(address) {
+  const lower = address.toLowerCase().replace(/^0x/, "");
+  const hash = keccak256Hex(lower);
+  let out = "0x";
+  for (let i = 0; i < lower.length; i++) {
+    out += parseInt(hash[i], 16) >= 8 ? lower[i].toUpperCase() : lower[i];
+  }
+  return out;
+}
+
+// src/utils/validation.ts
+var ETH_ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+var BYTES32_RE = /^0x[0-9a-fA-F]{64}$/;
+function requireString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new ValidationError(`${field} is required and must be a non-empty string`);
+  }
+  return value.trim();
+}
+function requireAddress(value, field) {
+  const s = requireString(value, field);
+  if (!ETH_ADDRESS_RE.test(s)) {
+    throw new ValidationError(`${field} must be a valid Ethereum address`);
+  }
+  return s;
+}
+function optionalAddress(value, field) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  return requireAddress(value, field);
+}
+function requireCountry(value, field) {
+  const s = requireString(value, field);
+  if (s.length < 2 || s.length > 3) {
+    throw new ValidationError(`${field} must be a 2-3 letter country code`);
+  }
+  return s.toUpperCase();
+}
+function requireHash(value, field) {
+  const s = requireString(value, field);
+  if (!BYTES32_RE.test(s)) {
+    throw new ValidationError(`${field} must be a 32-byte hex string (0x + 64 hex chars)`);
+  }
+  return s;
+}
+function optionalHash(value, field) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  return requireHash(value, field);
+}
+function clampInt(value, min, max, fallback) {
+  if (value === void 0 || value === null) return fallback;
+  const n = Math.floor(value);
+  if (isNaN(n)) return fallback;
+  return Math.max(min, Math.min(max, n));
+}
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var DECIMAL_RE = /^\d+(\.\d+)?$/;
+var INTEGER_STRING_RE = /^\d+$/;
+var ID_RE = /^[A-Za-z0-9_-]{1,100}$/;
+function requireWallet(value, field, options = {}) {
+  if (value === void 0 || value === null || typeof value === "string" && value.trim() === "") {
+    throw new ValidationError(`${field} is required`);
+  }
+  const raw = typeof value === "string" ? value.trim() : "";
+  if (!ETH_ADDRESS_RE.test(raw)) {
+    throw new ValidationError(`${field} must be a 42-character address: 0x followed by 40 hex characters`);
+  }
+  if (!options.allowZero && raw.toLowerCase() === ZERO_ADDRESS) {
+    throw new ValidationError(`${field} must not be the zero address`);
+  }
+  const body = raw.slice(2);
+  const mixedCase = body !== body.toLowerCase() && body !== body.toUpperCase();
+  if (mixedCase && toChecksumAddress(raw) !== raw) {
+    throw new ValidationError(`${field} fails its EIP-55 checksum, which almost always means a character was mistyped. Check it against its source, or send it in all-lowercase`);
+  }
+  return raw;
+}
+function optionalWallet(value, field, options = {}) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  return requireWallet(value, field, options);
+}
+function requireAmount(value, field, options = {}) {
+  if (typeof value !== "string") {
+    throw new ValidationError(`${field} must be a decimal string such as "100" or "12.5", never a JavaScript number`);
+  }
+  const s = value.trim();
+  if (!DECIMAL_RE.test(s)) {
+    throw new ValidationError(`${field} must be written as digits with an optional decimal fraction, such as "100" or "12.5"`);
+  }
+  if (!options.allowZero && !/[1-9]/.test(s)) {
+    throw new ValidationError(`${field} must be greater than zero`);
+  }
+  return s;
+}
+function optionalAmount(value, field, options = {}) {
+  if (value === void 0 || value === null) return void 0;
+  return requireAmount(value, field, options);
+}
+function requireIntegerString(value, field) {
+  if (typeof value !== "string" || !INTEGER_STRING_RE.test(value.trim())) {
+    throw new ValidationError(`${field} must be a whole number written as a string of digits`);
+  }
+  return value.trim();
+}
+function requireInt(value, field, min, max) {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw new ValidationError(`${field} must be a whole number`);
+  }
+  if (value < min || value > max) {
+    throw new ValidationError(`${field} must be between ${min} and ${max}`);
+  }
+  return value;
+}
+function optionalInt(value, field, min, max) {
+  if (value === void 0 || value === null) return void 0;
+  return requireInt(value, field, min, max);
+}
+function requireBoolean(value, field) {
+  if (typeof value !== "boolean") {
+    throw new ValidationError(`${field} must be true or false`);
+  }
+  return value;
+}
+function optionalBoolean(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  return requireBoolean(value, field);
+}
+function requireOneOf(value, field, allowed) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new ValidationError(`${field} must be one of ${allowed.join(", ")}`);
+  }
+  return value;
+}
+function optionalOneOf(value, field, allowed) {
+  if (value === void 0 || value === null) return void 0;
+  return requireOneOf(value, field, allowed);
+}
+function requireTxHash(value, field = "txHash") {
+  if (typeof value !== "string" || !BYTES32_RE.test(value.trim())) {
+    throw new ValidationError(`${field} must be the hash of the broadcast transaction: 0x followed by 64 hex characters`);
+  }
+  return value.trim();
+}
+function requirePositiveId(value, field) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value > 0) return String(value);
+  if (typeof value === "string" && INTEGER_STRING_RE.test(value.trim()) && Number(value.trim()) > 0 && Number.isSafeInteger(Number(value.trim()))) {
+    return value.trim();
+  }
+  throw new ValidationError(`${field} must be a positive whole number`);
+}
+function requireMarketId(value) {
+  const s = requireString(value, "marketId");
+  if (ETH_ADDRESS_RE.test(s)) {
+    throw new ValidationError("marketId is the market record id that lending.markets.list() returns, not the contract address. Routes keyed by a contract address take marketAddress instead");
+  }
+  if (s.length > 100) {
+    throw new ValidationError("marketId must be at most 100 characters");
+  }
+  return s;
+}
+function requireRecordId(value, field) {
+  const s = requireString(value, field);
+  if (!ID_RE.test(s)) {
+    throw new ValidationError(`${field} must be the record id the API returned (letters, digits, underscores and hyphens, at most 100 characters)`);
+  }
+  return s;
+}
+function sameAddress(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function assertInputIsNotOptions(input, example) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return;
+  const misplaced = ["signer", "txHash"].filter((key) => key in input);
+  if (misplaced.length > 0) {
+    throw new ValidationError(`${misplaced.join(" and ")} ${misplaced.length > 1 ? "go" : "goes"} in the options argument, the last one: ${example}. Passed in the input slot, nothing is signed or confirmed`);
+  }
+}
+function checkSignedPrice(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "object") throw new ValidationError("signedPrice must be the { price, timestamp, validUntil, signature } object the price signer produced");
+  if (typeof value.price !== "string" || !/^\d+$/.test(value.price)) throw new ValidationError("signedPrice.price must be the raw integer price as a string of digits");
+  requireInt(value.timestamp, "signedPrice.timestamp", 1, Number.MAX_SAFE_INTEGER);
+  requireInt(value.validUntil, "signedPrice.validUntil", 1, Number.MAX_SAFE_INTEGER);
+  if (typeof value.signature !== "string" || !/^0x[0-9a-fA-F]*$/.test(value.signature)) throw new ValidationError("signedPrice.signature must be 0x-prefixed hex");
+  return value;
+}
+
+// src/utils/sign.ts
+function requireSigner(signer) {
+  if (!signer || typeof signer.sendTransaction !== "function") {
+    throw new ValidationError("signer must be a wallet that can send transactions (an ethers v5 Signer)");
+  }
+  return signer;
+}
+
+// src/utils/flow.ts
+var DEFAULT_CONFIRMATIONS = 1;
+var MAX_CONFIRMATIONS = 12;
+var GAS_HEADROOM_PERCENT = 150n;
+var ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+var HEX_RE = /^0x[0-9a-fA-F]*$/;
+function isSignOptions(options) {
+  return Boolean(options && typeof options === "object" && "signer" in options);
+}
+function isConfirmOptions(options) {
+  return Boolean(options && typeof options === "object" && "txHash" in options && !("signer" in options));
+}
+function confirmHashOf(options) {
+  return requireTxHash(options.txHash);
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function numberOf(value) {
+  if (typeof value === "number" && Number.isInteger(value)) return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) return Number(value);
+  return void 0;
+}
+function quantityOf(value) {
+  if (typeof value === "string" && value.trim() !== "") return value.trim();
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "bigint") return value.toString();
+  return void 0;
+}
+function transactionOf(raw, chainHint) {
+  const inner = _nullishCoalesce(asRecord(raw.transaction), () => ( raw));
+  const data = inner.data;
+  if (typeof data !== "string" || !HEX_RE.test(data)) return null;
+  const create = inner.create === true || raw.create === true || inner.to === null;
+  if (create && data.length <= 2) return null;
+  const to = inner.to;
+  if (!create && (typeof to !== "string" || !ADDRESS_RE.test(to))) return null;
+  const tx = { data };
+  if (!create) tx.to = to;
+  const value = quantityOf(inner.value);
+  if (value !== void 0) tx.value = value;
+  const chainId = _nullishCoalesce(_nullishCoalesce(numberOf(inner.chainId), () => ( numberOf(raw.chainId))), () => ( chainHint));
+  if (chainId !== void 0) tx.chainId = chainId;
+  const gasLimit = quantityOf(inner.gasLimit);
+  if (gasLimit !== void 0) tx.gasLimit = gasLimit;
+  return tx;
+}
+function functionNameOf(raw) {
+  if (typeof raw.functionName === "string") return raw.functionName;
+  if (typeof raw.key === "string") return raw.key;
+  const inner = asRecord(raw.transaction);
+  return inner && typeof inner.functionName === "string" ? inner.functionName : null;
+}
+function planOf(payload, options = {}) {
+  const p = asRecord(payload);
+  if (!p) return null;
+  const chainHint = numberOf(p.chainId);
+  const batch = p.mode === "batch";
+  if (Array.isArray(p.steps)) {
+    const optionalIndexes = new Set(Array.isArray(p.optionalStepIndexes) ? p.optionalStepIndexes.filter((n) => typeof n === "number") : []);
+    const steps = [];
+    p.steps.forEach((entry, index) => {
+      const raw = asRecord(entry);
+      const transaction = raw ? transactionOf(raw, chainHint) : null;
+      if (!raw || !transaction) {
+        throw new TrussetError(`Step ${index + 1} of the prepared plan carries no transaction the SDK can sign`, "UNSIGNABLE_STEP", 0);
+      }
+      steps.push({ transaction, functionName: functionNameOf(raw), optional: raw.optional === true || optionalIndexes.has(index) });
+    });
+    if (steps.length === 0) return null;
+    return { steps, confirmIndex: resolveConfirmIndex(p, steps, options), batch };
+  }
+  for (const candidate of [p.transaction ? p : null, asRecord(p.calldata), p]) {
+    if (!candidate) continue;
+    const transaction = transactionOf(candidate, chainHint);
+    if (transaction) {
+      const step = { transaction, functionName: _nullishCoalesce(functionNameOf(p), () => ( functionNameOf(candidate))), optional: false };
+      return { steps: [step], confirmIndex: options.confirmIndex === null ? null : 0, batch };
+    }
+  }
+  return null;
+}
+function resolveConfirmIndex(p, steps, options) {
+  if (options.confirmIndex === null) return null;
+  if (typeof options.confirmIndex === "number") return options.confirmIndex;
+  if (options.confirmIndex !== "last" && typeof p.confirmStepIndex === "number" && p.confirmStepIndex >= 0 && p.confirmStepIndex < steps.length) {
+    return p.confirmStepIndex;
+  }
+  for (let i = steps.length - 1; i >= 0; i--) {
+    if (!steps[i].optional) return i;
+  }
+  return steps.length - 1;
+}
+async function signerChainId(signer) {
+  if (typeof signer.getChainId === "function") return Number(await signer.getChainId());
+  const provider = signer.provider;
+  if (provider && typeof provider.getNetwork === "function") return Number((await provider.getNetwork()).chainId);
+  throw new ValidationError("signer must expose getChainId() so the SDK can check it is on the instance network (any ethers v5 Signer does)");
+}
+async function signerAddress(signer) {
+  if (typeof signer.getAddress !== "function") {
+    throw new ValidationError("signer must expose getAddress() (any ethers v5 Signer does)");
+  }
+  return await signer.getAddress();
+}
+async function walletOf(options, provided, field) {
+  const address = await signerAddress(requireSigner(options.signer));
+  if (provided !== void 0 && !sameAddress(provided, address)) {
+    throw new ValidationError(`${field} ${provided} is not the signer's wallet ${address}. The API checks balances, allowances and roles from ${field}, so it must be the wallet that signs`);
+  }
+  return _nullishCoalesce(provided, () => ( address));
+}
+async function assertChain(source, signer, stamped) {
+  const instanceChain = await source.instanceChainId();
+  for (const chainId of stamped) {
+    if (chainId !== void 0 && chainId !== instanceChain) {
+      throw new TrussetError(`The prepared transaction names chain ${chainId}, but this instance runs on chain ${instanceChain}. Nothing was signed`, "CHAIN_MISMATCH", 0);
+    }
+  }
+  const signerChain = await signerChainId(signer);
+  if (signerChain !== instanceChain) {
+    throw new ValidationError(`The signer is connected to chain ${signerChain}, but this instance's transactions are for chain ${instanceChain}. Connect the signer to chain ${instanceChain}; the SDK never switches networks`);
+  }
+  return instanceChain;
+}
+function errorText(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    if (typeof e.reason === "string") return e.reason;
+    if (typeof e.code === "string" && typeof e.message === "string") return `${e.code}: ${e.message.split("\n")[0].slice(0, 200)}`;
+    if (typeof e.message === "string") return e.message.split("\n")[0].slice(0, 200);
+  }
+  return String(err);
+}
+async function sendAndWait(signer, transaction, chainId, confirmations) {
+  const request = { data: transaction.data, chainId };
+  if (transaction.to !== void 0) request.to = transaction.to;
+  if (transaction.value !== void 0) request.value = transaction.value;
+  if (transaction.gasLimit !== void 0) request.gasLimit = transaction.gasLimit;
+  else if (typeof signer.estimateGas === "function") {
+    const estimate = BigInt((await signer.estimateGas({ ...request })).toString());
+    request.gasLimit = ((estimate * GAS_HEADROOM_PERCENT + 99n) / 100n).toString();
+  }
+  const sent = await signer.sendTransaction(request);
+  try {
+    await sent.wait(confirmations);
+    return { hash: sent.hash };
+  } catch (err) {
+    const e = err;
+    if (e && e.code === "TRANSACTION_REPLACED" && e.cancelled === false && _optionalChain([e, 'access', _5 => _5.receipt, 'optionalAccess', _6 => _6.status]) === 1 && typeof _optionalChain([e, 'access', _7 => _7.replacement, 'optionalAccess', _8 => _8.hash]) === "string") {
+      return { hash: e.replacement.hash };
+    }
+    return { hash: sent.hash, error: err };
+  }
+}
+async function preflightChain(source, options) {
+  await assertChain(source, requireSigner(options.signer), []);
+}
+async function execute(source, plan, options) {
+  const signer = requireSigner(options.signer);
+  if (plan.batch) {
+    throw new ValidationError("This plan is a batch for one atomic wallet bundle (wallet_sendCalls). Prepare it without a signer, send it from a wallet that bundles calls, and confirm with { txHash } of the bundle transaction");
+  }
+  const confirmations = clampInt(options.confirmations, 1, MAX_CONFIRMATIONS, DEFAULT_CONFIRMATIONS);
+  const chainId = await assertChain(source, signer, plan.steps.map((s) => s.transaction.chainId));
+  const transactions = [];
+  for (let i = 0; i < plan.steps.length; i++) {
+    const step = plan.steps[i];
+    const broadcastSoFar = transactions.some((t) => t.txHash !== null);
+    let outcome;
+    try {
+      outcome = await sendAndWait(signer, step.transaction, chainId, confirmations);
+    } catch (err) {
+      outcome = { hash: null, error: err };
+    }
+    if (outcome.error === void 0) {
+      transactions.push({ functionName: step.functionName, txHash: outcome.hash, optional: step.optional });
+      continue;
+    }
+    transactions.push({ functionName: step.functionName, txHash: outcome.hash, optional: step.optional, error: errorText(outcome.error) });
+    if (step.optional) continue;
+    if (!broadcastSoFar && outcome.hash === null) throw outcome.error;
+    throw new ConfirmationError(
+      `Step ${i + 1} (${_nullishCoalesce(step.functionName, () => ( "transaction"))}) did not complete: ${errorText(outcome.error)}. ${broadcastSoFar ? "Earlier steps of this plan are already on chain; " : ""}see err.transactions for every hash sent`,
+      "TRANSACTION_FAILED",
+      transactions,
+      outcome.hash,
+      outcome.error
+    );
+  }
+  const confirmHash = plan.confirmIndex === null ? null : _nullishCoalesce(_optionalChain([transactions, 'access', _9 => _9[plan.confirmIndex], 'optionalAccess', _10 => _10.txHash]), () => ( null));
+  return { transactions, confirmHash };
+}
+async function confirmExecuted(executed, run) {
+  const hash = executed.confirmHash;
+  if (!hash) {
+    throw new ConfirmationError("The plan finished without a transaction to confirm. See err.transactions", "CONFIRMATION_FAILED", executed.transactions, null, null);
+  }
+  try {
+    const result = await run(hash);
+    return attachTransactions(result, executed.transactions);
+  } catch (err) {
+    throw new ConfirmationError(
+      `Transaction ${hash} is on chain but Trusset has not recorded it: ${errorText(err)}. Confirm it again with { txHash: '${hash}' }`,
+      "CONFIRMATION_FAILED",
+      executed.transactions,
+      hash,
+      err
+    );
+  }
+}
+function attachTransactions(result, transactions) {
+  const base = result && typeof result === "object" ? result : { result };
+  return { ...base, transactions };
+}
+async function signTypedData(source, options, typedData) {
+  const signer = requireSigner(options.signer);
+  if (typeof signer._signTypedData !== "function") {
+    throw new ValidationError("signer must support EIP-712 typed data (_signTypedData, as every ethers v5 Wallet and JsonRpcSigner does)");
+  }
+  await assertChain(source, signer, [numberOf(_optionalChain([typedData, 'access', _11 => _11.domain, 'optionalAccess', _12 => _12.chainId]))]);
+  const types = { ...typedData.types };
+  delete types.EIP712Domain;
+  return await signer._signTypedData(typedData.domain, types, typedData.message);
+}
+async function signMessage(source, options, message) {
+  const signer = requireSigner(options.signer);
+  if (typeof signer.signMessage !== "function") {
+    throw new ValidationError("signer must support signMessage (every ethers v5 Signer does)");
+  }
+  await assertChain(source, signer, []);
+  return await signer.signMessage(message);
+}
+function splitSignature(signature) {
+  const hex = typeof signature === "string" ? signature.trim() : "";
+  if (/^0x[0-9a-fA-F]{130}$/.test(hex)) {
+    let v = parseInt(hex.slice(130, 132), 16);
+    if (v < 27) v += 27;
+    if (v !== 27 && v !== 28) throw new ValidationError("The signature carries an invalid recovery id");
+    return { v, r: `0x${hex.slice(2, 66)}`, s: `0x${hex.slice(66, 130)}` };
+  }
+  if (/^0x[0-9a-fA-F]{128}$/.test(hex)) {
+    const yParityAndS = BigInt(`0x${hex.slice(66, 130)}`);
+    const yParity = yParityAndS >> 255n;
+    const s = yParityAndS & (1n << 255n) - 1n;
+    return { v: yParity === 1n ? 28 : 27, r: `0x${hex.slice(2, 66)}`, s: `0x${s.toString(16).padStart(64, "0")}` };
+  }
+  throw new ValidationError("The signature must be 65 bytes (or 64 bytes in EIP-2098 compact form) of hex");
+}
+
+// src/utils/chain.ts
+var InstanceChain = class {
+  constructor(http) {
+    this.http = http;
+    this.chain = null;
+  }
+  instanceChainId() {
+    if (!this.chain) {
+      const pending = this.http.get("/instances/api/info").then((info) => {
+        const id = _optionalChain([info, 'optionalAccess', _13 => _13.network, 'optionalAccess', _14 => _14.chainId]);
+        if (typeof id !== "number" || !Number.isInteger(id)) {
+          throw new TrussetError("This instance runs on a network without an EVM chain id, so nothing can be signed for it", "CHAIN_UNRESOLVED", 0);
+        }
+        return id;
+      });
+      pending.catch(() => {
+        this.chain = null;
+      });
+      this.chain = pending;
+    }
+    return this.chain;
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.TrussetError = TrussetError; exports.AuthError = AuthError; exports.ValidationError = ValidationError; exports.NetworkError = NetworkError; exports.ConfirmationError = ConfirmationError; exports.requireString = requireString; exports.requireAddress = requireAddress; exports.optionalAddress = optionalAddress; exports.requireCountry = requireCountry; exports.requireHash = requireHash; exports.optionalHash = optionalHash; exports.clampInt = clampInt; exports.requireWallet = requireWallet; exports.optionalWallet = optionalWallet; exports.requireAmount = requireAmount; exports.optionalAmount = optionalAmount; exports.requireIntegerString = requireIntegerString; exports.requireInt = requireInt; exports.optionalInt = optionalInt; exports.requireBoolean = requireBoolean; exports.optionalBoolean = optionalBoolean; exports.requireOneOf = requireOneOf; exports.optionalOneOf = optionalOneOf; exports.requireTxHash = requireTxHash; exports.requirePositiveId = requirePositiveId; exports.requireMarketId = requireMarketId; exports.requireRecordId = requireRecordId; exports.sameAddress = sameAddress; exports.assertInputIsNotOptions = assertInputIsNotOptions; exports.checkSignedPrice = checkSignedPrice; exports.InstanceChain = InstanceChain; exports.requireSigner = requireSigner; exports.isSignOptions = isSignOptions; exports.isConfirmOptions = isConfirmOptions; exports.confirmHashOf = confirmHashOf; exports.planOf = planOf; exports.signerAddress = signerAddress; exports.walletOf = walletOf; exports.preflightChain = preflightChain; exports.execute = execute; exports.confirmExecuted = confirmExecuted; exports.attachTransactions = attachTransactions; exports.signTypedData = signTypedData; exports.signMessage = signMessage; exports.splitSignature = splitSignature;