@tokenops/sdk 1.0.0

package/dist/chunk-VDXVNZCO.cjs

@@ -0,0 +1,329 @@
+'use strict';
+
+var chunk56UI7LUR_cjs = require('./chunk-56UI7LUR.cjs');
+var viem = require('viem');
+
+// src/core/version.ts
+var SDK_VERSION = "1.0.0";
+function mapContractRevert(error, args) {
+  if (error instanceof chunk56UI7LUR_cjs.TokenOpsSdkError) return error;
+  const ctx = {
+    method: args.method,
+    contractAddress: args.contractAddress,
+    productContext: args.productContext
+  };
+  const reverted = findRevertedError(error);
+  if (!reverted) {
+    return classifyNonRevert(error, args);
+  }
+  let revertName = reverted.data?.errorName;
+  let revertArgs = reverted.data?.args;
+  let revertSelector;
+  const rawRevertData = reverted.raw;
+  const revertReason = reverted.reason;
+  if (revertName === void 0 && rawRevertData !== void 0 && rawRevertData.length >= 10) {
+    revertSelector = rawRevertData.slice(0, 10);
+    try {
+      const decoded = viem.decodeErrorResult({ abi: args.abi, data: rawRevertData });
+      revertName = decoded.errorName;
+      revertArgs = decoded.args;
+    } catch {
+    }
+  } else if (revertSelector === void 0 && rawRevertData !== void 0) {
+    revertSelector = rawRevertData.slice(0, 10);
+  }
+  if (revertName !== void 0) {
+    const fromProduct = args.productMapper?.(revertName, revertArgs, ctx);
+    if (fromProduct) return attachCause(fromProduct, error);
+    const fromDefault = defaultRevertNameMapper(revertName, revertArgs, ctx, args.account);
+    if (fromDefault) return attachCause(fromDefault, error);
+  }
+  return new chunk56UI7LUR_cjs.ContractRevertError({
+    method: args.method,
+    contractAddress: args.contractAddress,
+    revertName,
+    revertSelector,
+    revertArgs,
+    revertReason,
+    rawRevertData,
+    cause: error
+  });
+}
+function attachCause(err, cause) {
+  if (err.cause === void 0) {
+    Object.defineProperty(err, "cause", {
+      value: cause,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  return err;
+}
+function defaultRevertNameMapper(name, errArgs, ctx, account) {
+  switch (name) {
+    // OpenZeppelin / cross-product structural errors.
+    case "EnforcedPause":
+    case "PausableUpgradeable__Paused":
+    case "ClaimsPaused":
+      return new chunk56UI7LUR_cjs.PausedError(ctx);
+    case "AccessControlUnauthorizedAccount": {
+      const acct = errArgs?.[0] ?? account;
+      const role = errArgs?.[1];
+      return new chunk56UI7LUR_cjs.AccessDeniedError({ ...ctx, account: acct, role });
+    }
+    case "AccessControlBadConfirmation":
+      return new chunk56UI7LUR_cjs.InvalidArgumentError({
+        method: ctx.method,
+        argument: "callerConfirmation",
+        reason: "must equal msg.sender for renounceRole"
+      });
+    case "InvalidInitialization":
+    case "Initializable_InvalidInitialization":
+      return new chunk56UI7LUR_cjs.AlreadyInitializedError(ctx);
+    case "ReentrancyGuardReentrantCall":
+    case "ReentrancyGuardTransient":
+      return new chunk56UI7LUR_cjs.ReentrancyError(ctx);
+    // Cross-product custom errors with stable, unambiguous meaning.
+    case "InsufficientFee":
+    case "InsufficientGasFee":
+      return new chunk56UI7LUR_cjs.InsufficientFeeError({ ...ctx, feeKind: "gas" });
+    case "InsufficientAmount": {
+      const provided = errArgs?.[0];
+      const required = errArgs?.[1];
+      return new chunk56UI7LUR_cjs.InsufficientFeeError({ ...ctx, feeKind: "gas", required, provided });
+    }
+    case "ZeroBalance":
+    case "InsufficientBalance":
+      return new chunk56UI7LUR_cjs.InsufficientBalanceError({ ...ctx, balanceKind: "eth" });
+    case "BatchTooLarge": {
+      const requested = Number(errArgs?.[0] ?? 0);
+      const max = errArgs?.[1] ?? 0n;
+      return new chunk56UI7LUR_cjs.BatchTooLargeError({ ...ctx, requested, max });
+    }
+    case "SplitDisabled":
+      return new chunk56UI7LUR_cjs.FeatureDisabledError({ ...ctx, feature: "split" });
+    case "PausableDisabled":
+      return new chunk56UI7LUR_cjs.FeatureDisabledError({ ...ctx, feature: "pause" });
+    case "ExtensionNotAllowed":
+      return new chunk56UI7LUR_cjs.FeatureDisabledError({ ...ctx, feature: "extendClaimWindow" });
+    case "TransferFailed":
+      return new chunk56UI7LUR_cjs.TransferFailedError({ ...ctx, asset: "eth" });
+    case "HandleNotAllowed":
+      return new chunk56UI7LUR_cjs.FheHandleNotAllowedError({ ...ctx, account });
+    case "SenderNotAllowedToUseHandle": {
+      const handle = errArgs?.[0];
+      const sender = errArgs?.[1] ?? account;
+      return new chunk56UI7LUR_cjs.FheHandleNotAllowedError({ ...ctx, handle, account: sender });
+    }
+    case "SenderNotAllowed": {
+      const sender = errArgs?.[0] ?? account;
+      return new chunk56UI7LUR_cjs.FheHandleNotAllowedError({ ...ctx, account: sender });
+    }
+    case "InvalidSignature":
+      return new chunk56UI7LUR_cjs.InvalidSignatureError(ctx);
+    // Range / arg-validation reverts the SDK should already have caught in
+    // preflight or input validation. If they slip through, surface them as
+    // structural `InvalidArgumentError` so consumers see `TOKENOPS_INVALID_ARGUMENT`
+    // rather than a generic contract-revert message.
+    case "InvalidAddress":
+    case "InvalidAdmin":
+    case "InvalidFeeCollector":
+    case "InvalidRecipient":
+    case "InvalidToken":
+    case "InvalidParty":
+    case "InvalidStartTime":
+    case "EndTimeInPast":
+    case "InvalidDuration":
+    case "InvalidTimestamps":
+    case "InvalidBps":
+    case "InvalidFeeBps":
+    case "TokenFeeTooHigh":
+    case "CliffExceedsDuration":
+    case "TimelockOverflow":
+    case "InvalidTransferDuration":
+    case "InvalidSplitDenominator":
+    case "InvalidMaxBatchSize":
+    case "InvalidWalletIndex":
+    case "CannotTransferToSelf":
+    case "CannotTransferToZero":
+    case "SameToken":
+    case "UnexpectedETH":
+    case "EmptyBatch":
+    case "EmptyRecipients":
+    case "ZeroAddressRecipient":
+    case "ArrayLengthMismatch":
+    case "VestingIdsNotStrictlyAsc":
+    case "CustomFeeNotSet":
+      return new chunk56UI7LUR_cjs.InvalidArgumentError({
+        method: ctx.method,
+        argument: invalidArgumentLabelFor(name),
+        reason: `the contract reverted with \`${name}\`. If you did not pass an invalid value, this may be an SDK bug \u2014 please file an issue.`
+      });
+    default:
+      return void 0;
+  }
+}
+function invalidArgumentLabelFor(revertName) {
+  switch (revertName) {
+    case "InvalidAddress":
+      return "address";
+    case "InvalidAdmin":
+      return "admin";
+    case "InvalidFeeCollector":
+      return "feeCollector";
+    case "InvalidRecipient":
+    case "ZeroAddressRecipient":
+      return "recipient";
+    case "InvalidToken":
+    case "SameToken":
+      return "token";
+    case "InvalidParty":
+      return "party";
+    case "InvalidStartTime":
+      return "startTime";
+    case "EndTimeInPast":
+      return "endTime";
+    case "InvalidDuration":
+    case "InvalidTransferDuration":
+      return "duration";
+    case "InvalidTimestamps":
+      return "timestamps";
+    case "InvalidBps":
+    case "InvalidFeeBps":
+    case "TokenFeeTooHigh":
+      return "feeBps";
+    case "CliffExceedsDuration":
+      return "cliff";
+    case "TimelockOverflow":
+      return "timelock";
+    case "InvalidSplitDenominator":
+      return "splitDenominator";
+    case "InvalidMaxBatchSize":
+      return "maxBatchSize";
+    case "InvalidWalletIndex":
+      return "walletIndex";
+    case "CannotTransferToSelf":
+    case "CannotTransferToZero":
+      return "to";
+    case "UnexpectedETH":
+      return "msg.value";
+    case "EmptyBatch":
+    case "EmptyRecipients":
+      return "recipients";
+    case "ArrayLengthMismatch":
+      return "arguments";
+    case "VestingIdsNotStrictlyAsc":
+      return "vestingIds";
+    case "CustomFeeNotSet":
+      return "user";
+    default:
+      return "input";
+  }
+}
+function isContractRevert(error) {
+  if (!(error instanceof viem.BaseError)) return false;
+  const frame = error.walk((e) => e instanceof viem.ContractFunctionRevertedError);
+  return frame instanceof viem.ContractFunctionRevertedError;
+}
+function classifyNonRevert(error, args) {
+  if (!(error instanceof viem.BaseError)) {
+    return new chunk56UI7LUR_cjs.UnknownWriteFailureError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      cause: error
+    });
+  }
+  const walk = (predicate) => {
+    const frame = error.walk((f) => predicate(f));
+    return predicate(frame) ? frame : void 0;
+  };
+  if (walk((e) => e instanceof viem.UserRejectedRequestError) || walk((e) => e instanceof viem.TransactionRejectedRpcError)) {
+    return new chunk56UI7LUR_cjs.WalletRejectedError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      cause: error
+    });
+  }
+  if (walk((e) => e instanceof viem.ChainMismatchError)) {
+    return new chunk56UI7LUR_cjs.WalletChainMismatchError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      cause: error
+    });
+  }
+  if (walk((e) => e instanceof viem.InsufficientFundsError)) {
+    return new chunk56UI7LUR_cjs.InsufficientGasFundsError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      cause: error
+    });
+  }
+  const httpFrame = walk((e) => e instanceof viem.HttpRequestError);
+  if (httpFrame) {
+    return new chunk56UI7LUR_cjs.NetworkError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      statusCode: httpFrame.status,
+      cause: error
+    });
+  }
+  if (walk((e) => e instanceof viem.TimeoutError)) {
+    return new chunk56UI7LUR_cjs.NetworkError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      cause: error
+    });
+  }
+  return new chunk56UI7LUR_cjs.UnknownWriteFailureError({
+    method: args.method,
+    contractAddress: args.contractAddress,
+    cause: error
+  });
+}
+function findRevertedError(err) {
+  if (!(err instanceof viem.BaseError)) {
+    if (err instanceof Error) {
+      const hex = coerceRevertHex(err.data);
+      if (hex) return { raw: hex };
+    }
+    return void 0;
+  }
+  const frame = err.walk((f) => f instanceof viem.ContractFunctionRevertedError);
+  if (frame instanceof viem.ContractFunctionRevertedError) {
+    const data = frame.data ? {
+      errorName: frame.data.errorName,
+      args: frame.data.args
+    } : void 0;
+    return {
+      data,
+      raw: frame.raw,
+      reason: frame.reason
+    };
+  }
+  let cursor = err;
+  const seen = /* @__PURE__ */ new Set();
+  while (cursor && !seen.has(cursor)) {
+    seen.add(cursor);
+    const hex = coerceRevertHex(cursor.data);
+    if (hex) return { raw: hex };
+    cursor = cursor.cause;
+  }
+  return void 0;
+}
+function coerceRevertHex(value) {
+  if (typeof value === "string" && value.startsWith("0x") && value.length >= 10) {
+    return value;
+  }
+  if (value !== null && typeof value === "object" && "data" in value) {
+    const nested = value.data;
+    if (typeof nested === "string" && nested.startsWith("0x") && nested.length >= 10) {
+      return nested;
+    }
+  }
+  return void 0;
+}
+
+exports.SDK_VERSION = SDK_VERSION;
+exports.isContractRevert = isContractRevert;
+exports.mapContractRevert = mapContractRevert;

