@gauntlet-xyz/sdk 2.5.0 → 3.1.1

package/dist/cjs/api/positionHistory.js

@@ -0,0 +1,144 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var positionHistory_exports = {};
+__export(positionHistory_exports, {
+  buildPositionHistory: () => buildPositionHistory,
+  getPositionHistory: () => getPositionHistory
+});
+module.exports = __toCommonJS(positionHistory_exports);
+var import_activityRows = require("./activityRows");
+var import_errors = require("../errors");
+var import_decimal = require("./decimal");
+const ASSET_SCALE = 18;
+function buildPositionHistory(rows) {
+  if (rows.length === 0) {
+    throw new import_errors.GauntletSDKError("Cannot build position history from zero activity rows");
+  }
+  const vaultIds = new Set(rows.map((r) => r.vault_id));
+  if (vaultIds.size > 1) {
+    throw new import_errors.GauntletSDKError(
+      `Position history requires rows from a single vault; got ${[...vaultIds].join(", ")}`
+    );
+  }
+  const ordered = (0, import_activityRows.orderActivityRows)(rows);
+  (0, import_activityRows.activityLifecycles)(ordered);
+  const tokenRow = ordered.find((r) => r.assets_delta.token) ?? ordered[0];
+  const token = tokenRow.assets_delta.token ?? null;
+  for (const row of ordered) (0, import_activityRows.requireSameToken)(tokenRow, row);
+  let sharesBalance = 0n;
+  let pendingDepositAssets = 0n;
+  let pendingRedeemShares = 0n;
+  let netAssetsIn = 0n;
+  const pendingDepositByHash = /* @__PURE__ */ new Map();
+  const pendingRedeemByHash = /* @__PURE__ */ new Map();
+  const points = [];
+  for (const row of ordered) {
+    const sharesDelta = (0, import_decimal.sharesToBigInt)(row.shares_delta);
+    const assetsDelta = (0, import_decimal.decimalToBigInt)(row.assets_delta.native, ASSET_SCALE);
+    sharesBalance += sharesDelta;
+    switch (row.type) {
+      case "deposit":
+        if (row.request_hash != null) {
+          const requested = pendingDepositByHash.get(row.request_hash);
+          if (requested === void 0) {
+            throw new import_errors.GauntletSDKError(
+              `Deposit settlement ${row.tx_hash} references request_hash "${row.request_hash}" with no matching deposit_pending row`
+            );
+          }
+          pendingDepositByHash.delete(row.request_hash);
+          pendingDepositAssets -= requested;
+          netAssetsIn += requested;
+        } else {
+          netAssetsIn += assetsDelta;
+        }
+        break;
+      case "deposit_pending":
+        pendingDepositAssets += assetsDelta;
+        if (row.request_hash != null) pendingDepositByHash.set(row.request_hash, assetsDelta);
+        break;
+      case "deposit_refunded":
+        if (row.request_hash == null || pendingDepositByHash.get(row.request_hash) !== -assetsDelta) {
+          throw new import_errors.GauntletSDKError("The deposit refund does not match its escrow");
+        }
+        pendingDepositAssets += assetsDelta;
+        pendingDepositByHash.delete(row.request_hash);
+        break;
+      case "withdraw":
+        netAssetsIn += assetsDelta;
+        if (row.request_hash != null) {
+          const escrowed = pendingRedeemByHash.get(row.request_hash);
+          if (escrowed === void 0) {
+            throw new import_errors.GauntletSDKError(
+              `Withdraw settlement ${row.tx_hash} references request_hash "${row.request_hash}" with no matching withdraw_pending row`
+            );
+          }
+          pendingRedeemByHash.delete(row.request_hash);
+          pendingRedeemShares -= escrowed;
+        }
+        break;
+      case "withdraw_pending": {
+        const escrowed = -sharesDelta;
+        pendingRedeemShares += escrowed;
+        if (row.request_hash != null) pendingRedeemByHash.set(row.request_hash, escrowed);
+        break;
+      }
+      case "withdraw_refunded":
+        if (row.request_hash == null || pendingRedeemByHash.get(row.request_hash) !== sharesDelta) {
+          throw new import_errors.GauntletSDKError("The withdrawal refund does not match its escrow");
+        }
+        pendingRedeemShares -= sharesDelta;
+        pendingRedeemByHash.delete(row.request_hash);
+        break;
+      case "transfer_in":
+      case "transfer_out":
+        break;
+      default:
+        throw new import_errors.GauntletSDKError(`Unknown activity row type "${row.type}"`);
+    }
+    if (sharesBalance < 0n || pendingDepositAssets < 0n || pendingRedeemShares < 0n) {
+      throw new import_errors.GauntletSDKError("The activity history produces a negative position balance");
+    }
+    points.push({
+      timestamp: new Date(row.block_timestamp * 1e3),
+      txHash: row.tx_hash,
+      type: row.type,
+      sharesDelta,
+      assetsDelta: row.assets_delta.native,
+      sharesBalance,
+      pendingDepositAssets: (0, import_decimal.bigIntToDecimal)(pendingDepositAssets, ASSET_SCALE),
+      pendingRedeemShares,
+      netAssetsIn: (0, import_decimal.bigIntToDecimal)(netAssetsIn, ASSET_SCALE)
+    });
+  }
+  return { vaultId: ordered[0].vault_id, token, points };
+}
+async function getPositionHistory(api, walletAddress, vaultId) {
+  const rows = [];
+  for await (const row of api.activityRows(walletAddress, { vaultId, order: "asc", limit: 1e3 })) {
+    rows.push(row);
+  }
+  if (rows.length === 0) return { vaultId, token: null, points: [] };
+  return buildPositionHistory(rows);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPositionHistory,
+  getPositionHistory
+});
+//# sourceMappingURL=positionHistory.js.map

package/dist/cjs/api/positionHistory.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/api/positionHistory.ts"],
+  "sourcesContent": ["import { activityLifecycles, orderActivityRows, requireSameToken } from './activityRows';\nimport { GauntletSDKError } from '../errors';\nimport type { GauntletApi, TokenRef, UserActivity } from './client';\nimport { bigIntToDecimal, decimalToBigInt, sharesToBigInt } from './decimal';\n\n/**\n * Internal accounting scale for asset amounts. The API emits human-unit\n * decimal strings with at most `token.decimals` fractional digits, so 18\n * digits is exact for every supported asset; a token with more than 18\n * decimals would throw `DecimalPrecisionError` rather than lose precision.\n */\nconst ASSET_SCALE = 18;\n\n/** The wallet's reconstructed position state immediately after one activity row. */\nexport interface PositionHistoryPoint {\n  timestamp: Date;\n  txHash: string;\n  type: UserActivity['type'];\n  /** Signed share movement of this row, 18-decimal base units. */\n  sharesDelta: bigint;\n  /** Signed asset movement of this row (deposit-ledger convention), human decimal string. */\n  assetsDelta: string;\n  /** Shares held by the wallet after this row (escrowed redeem shares excluded). */\n  sharesBalance: bigint;\n  /** Assets escrowed at the Provisioner awaiting share mint, human decimal string. */\n  pendingDepositAssets: string;\n  /** Shares escrowed at the Provisioner awaiting asset return, 18-decimal base units. */\n  pendingRedeemShares: bigint;\n  /** Cumulative settled deposits minus settled withdrawals, human decimal string. */\n  netAssetsIn: string;\n}\n\nexport interface PositionHistory {\n  /** CAIP-10 vault id the history belongs to. */\n  vaultId: string;\n  /** The vault's asset token, when the indexer reports it on any row. */\n  token: TokenRef | null;\n  /** Chronological (oldest-first) position states, one per activity row. */\n  points: PositionHistoryPoint[];\n}\n\n/**\n * Pure builder: replays a single vault's activity rows (any order) into a\n * chronological position timeline \u2014 running share balance, escrowed pending\n * amounts, and cumulative net asset flows.\n *\n * Async lifecycles are paired via `request_hash` so settled deposits count\n * the requested asset amount and terminal rows release the matching escrow.\n */\nexport function buildPositionHistory(rows: UserActivity[]): PositionHistory {\n  if (rows.length === 0) {\n    throw new GauntletSDKError('Cannot build position history from zero activity rows');\n  }\n  const vaultIds = new Set(rows.map((r) => r.vault_id));\n  if (vaultIds.size > 1) {\n    throw new GauntletSDKError(\n      `Position history requires rows from a single vault; got ${[...vaultIds].join(', ')}`\n    );\n  }\n\n  const ordered = orderActivityRows(rows);\n  activityLifecycles(ordered);\n  const tokenRow = ordered.find((r) => r.assets_delta.token) ?? ordered[0];\n  const token = tokenRow.assets_delta.token ?? null;\n  for (const row of ordered) requireSameToken(tokenRow, row);\n\n  let sharesBalance = 0n;\n  let pendingDepositAssets = 0n;\n  let pendingRedeemShares = 0n;\n  let netAssetsIn = 0n;\n  const pendingDepositByHash = new Map<string, bigint>();\n  const pendingRedeemByHash = new Map<string, bigint>();\n\n  const points: PositionHistoryPoint[] = [];\n  for (const row of ordered) {\n    const sharesDelta = sharesToBigInt(row.shares_delta);\n    const assetsDelta = decimalToBigInt(row.assets_delta.native, ASSET_SCALE);\n    sharesBalance += sharesDelta;\n\n    switch (row.type) {\n      case 'deposit':\n        if (row.request_hash != null) {\n          // Async terminal solve: assets moved at request time; release escrow.\n          const requested = pendingDepositByHash.get(row.request_hash);\n          if (requested === undefined) {\n            throw new GauntletSDKError(\n              `Deposit settlement ${row.tx_hash} references request_hash \"${row.request_hash}\" with no matching deposit_pending row`\n            );\n          }\n          pendingDepositByHash.delete(row.request_hash);\n          pendingDepositAssets -= requested;\n          netAssetsIn += requested;\n        } else {\n          netAssetsIn += assetsDelta;\n        }\n        break;\n      case 'deposit_pending':\n        pendingDepositAssets += assetsDelta;\n        if (row.request_hash != null) pendingDepositByHash.set(row.request_hash, assetsDelta);\n        break;\n      case 'deposit_refunded':\n        if (\n          row.request_hash == null ||\n          pendingDepositByHash.get(row.request_hash) !== -assetsDelta\n        ) {\n          throw new GauntletSDKError('The deposit refund does not match its escrow');\n        }\n        pendingDepositAssets += assetsDelta;\n        pendingDepositByHash.delete(row.request_hash);\n        break;\n      case 'withdraw':\n        // Sync withdraws and async terminal solves both carry the asset\n        // payout as a negative delta on this row.\n        netAssetsIn += assetsDelta;\n        if (row.request_hash != null) {\n          const escrowed = pendingRedeemByHash.get(row.request_hash);\n          if (escrowed === undefined) {\n            throw new GauntletSDKError(\n              `Withdraw settlement ${row.tx_hash} references request_hash \"${row.request_hash}\" with no matching withdraw_pending row`\n            );\n          }\n          pendingRedeemByHash.delete(row.request_hash);\n          pendingRedeemShares -= escrowed;\n        }\n        break;\n      case 'withdraw_pending': {\n        const escrowed = -sharesDelta;\n        pendingRedeemShares += escrowed;\n        if (row.request_hash != null) pendingRedeemByHash.set(row.request_hash, escrowed);\n        break;\n      }\n      case 'withdraw_refunded':\n        if (row.request_hash == null || pendingRedeemByHash.get(row.request_hash) !== sharesDelta) {\n          throw new GauntletSDKError('The withdrawal refund does not match its escrow');\n        }\n        pendingRedeemShares -= sharesDelta;\n        pendingRedeemByHash.delete(row.request_hash);\n        break;\n      case 'transfer_in':\n      case 'transfer_out':\n        break;\n      default:\n        throw new GauntletSDKError(`Unknown activity row type \"${row.type}\"`);\n    }\n\n    if (sharesBalance < 0n || pendingDepositAssets < 0n || pendingRedeemShares < 0n) {\n      throw new GauntletSDKError('The activity history produces a negative position balance');\n    }\n    points.push({\n      timestamp: new Date(row.block_timestamp * 1000),\n      txHash: row.tx_hash,\n      type: row.type,\n      sharesDelta,\n      assetsDelta: row.assets_delta.native,\n      sharesBalance,\n      pendingDepositAssets: bigIntToDecimal(pendingDepositAssets, ASSET_SCALE),\n      pendingRedeemShares,\n      netAssetsIn: bigIntToDecimal(netAssetsIn, ASSET_SCALE),\n    });\n  }\n\n  return { vaultId: ordered[0].vault_id, token, points };\n}\n\n/**\n * Fetches a wallet's complete activity for one vault and replays it into a\n * position timeline. `vaultId` is the CAIP-10 id; use `apiVaultIdFromVaultId`\n * to convert a manifest vault id. A wallet that has never touched the vault\n * gets an empty timeline, not an error.\n */\nexport async function getPositionHistory(\n  api: GauntletApi,\n  walletAddress: string,\n  vaultId: string\n): Promise<PositionHistory> {\n  const rows: UserActivity[] = [];\n  for await (const row of api.activityRows(walletAddress, { vaultId, order: 'asc', limit: 1000 })) {\n    rows.push(row);\n  }\n  if (rows.length === 0) return { vaultId, token: null, points: [] };\n  return buildPositionHistory(rows);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/attribution/erc8021.d.ts

@@ -0,0 +1,9 @@
+import { type Hex } from 'viem';
+/**
+ * Encode an ERC-8021 builder code as a calldata suffix.
+ * Format: utf8-encoded builder code + codesLength (1 byte) + schemaId (1 byte) + ERC marker (16 bytes)
+ *
+ * @see https://eips.ethereum.org/EIPS/eip-8021
+ */
+export declare function encodeBuilderCode(builderCode: string): Hex;
+//# sourceMappingURL=erc8021.d.ts.map

package/dist/cjs/attribution/erc8021.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc8021.d.ts","sourceRoot":"","sources":["../../../src/attribution/erc8021.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAMvC;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,GAAG,CAK1D"}

package/dist/cjs/attribution/erc8021.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var erc8021_exports = {};
+__export(erc8021_exports, {
+  encodeBuilderCode: () => encodeBuilderCode
+});
+module.exports = __toCommonJS(erc8021_exports);
+var import_viem = require("viem");
+const ERC8021_MARKER = "80218021802180218021802180218021";
+const ERC8021_SCHEMA_ID = "00";
+function encodeBuilderCode(builderCode) {
+  const codeHex = (0, import_viem.toHex)(builderCode).slice(2);
+  const codeByteLen = codeHex.length / 2;
+  const codeLengthHex = codeByteLen.toString(16).padStart(2, "0");
+  return `0x${codeHex}${codeLengthHex}${ERC8021_SCHEMA_ID}${ERC8021_MARKER}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  encodeBuilderCode
+});
+//# sourceMappingURL=erc8021.js.map

package/dist/cjs/attribution/erc8021.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/attribution/erc8021.ts"],
+  "sourcesContent": ["import { toHex, type Hex } from 'viem';\n\n// 16-byte ERC-8021 marker: \"8021\" repeated 8 times\nconst ERC8021_MARKER = '80218021802180218021802180218021' as const;\nconst ERC8021_SCHEMA_ID = '00' as const; // Schema 0: simple ASCII codes\n\n/**\n * Encode an ERC-8021 builder code as a calldata suffix.\n * Format: utf8-encoded builder code + codesLength (1 byte) + schemaId (1 byte) + ERC marker (16 bytes)\n *\n * @see https://eips.ethereum.org/EIPS/eip-8021\n */\nexport function encodeBuilderCode(builderCode: string): Hex {\n  const codeHex = toHex(builderCode).slice(2); // UTF-8 hex without 0x prefix\n  const codeByteLen = codeHex.length / 2;\n  const codeLengthHex = codeByteLen.toString(16).padStart(2, '0');\n  return `0x${codeHex}${codeLengthHex}${ERC8021_SCHEMA_ID}${ERC8021_MARKER}` as Hex;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAgC;AAGhC,MAAM,iBAAiB;AACvB,MAAM,oBAAoB;AAQnB,SAAS,kBAAkB,aAA0B;AAC1D,QAAM,cAAU,mBAAM,WAAW,EAAE,MAAM,CAAC;AAC1C,QAAM,cAAc,QAAQ,SAAS;AACrC,QAAM,gBAAgB,YAAY,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC9D,SAAO,KAAK,OAAO,GAAG,aAAa,GAAG,iBAAiB,GAAG,cAAc;AAC1E;",
+  "names": []
+}

package/dist/cjs/attribution/index.d.ts

@@ -0,0 +1,28 @@
+import { Address, type Hex } from 'viem';
+import { GauntletClient } from "../client.js";
+import { TxStep } from "../evm/adapters/types.js";
+export { encodeBuilderCode } from "./erc8021.js";
+export type PreparedPayloadWithAttribution = {
+    type: string;
+    to: Address;
+    chainId: number;
+    data: Hex;
+    account?: Address;
+};
+export type PreparedTx = {
+    payload: PreparedPayloadWithAttribution;
+    tx: TxStep & {
+        chainId: number;
+    };
+};
+/**
+ * Build the full attribution suffix to append to transaction calldata.
+ *
+ * PUBLIC:  ERC-8021 builder code only — `0x{codesLength}{builderCode utf8}{schemaId=0x00}{ercMarker}`, or `0x` if no builderCode.
+ * ENCODED: Requests a sourceId from the Gauntlet API with builder code as an arg and encodes that.
+ * PRIVATE: Generates a random salt and posts it to the Gauntlet API.
+ *
+ */
+export declare function buildAttribution(client: GauntletClient): Promise<Hex>;
+export declare function encodeTransactionWithAttribution(client: GauntletClient, transaction: TxStep, chainId: number): Promise<PreparedTx>;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/attribution/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/attribution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAsB,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAE7D,OAAO,EAAmB,cAAc,EAAE,qBAAkB;AAE5D,OAAO,EAAE,MAAM,EAAE,iCAA8B;AAC/C,OAAO,EAAE,iBAAiB,EAAE,qBAAkB;AAE9C,MAAM,MAAM,8BAA8B,GAAG;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,GAAG,CAAC;IACV,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,8BAA8B,CAAC;IACxC,EAAE,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAClC,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,CAS3E;AAED,wBAAsB,gCAAgC,CACpD,MAAM,EAAE,cAAc,EACtB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,UAAU,CAAC,CAsBrB"}

package/dist/cjs/attribution/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var attribution_exports = {};
+__export(attribution_exports, {
+  buildAttribution: () => buildAttribution,
+  encodeBuilderCode: () => import_erc80212.encodeBuilderCode,
+  encodeTransactionWithAttribution: () => encodeTransactionWithAttribution
+});
+module.exports = __toCommonJS(attribution_exports);
+var import_viem = require("viem");
+var import_erc8021 = require("./erc8021");
+var import_client = require("../client");
+var import_errors = require("../errors");
+var import_erc80212 = require("./erc8021");
+async function buildAttribution(client) {
+  switch (client.attributionMode) {
+    case import_client.AttributionMode.PUBLIC:
+      return client.builderCode ? (0, import_erc8021.encodeBuilderCode)(client.builderCode) : "0x";
+    case import_client.AttributionMode.ENCODED:
+      throw new import_errors.UnimplementedFeatureError("AttributionMode.ENCODED");
+    case import_client.AttributionMode.PRIVATE:
+      throw new import_errors.UnimplementedFeatureError("AttributionMode.PRIVATE");
+  }
+}
+async function encodeTransactionWithAttribution(client, transaction, chainId) {
+  const customAttribution = await buildAttribution(client);
+  const encodedTx = (0, import_viem.encodeFunctionData)({
+    abi: transaction.abi,
+    functionName: transaction.functionName,
+    args: transaction.args
+  });
+  const encodedTxWithAttribution = `${encodedTx}${customAttribution.replace("0x", "")}`;
+  return {
+    payload: {
+      type: transaction.type,
+      account: transaction.account,
+      to: transaction.address,
+      chainId,
+      data: encodedTxWithAttribution
+    },
+    tx: {
+      ...transaction,
+      chainId,
+      attribution: customAttribution
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAttribution,
+  encodeBuilderCode,
+  encodeTransactionWithAttribution
+});
+//# sourceMappingURL=index.js.map

package/dist/cjs/attribution/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/attribution/index.ts"],
+  "sourcesContent": ["import { Address, encodeFunctionData, type Hex } from 'viem';\nimport { encodeBuilderCode } from './erc8021';\nimport { AttributionMode, GauntletClient } from '../client';\nimport { UnimplementedFeatureError } from '../errors';\nimport { TxStep } from '../evm/adapters/types';\nexport { encodeBuilderCode } from './erc8021';\n\nexport type PreparedPayloadWithAttribution = {\n  type: string;\n  to: Address;\n  chainId: number;\n  data: Hex;\n  account?: Address;\n};\n\nexport type PreparedTx = {\n  payload: PreparedPayloadWithAttribution;\n  tx: TxStep & { chainId: number };\n};\n\n/**\n * Build the full attribution suffix to append to transaction calldata.\n *\n * PUBLIC:  ERC-8021 builder code only \u2014 `0x{codesLength}{builderCode utf8}{schemaId=0x00}{ercMarker}`, or `0x` if no builderCode.\n * ENCODED: Requests a sourceId from the Gauntlet API with builder code as an arg and encodes that.\n * PRIVATE: Generates a random salt and posts it to the Gauntlet API.\n *\n */\nexport async function buildAttribution(client: GauntletClient): Promise<Hex> {\n  switch (client.attributionMode) {\n    case AttributionMode.PUBLIC:\n      return client.builderCode ? encodeBuilderCode(client.builderCode) : '0x';\n    case AttributionMode.ENCODED:\n      throw new UnimplementedFeatureError('AttributionMode.ENCODED');\n    case AttributionMode.PRIVATE:\n      throw new UnimplementedFeatureError('AttributionMode.PRIVATE');\n  }\n}\n\nexport async function encodeTransactionWithAttribution(\n  client: GauntletClient,\n  transaction: TxStep,\n  chainId: number\n): Promise<PreparedTx> {\n  const customAttribution = await buildAttribution(client);\n  const encodedTx = encodeFunctionData({\n    abi: transaction.abi,\n    functionName: transaction.functionName,\n    args: transaction.args,\n  });\n  const encodedTxWithAttribution = `${encodedTx}${customAttribution.replace('0x', '')}` as Hex;\n  return {\n    payload: {\n      type: transaction.type,\n      account: transaction.account,\n      to: transaction.address,\n      chainId,\n      data: encodedTxWithAttribution,\n    },\n    tx: {\n      ...transaction,\n      chainId,\n      attribution: customAttribution,\n    },\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAsD;AACtD,qBAAkC;AAClC,oBAAgD;AAChD,oBAA0C;AAE1C,IAAAA,kBAAkC;AAuBlC,eAAsB,iBAAiB,QAAsC;AAC3E,UAAQ,OAAO,iBAAiB;AAAA,IAC9B,KAAK,8BAAgB;AACnB,aAAO,OAAO,kBAAc,kCAAkB,OAAO,WAAW,IAAI;AAAA,IACtE,KAAK,8BAAgB;AACnB,YAAM,IAAI,wCAA0B,yBAAyB;AAAA,IAC/D,KAAK,8BAAgB;AACnB,YAAM,IAAI,wCAA0B,yBAAyB;AAAA,EACjE;AACF;AAEA,eAAsB,iCACpB,QACA,aACA,SACqB;AACrB,QAAM,oBAAoB,MAAM,iBAAiB,MAAM;AACvD,QAAM,gBAAY,gCAAmB;AAAA,IACnC,KAAK,YAAY;AAAA,IACjB,cAAc,YAAY;AAAA,IAC1B,MAAM,YAAY;AAAA,EACpB,CAAC;AACD,QAAM,2BAA2B,GAAG,SAAS,GAAG,kBAAkB,QAAQ,MAAM,EAAE,CAAC;AACnF,SAAO;AAAA,IACL,SAAS;AAAA,MACP,MAAM,YAAY;AAAA,MAClB,SAAS,YAAY;AAAA,MACrB,IAAI,YAAY;AAAA,MAChB;AAAA,MACA,MAAM;AAAA,IACR;AAAA,IACA,IAAI;AAAA,MACF,GAAG;AAAA,MACH;AAAA,MACA,aAAa;AAAA,IACf;AAAA,EACF;AACF;",
+  "names": ["import_erc8021"]
+}

package/dist/cjs/client.d.ts

@@ -0,0 +1,72 @@
+import { type PublicClient, type WalletClient } from 'viem';
+import { GauntletApi } from "./api/client.js";
+import type { VaultManifest } from "./evm/types.js";
+/**
+ * Controls how builder attribution is appended to transactions.
+ *
+ * - `PUBLIC` – attribution is sent as plain calldata (default).
+ * - `ENCODED` – attribution is encoded using ERC-8021 with a builder code fetched from the API.
+ * - `PRIVATE` – no attribution data is appended.
+ */
+export declare enum AttributionMode {
+    PUBLIC = "public",
+    ENCODED = "encoded",
+    PRIVATE = "private"
+}
+export type ChainId = string | number;
+/** The static vault manifest bundled with this SDK release; the GauntletClient default. */
+export declare const bundledVaultManifest: VaultManifest;
+export interface GauntletClientConfig {
+    /** Gaia API key, sent as `x-api-key` on `client.api` requests. Anonymous access is rate-limited. */
+    apiKey?: string;
+    /** Override the Gaia API origin (e.g. a same-origin proxy route). Defaults to `https://api.gauntlet.xyz`. */
+    apiUrl?: string;
+    /** Map of chainId → PublicClient, e.g. { [base.id]: createPublicClient(...) } */
+    evmClients?: Record<ChainId, PublicClient>;
+    attributionMode?: AttributionMode;
+    builderCode?: string;
+    /** Viem WalletClient for signing transactions. */
+    wallet?: WalletClient;
+}
+/**
+ * Main entry point for the Gauntlet SDK.
+ *
+ * Holds configuration (RPC clients, wallet, attribution mode) and exposes helpers
+ * for reading the vault manifest. Pass an instance of this class to every SDK
+ * function (e.g. `getDepositTx`, `getWithdrawTx`, `getVaults`).
+ *
+ * @example
+ * ```ts
+ * import { createPublicClient, createWalletClient, http } from 'viem';
+ * import { base } from 'viem/chains';
+ * import { GauntletClient, AttributionMode } from '@gauntlet-xyz/sdk';
+ *
+ * const wallet = createWalletClient({
+ *  account: privateKeyToAccount('0x...'), // or other account source
+ *  chain: base,
+ *  transport: http()
+ * })
+ *
+ * const client = new GauntletClient({
+ *   evmClients: { [base.id]: createPublicClient({ chain: base, transport: http() }) },
+ *   wallet,
+ *   attributionMode: AttributionMode.PUBLIC,
+ * });
+ * ```
+ */
+export declare class GauntletClient {
+    readonly apiKey?: string;
+    readonly builderCode?: string;
+    readonly attributionMode: AttributionMode;
+    readonly evmClients: Record<ChainId, PublicClient>;
+    readonly wallet?: WalletClient;
+    /** Typed client for the Gaia REST API (vaults, positions, activity, tvl, prices). */
+    readonly api: GauntletApi;
+    private _manifest;
+    constructor(config: GauntletClientConfig);
+    get manifest(): Promise<VaultManifest>;
+    setManifest(manifest: VaultManifest): void;
+    getPublicClient(chainId?: ChainId): PublicClient;
+    getSourceId(): Promise<string>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/cjs/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,MAAM,CAAC;AAE5D,OAAO,EAAE,WAAW,EAAE,wBAAqB;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,uBAAoB;AAGjD;;;;;;GAMG;AACH,oBAAY,eAAe;IACzB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAED,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AAEtC,2FAA2F;AAC3F,eAAO,MAAM,oBAAoB,EAAsB,aAAa,CAAC;AAErE,MAAM,WAAW,oBAAoB;IACnC,oGAAoG;IACpG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6GAA6G;IAC7G,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,UAAU,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;IAC3C,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,cAAc;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;IACnD,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,qFAAqF;IACrF,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAE1B,OAAO,CAAC,SAAS,CAAuC;gBAE5C,MAAM,EAAE,oBAAoB;IASxC,IAAI,QAAQ,IAAI,OAAO,CAAC,aAAa,CAAC,CAErC;IAED,WAAW,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAI1C,eAAe,CAAC,OAAO,GAAE,OAAiB,GAAG,YAAY;IAQnD,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;CAGrC"}

package/dist/cjs/client.js

@@ -0,0 +1,80 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  AttributionMode: () => AttributionMode,
+  GauntletClient: () => GauntletClient,
+  bundledVaultManifest: () => bundledVaultManifest
+});
+module.exports = __toCommonJS(client_exports);
+var import_vaults = __toESM(require("../manifest/vaults.json"), 1);
+var import_client = require("./api/client");
+var import_errors = require("./errors");
+var import_chains = require("viem/chains");
+var AttributionMode = /* @__PURE__ */ ((AttributionMode2) => {
+  AttributionMode2["PUBLIC"] = "public";
+  AttributionMode2["ENCODED"] = "encoded";
+  AttributionMode2["PRIVATE"] = "private";
+  return AttributionMode2;
+})(AttributionMode || {});
+const bundledVaultManifest = import_vaults.default;
+class GauntletClient {
+  constructor(config) {
+    this._manifest = bundledVaultManifest;
+    this.apiKey = config.apiKey;
+    this.evmClients = config.evmClients ?? {};
+    this.attributionMode = config.attributionMode ?? "public" /* PUBLIC */;
+    this.builderCode = config.builderCode;
+    this.wallet = config.wallet;
+    this.api = new import_client.GauntletApi({ apiKey: config.apiKey, apiUrl: config.apiUrl });
+  }
+  get manifest() {
+    return Promise.resolve(this._manifest);
+  }
+  setManifest(manifest) {
+    this._manifest = manifest;
+  }
+  getPublicClient(chainId = import_chains.base.id) {
+    const client = this.evmClients[chainId];
+    if (!client) throw new import_errors.RpcNotConfiguredError(chainId);
+    return client;
+  }
+  // Will be used for encoded attribution
+  // Will use apiKey to get a builder ID from core api
+  async getSourceId() {
+    throw new import_errors.UnimplementedFeatureError("getSourceId");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AttributionMode,
+  GauntletClient,
+  bundledVaultManifest
+});
+//# sourceMappingURL=client.js.map