package/dist/chunk-VJKZWYYJ.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+// src/core/telemetry.ts
+var NoopTelemetry = class {
+  event() {
+  }
+  async span(_name, fn) {
+    return fn();
+  }
+  error() {
+  }
+  /**
+   * No-op telemetry has no state to carry — returning `this` is correct and
+   * avoids a per-request allocation. Consumers that swap to a real adapter
+   * will get a fresh child instance per call.
+   */
+  scope(_tags) {
+    return this;
+  }
+};
+async function withTelemetry(telemetry, name, fn) {
+  const t = telemetry ?? new NoopTelemetry();
+  try {
+    return await t.span(name, fn);
+  } catch (err) {
+    t.error(err instanceof Error ? err : new Error(String(err)), { span: name });
+    throw err;
+  }
+}
+
+exports.NoopTelemetry = NoopTelemetry;
+exports.withTelemetry = withTelemetry;

package/dist/chunk-WRCUDSUJ.js

@@ -0,0 +1,96 @@
+import { normaliseAddress } from './chunk-BE2AIZ3K.js';
+import { withTelemetry } from './chunk-Q2GP5UDC.js';
+import { TokenOpsContractError } from './chunk-IVE3QEGD.js';
+
+// src/fhe/operators.ts
+var ERC7984_SET_OPERATOR_ABI = [
+  {
+    type: "function",
+    name: "setOperator",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "until", type: "uint48" }
+    ],
+    outputs: []
+  }
+];
+var ERC7984_OPERATOR_MAX_DEADLINE = (1n << 48n) - 1n;
+async function setOperator(args) {
+  const { publicClient, walletClient, account, waitForReceipt = true, telemetry } = args;
+  const token = normaliseAddress(args.token);
+  const spender = normaliseAddress(args.spender);
+  const deadline = args.deadline ?? ERC7984_OPERATOR_MAX_DEADLINE;
+  return withTelemetry(telemetry, "fhe.setOperator", async () => {
+    const fromAccount = account ?? walletClient.account;
+    if (!fromAccount) {
+      throw new TokenOpsContractError(
+        "setOperator: no account available \u2014 pass `account` explicitly or attach an account to the walletClient",
+        { contract: "ERC7984", call: "setOperator" }
+      );
+    }
+    if (deadline < 0n || deadline > ERC7984_OPERATOR_MAX_DEADLINE) {
+      throw new TokenOpsContractError(
+        `setOperator: deadline ${deadline} out of uint48 range [0, ${ERC7984_OPERATOR_MAX_DEADLINE}]`,
+        { contract: "ERC7984", call: "setOperator", deadline: deadline.toString() }
+      );
+    }
+    const deadlineNum = Number(deadline);
+    let hash;
+    try {
+      hash = await walletClient.writeContract({
+        address: token,
+        abi: ERC7984_SET_OPERATOR_ABI,
+        functionName: "setOperator",
+        args: [spender, deadlineNum],
+        account: fromAccount,
+        // viem requires `chain` to be passed explicitly when the wallet has
+        // no default chain (e.g. some consumer-side constructions). Forward
+        // whatever the wallet is bound to; viem accepts undefined and falls
+        // back to the wallet's chain when present.
+        chain: walletClient.chain
+      });
+    } catch (err) {
+      throw new TokenOpsContractError(
+        `setOperator: writeContract failed (token=${token}, spender=${spender})`,
+        {
+          contract: "ERC7984",
+          call: "setOperator",
+          token,
+          spender,
+          cause: err
+        }
+      );
+    }
+    if (waitForReceipt) {
+      try {
+        await publicClient.waitForTransactionReceipt({ hash });
+      } catch (err) {
+        throw new TokenOpsContractError(`setOperator: receipt wait failed (tx=${hash})`, {
+          contract: "ERC7984",
+          call: "setOperator",
+          tx: hash,
+          cause: err
+        });
+      }
+    }
+    return hash;
+  });
+}
+async function revokeOperator(args) {
+  return withTelemetry(args.telemetry, "fhe.revokeOperator", async () => {
+    return setOperator({
+      publicClient: args.publicClient,
+      walletClient: args.walletClient,
+      ...args.account !== void 0 ? { account: args.account } : {},
+      token: args.token,
+      spender: args.spender,
+      deadline: 0n,
+      ...args.waitForReceipt !== void 0 ? { waitForReceipt: args.waitForReceipt } : {}
+      // Do NOT forward `telemetry` — the inner `fhe.setOperator` span would
+      // double-emit. The outer `fhe.revokeOperator` span carries the call.
+    });
+  });
+}
+
+export { ERC7984_OPERATOR_MAX_DEADLINE, ERC7984_SET_OPERATOR_ABI, revokeOperator, setOperator };