package/dist/cjs/client.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/client.ts"],
+  "sourcesContent": ["import { type PublicClient, type WalletClient } from 'viem';\nimport bundledManifest from '../manifest/vaults.json';\nimport { GauntletApi } from './api/client';\nimport { RpcNotConfiguredError, UnimplementedFeatureError } from './errors';\nimport type { VaultManifest } from './evm/types';\nimport { base } from 'viem/chains';\n\n/**\n * Controls how builder attribution is appended to transactions.\n *\n * - `PUBLIC` \u2013 attribution is sent as plain calldata (default).\n * - `ENCODED` \u2013 attribution is encoded using ERC-8021 with a builder code fetched from the API.\n * - `PRIVATE` \u2013 no attribution data is appended.\n */\nexport enum AttributionMode {\n  PUBLIC = 'public',\n  ENCODED = 'encoded',\n  PRIVATE = 'private',\n}\n\nexport type ChainId = string | number;\n\n/** The static vault manifest bundled with this SDK release; the GauntletClient default. */\nexport const bundledVaultManifest = bundledManifest as VaultManifest;\n\nexport interface GauntletClientConfig {\n  /** Gaia API key, sent as `x-api-key` on `client.api` requests. Anonymous access is rate-limited. */\n  apiKey?: string;\n  /** Override the Gaia API origin (e.g. a same-origin proxy route). Defaults to `https://api.gauntlet.xyz`. */\n  apiUrl?: string;\n  /** Map of chainId \u2192 PublicClient, e.g. { [base.id]: createPublicClient(...) } */\n  evmClients?: Record<ChainId, PublicClient>;\n  attributionMode?: AttributionMode;\n  builderCode?: string;\n  /** Viem WalletClient for signing transactions. */\n  wallet?: WalletClient;\n}\n\n/**\n * Main entry point for the Gauntlet SDK.\n *\n * Holds configuration (RPC clients, wallet, attribution mode) and exposes helpers\n * for reading the vault manifest. Pass an instance of this class to every SDK\n * function (e.g. `getDepositTx`, `getWithdrawTx`, `getVaults`).\n *\n * @example\n * ```ts\n * import { createPublicClient, createWalletClient, http } from 'viem';\n * import { base } from 'viem/chains';\n * import { GauntletClient, AttributionMode } from '@gauntlet-xyz/sdk';\n *\n * const wallet = createWalletClient({\n *  account: privateKeyToAccount('0x...'), // or other account source\n *  chain: base,\n *  transport: http()\n * })\n *\n * const client = new GauntletClient({\n *   evmClients: { [base.id]: createPublicClient({ chain: base, transport: http() }) },\n *   wallet,\n *   attributionMode: AttributionMode.PUBLIC,\n * });\n * ```\n */\nexport class GauntletClient {\n  readonly apiKey?: string;\n  readonly builderCode?: string;\n  readonly attributionMode: AttributionMode;\n  readonly evmClients: Record<ChainId, PublicClient>;\n  readonly wallet?: WalletClient;\n  /** Typed client for the Gaia REST API (vaults, positions, activity, tvl, prices). */\n  readonly api: GauntletApi;\n\n  private _manifest: VaultManifest = bundledVaultManifest;\n\n  constructor(config: GauntletClientConfig) {\n    this.apiKey = config.apiKey;\n    this.evmClients = config.evmClients ?? {};\n    this.attributionMode = config.attributionMode ?? AttributionMode.PUBLIC;\n    this.builderCode = config.builderCode;\n    this.wallet = config.wallet;\n    this.api = new GauntletApi({ apiKey: config.apiKey, apiUrl: config.apiUrl });\n  }\n\n  get manifest(): Promise<VaultManifest> {\n    return Promise.resolve(this._manifest);\n  }\n\n  setManifest(manifest: VaultManifest): void {\n    this._manifest = manifest;\n  }\n\n  getPublicClient(chainId: ChainId = base.id): PublicClient {\n    const client = this.evmClients[chainId];\n    if (!client) throw new RpcNotConfiguredError(chainId);\n    return client;\n  }\n\n  // Will be used for encoded attribution\n  // Will use apiKey to get a builder ID from core api\n  async getSourceId(): Promise<string> {\n    throw new UnimplementedFeatureError('getSourceId');\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oBAA4B;AAC5B,oBAA4B;AAC5B,oBAAiE;AAEjE,oBAAqB;AASd,IAAK,kBAAL,kBAAKA,qBAAL;AACL,EAAAA,iBAAA,YAAS;AACT,EAAAA,iBAAA,aAAU;AACV,EAAAA,iBAAA,aAAU;AAHA,SAAAA;AAAA,GAAA;AASL,MAAM,uBAAuB,cAAAC;AAyC7B,MAAM,eAAe;AAAA,EAW1B,YAAY,QAA8B;AAF1C,SAAQ,YAA2B;AAGjC,SAAK,SAAS,OAAO;AACrB,SAAK,aAAa,OAAO,cAAc,CAAC;AACxC,SAAK,kBAAkB,OAAO,mBAAmB;AACjD,SAAK,cAAc,OAAO;AAC1B,SAAK,SAAS,OAAO;AACrB,SAAK,MAAM,IAAI,0BAAY,EAAE,QAAQ,OAAO,QAAQ,QAAQ,OAAO,OAAO,CAAC;AAAA,EAC7E;AAAA,EAEA,IAAI,WAAmC;AACrC,WAAO,QAAQ,QAAQ,KAAK,SAAS;AAAA,EACvC;AAAA,EAEA,YAAY,UAA+B;AACzC,SAAK,YAAY;AAAA,EACnB;AAAA,EAEA,gBAAgB,UAAmB,mBAAK,IAAkB;AACxD,UAAM,SAAS,KAAK,WAAW,OAAO;AACtC,QAAI,CAAC,OAAQ,OAAM,IAAI,oCAAsB,OAAO;AACpD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA,EAIA,MAAM,cAA+B;AACnC,UAAM,IAAI,wCAA0B,aAAa;AAAA,EACnD;AACF;",
+  "names": ["AttributionMode", "bundledManifest"]
+}

package/dist/cjs/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const MAX_BPS = 10000n;
+export declare const DEFAULT_BPS = 100;
+export declare const SECOND = 1;
+export declare const MINUTE: number;
+export declare const HOUR: number;
+export declare const DAY: number;
+export declare const REQUEST_DEADLINE_BUFFER_DAYS = 3;
+export declare const DEFAULT_MAX_PRICE_AGE_DAYS = 10;
+export declare const DEFAULT_SOLVER_TIP = 0n;
+export declare const DEFAULT_REQUEST_DEADLINE_BUFFER: number;
+export declare const DEFAULT_MAX_PRICE_AGE: bigint;
+export declare const CHAIN_NAMES: Record<number, string>;
+export declare const BLOCKS_3_DAYS: Record<number, bigint>;
+export declare const DEFAULT_BLOCKS_3_DAYS = 129600n;
+export declare const LOG_PAGE_SIZE = 9999n;
+//# sourceMappingURL=constants.d.ts.map

package/dist/cjs/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,SAAS,CAAC;AAC9B,eAAO,MAAM,WAAW,MAAM,CAAC;AAE/B,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,MAAM,QAAc,CAAC;AAClC,eAAO,MAAM,IAAI,QAAc,CAAC;AAChC,eAAO,MAAM,GAAG,QAAY,CAAC;AAE7B,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAC9C,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAC7C,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,+BAA+B,QAAqC,CAAC;AAClF,eAAO,MAAM,qBAAqB,QAA2C,CAAC;AAE9E,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAM9C,CAAC;AAGF,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAMhD,CAAC;AACF,eAAO,MAAM,qBAAqB,UAAW,CAAC;AAG9C,eAAO,MAAM,aAAa,QAAS,CAAC"}