package/dist/chunk-XSNLAS5M.js

@@ -0,0 +1,135 @@
+import { InvalidArgumentError } from './chunk-IVE3QEGD.js';
+
+// src/fhe/scale-ratio.ts
+var FHE_SPLIT_DENOMINATOR = 90090000n;
+var MAX_UINT64 = (1n << 64n) - 1n;
+var MAX_UINT128 = (1n << 128n) - 1n;
+var MAX_FRACTION_DENOMINATOR = 16n;
+var BASIS_POINT_SCALE = 10000n;
+function scaleRatio({
+  numerator,
+  denominator,
+  minDenominator = FHE_SPLIT_DENOMINATOR,
+  width = "uint128"
+}) {
+  if (denominator <= 0n) {
+    throw new InvalidArgumentError({
+      method: "scaleRatio",
+      argument: "denominator",
+      reason: `must be > 0, got ${denominator}`,
+      value: denominator
+    });
+  }
+  if (numerator < 0n) {
+    throw new InvalidArgumentError({
+      method: "scaleRatio",
+      argument: "numerator",
+      reason: `must be >= 0, got ${numerator}`,
+      value: numerator
+    });
+  }
+  if (minDenominator <= 0n) {
+    throw new InvalidArgumentError({
+      method: "scaleRatio",
+      argument: "minDenominator",
+      reason: `must be > 0, got ${minDenominator}`,
+      value: minDenominator
+    });
+  }
+  if (denominator >= minDenominator) {
+    assertWithinWidth(numerator, width, "numerator");
+    assertWithinWidth(denominator, width, "denominator");
+    return { numerator, denominator };
+  }
+  const scaledNumerator = (numerator * minDenominator + denominator - 1n) / denominator;
+  assertWithinWidth(scaledNumerator, width, "scaled numerator");
+  assertWithinWidth(minDenominator, width, "scaled denominator");
+  return { numerator: scaledNumerator, denominator: minDenominator };
+}
+function assertWithinWidth(value, width, label) {
+  const max = width === "uint64" ? MAX_UINT64 : MAX_UINT128;
+  if (value > max) {
+    throw new InvalidArgumentError({
+      method: "scaleRatio",
+      argument: label,
+      reason: `exceeds ${width} range`,
+      value
+    });
+  }
+}
+var share = {
+  /**
+   * Build a `ScaledRatio` from a simple fraction `n/m`.
+   *
+   * - `m` must be in `1..16` — every integer in this range divides
+   *   {@link FHE_SPLIT_DENOMINATOR} cleanly, so the result is exact.
+   * - `n` must be in `0..m` — `0` is a zero-share (no-op split) and `m`
+   *   itself is the whole position.
+   *
+   * Both arguments accept `number` (must be an integer) or `bigint` —
+   * use whichever is convenient at the call site.
+   *
+   * @throws InvalidArgumentError if `m` is outside `1..16` or `n` is
+   *         outside `0..m`, or either input is a non-integer `number`.
+   */
+  fraction(numerator, denominator) {
+    const n = toIntegerBigInt(numerator, "share.fraction", "numerator");
+    const m = toIntegerBigInt(denominator, "share.fraction", "denominator");
+    if (m <= 0n || m > MAX_FRACTION_DENOMINATOR) {
+      throw new InvalidArgumentError({
+        method: "share.fraction",
+        argument: "denominator",
+        reason: `must be in 1..${MAX_FRACTION_DENOMINATOR}, got ${m}`,
+        value: m
+      });
+    }
+    if (n < 0n || n > m) {
+      throw new InvalidArgumentError({
+        method: "share.fraction",
+        argument: "numerator",
+        reason: `must be in 0..${m} (denominator), got ${n}`,
+        value: n
+      });
+    }
+    return scaleRatio({ numerator: n, denominator: m, width: "uint64" });
+  },
+  /**
+   * Build a `ScaledRatio` from a basis-point amount.
+   *
+   * `bps` must be in `0..10_000` — `0` is a zero-share and `10_000` is
+   * the whole position (= 100%). `10_000` divides
+   * {@link FHE_SPLIT_DENOMINATOR} cleanly, so the result is exact:
+   * `bps × 9_009` over `90_090_000`.
+   *
+   * Accepts `number` (must be an integer) or `bigint`.
+   *
+   * @throws InvalidArgumentError if `bps` is outside `0..10_000`, or is
+   *         a non-integer `number`.
+   */
+  basisPoints(bps) {
+    const value = toIntegerBigInt(bps, "share.basisPoints", "bps");
+    if (value < 0n || value > BASIS_POINT_SCALE) {
+      throw new InvalidArgumentError({
+        method: "share.basisPoints",
+        argument: "bps",
+        reason: `must be in 0..${BASIS_POINT_SCALE}, got ${value}`,
+        value
+      });
+    }
+    return scaleRatio({ numerator: value, denominator: BASIS_POINT_SCALE, width: "uint64" });
+  }
+};
+function toIntegerBigInt(value, method, argument) {
+  if (typeof value === "bigint") return value;
+  if (!Number.isInteger(value)) {
+    throw new InvalidArgumentError({
+      method,
+      argument,
+      reason: `must be an integer, got ${value}`,
+      value
+    });
+  }
+  return BigInt(value);
+}
+
+export { FHE_SPLIT_DENOMINATOR, scaleRatio, share };