package/dist/cjs/constants.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  BLOCKS_3_DAYS: () => BLOCKS_3_DAYS,
+  CHAIN_NAMES: () => CHAIN_NAMES,
+  DAY: () => DAY,
+  DEFAULT_BLOCKS_3_DAYS: () => DEFAULT_BLOCKS_3_DAYS,
+  DEFAULT_BPS: () => DEFAULT_BPS,
+  DEFAULT_MAX_PRICE_AGE: () => DEFAULT_MAX_PRICE_AGE,
+  DEFAULT_MAX_PRICE_AGE_DAYS: () => DEFAULT_MAX_PRICE_AGE_DAYS,
+  DEFAULT_REQUEST_DEADLINE_BUFFER: () => DEFAULT_REQUEST_DEADLINE_BUFFER,
+  DEFAULT_SOLVER_TIP: () => DEFAULT_SOLVER_TIP,
+  HOUR: () => HOUR,
+  LOG_PAGE_SIZE: () => LOG_PAGE_SIZE,
+  MAX_BPS: () => MAX_BPS,
+  MINUTE: () => MINUTE,
+  REQUEST_DEADLINE_BUFFER_DAYS: () => REQUEST_DEADLINE_BUFFER_DAYS,
+  SECOND: () => SECOND
+});
+module.exports = __toCommonJS(constants_exports);
+const MAX_BPS = 10000n;
+const DEFAULT_BPS = 100;
+const SECOND = 1;
+const MINUTE = SECOND * 60;
+const HOUR = MINUTE * 60;
+const DAY = HOUR * 24;
+const REQUEST_DEADLINE_BUFFER_DAYS = 3;
+const DEFAULT_MAX_PRICE_AGE_DAYS = 10;
+const DEFAULT_SOLVER_TIP = 0n;
+const DEFAULT_REQUEST_DEADLINE_BUFFER = DAY * REQUEST_DEADLINE_BUFFER_DAYS;
+const DEFAULT_MAX_PRICE_AGE = BigInt(DAY * DEFAULT_MAX_PRICE_AGE_DAYS);
+const CHAIN_NAMES = {
+  1: "ethereum",
+  8453: "base",
+  42161: "arbitrum",
+  10: "optimism",
+  5042: "arc"
+};
+const BLOCKS_3_DAYS = {
+  1: 21600n,
+  8453: 129600n,
+  42161: 1036800n,
+  10: 129600n,
+  5042: 518400n
+};
+const DEFAULT_BLOCKS_3_DAYS = 129600n;
+const LOG_PAGE_SIZE = 9999n;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BLOCKS_3_DAYS,
+  CHAIN_NAMES,
+  DAY,
+  DEFAULT_BLOCKS_3_DAYS,
+  DEFAULT_BPS,
+  DEFAULT_MAX_PRICE_AGE,
+  DEFAULT_MAX_PRICE_AGE_DAYS,
+  DEFAULT_REQUEST_DEADLINE_BUFFER,
+  DEFAULT_SOLVER_TIP,
+  HOUR,
+  LOG_PAGE_SIZE,
+  MAX_BPS,
+  MINUTE,
+  REQUEST_DEADLINE_BUFFER_DAYS,
+  SECOND
+});
+//# sourceMappingURL=constants.js.map

package/dist/cjs/constants.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/constants.ts"],
+  "sourcesContent": ["export const MAX_BPS = 10000n;\nexport const DEFAULT_BPS = 100;\n\nexport const SECOND = 1;\nexport const MINUTE = SECOND * 60;\nexport const HOUR = MINUTE * 60;\nexport const DAY = HOUR * 24;\n\nexport const REQUEST_DEADLINE_BUFFER_DAYS = 3;\nexport const DEFAULT_MAX_PRICE_AGE_DAYS = 10;\nexport const DEFAULT_SOLVER_TIP = 0n;\nexport const DEFAULT_REQUEST_DEADLINE_BUFFER = DAY * REQUEST_DEADLINE_BUFFER_DAYS;\nexport const DEFAULT_MAX_PRICE_AGE = BigInt(DAY * DEFAULT_MAX_PRICE_AGE_DAYS);\n\nexport const CHAIN_NAMES: Record<number, string> = {\n  1: 'ethereum',\n  8453: 'base',\n  42161: 'arbitrum',\n  10: 'optimism',\n  5042: 'arc',\n};\n\n// Approximate 3-day block lookback per chain based on avg block time.\nexport const BLOCKS_3_DAYS: Record<number, bigint> = {\n  1: 21_600n,\n  8453: 129_600n,\n  42161: 1_036_800n,\n  10: 129_600n,\n  5042: 518_400n,\n};\nexport const DEFAULT_BLOCKS_3_DAYS = 129_600n;\n\n// Many RPC providers cap eth_getLogs to 10,000 blocks per request.\nexport const LOG_PAGE_SIZE = 9_999n;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,UAAU;AAChB,MAAM,cAAc;AAEpB,MAAM,SAAS;AACf,MAAM,SAAS,SAAS;AACxB,MAAM,OAAO,SAAS;AACtB,MAAM,MAAM,OAAO;AAEnB,MAAM,+BAA+B;AACrC,MAAM,6BAA6B;AACnC,MAAM,qBAAqB;AAC3B,MAAM,kCAAkC,MAAM;AAC9C,MAAM,wBAAwB,OAAO,MAAM,0BAA0B;AAErE,MAAM,cAAsC;AAAA,EACjD,GAAG;AAAA,EACH,MAAM;AAAA,EACN,OAAO;AAAA,EACP,IAAI;AAAA,EACJ,MAAM;AACR;AAGO,MAAM,gBAAwC;AAAA,EACnD,GAAG;AAAA,EACH,MAAM;AAAA,EACN,OAAO;AAAA,EACP,IAAI;AAAA,EACJ,MAAM;AACR;AACO,MAAM,wBAAwB;AAG9B,MAAM,gBAAgB;",
+  "names": []
+}