@opendatalabs/vana-sdk 3.1.0 → 3.2.0-canary.255a8bf

package/dist/protocol/escrow-deposit.cjs

@@ -0,0 +1,89 @@
+"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 escrow_deposit_exports = {};
+__export(escrow_deposit_exports, {
+  ESCROW_DEPOSIT_ABI: () => ESCROW_DEPOSIT_ABI,
+  buildDepositNativeRequest: () => buildDepositNativeRequest,
+  buildDepositTokenRequest: () => buildDepositTokenRequest,
+  encodeDepositNativeData: () => encodeDepositNativeData,
+  encodeDepositTokenData: () => encodeDepositTokenData,
+  escrowContractAddress: () => escrowContractAddress
+});
+module.exports = __toCommonJS(escrow_deposit_exports);
+var import_viem = require("viem");
+const ESCROW_DEPOSIT_ABI = [
+  {
+    type: "function",
+    name: "depositNative",
+    stateMutability: "payable",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "depositToken",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+function escrowContractAddress(config) {
+  return config.contracts.dataPortabilityEscrow;
+}
+function encodeDepositNativeData(input) {
+  return (0, import_viem.encodeFunctionData)({
+    abi: ESCROW_DEPOSIT_ABI,
+    functionName: "depositNative",
+    args: [input.account]
+  });
+}
+function encodeDepositTokenData(input) {
+  return (0, import_viem.encodeFunctionData)({
+    abi: ESCROW_DEPOSIT_ABI,
+    functionName: "depositToken",
+    args: [input.account, input.token, input.amount]
+  });
+}
+function buildDepositNativeRequest(config, input) {
+  return {
+    to: escrowContractAddress(config),
+    data: encodeDepositNativeData({ account: input.account }),
+    value: input.amount
+  };
+}
+function buildDepositTokenRequest(config, input) {
+  return {
+    to: escrowContractAddress(config),
+    data: encodeDepositTokenData(input)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ESCROW_DEPOSIT_ABI,
+  buildDepositNativeRequest,
+  buildDepositTokenRequest,
+  encodeDepositNativeData,
+  encodeDepositTokenData,
+  escrowContractAddress
+});
+//# sourceMappingURL=escrow-deposit.cjs.map

package/dist/protocol/escrow-deposit.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/protocol/escrow-deposit.ts"],"sourcesContent":["/**\n * On-chain deposit primitives for the DataPortabilityEscrow contract.\n *\n * The escrow holds the finalized balance that `/v1/escrow/pay` debits against.\n * A payer credits their balance by sending one of two function calls to the\n * escrow contract — depositNative (native VANA, amount via `msg.value`) or\n * depositToken (ERC-20, caller must `approve` the escrow first). The credited\n * `account` need not equal `msg.sender`, so a third party can fund someone\n * else's escrow.\n *\n * Once the on-chain tx lands, call `GatewayClient.submitEscrowDeposit({txHash})`\n * to announce it; the gateway reconciles it into the balance and surfaces it\n * under `getEscrowBalance(account).deposits.finalized`.\n *\n * These helpers are signer/transport-agnostic — they return the raw\n * `{to, data, value?}` request object so callers can feed it to any wallet\n * stack (viem `sendTransaction`/`writeContract`, ethers, wallet-rpc, MPC,\n * Safe transactions, etc.).\n *\n * @category Protocol\n */\nimport { encodeFunctionData } from \"viem\";\nimport type { DataPortabilityGatewayConfig } from \"./eip712\";\n\n// ABI for the two deposit entry points on DataPortabilityEscrow. Same shape\n// the gateway uses to decode pending/mined tx calldata at\n// /v1/escrow/deposit time (data-gateway/lib/escrow.ts:39).\nexport const ESCROW_DEPOSIT_ABI = [\n  {\n    type: \"function\",\n    name: \"depositNative\",\n    stateMutability: \"payable\",\n    inputs: [{ name: \"account\", type: \"address\" }],\n    outputs: [],\n  },\n  {\n    type: \"function\",\n    name: \"depositToken\",\n    stateMutability: \"nonpayable\",\n    inputs: [\n      { name: \"account\", type: \"address\" },\n      { name: \"token\", type: \"address\" },\n      { name: \"amount\", type: \"uint256\" },\n    ],\n    outputs: [],\n  },\n] as const;\n\nexport function escrowContractAddress(\n  config: DataPortabilityGatewayConfig,\n): `0x${string}` {\n  return config.contracts.dataPortabilityEscrow as `0x${string}`;\n}\n\nexport interface DepositNativeInput {\n  // Address credited inside the escrow. Often the same as the wallet sending\n  // the tx, but third-party funding is supported.\n  account: `0x${string}`;\n  amount: bigint;\n}\n\nexport interface DepositTokenInput {\n  account: `0x${string}`;\n  // ERC-20 contract address.\n  token: `0x${string}`;\n  amount: bigint;\n}\n\n// Shape compatible with viem's `sendTransaction` / `writeContract` request\n// objects. `value` is omitted on the ERC-20 path because the amount lives in\n// the token contract, not `msg.value`.\nexport interface DepositTransactionRequest {\n  to: `0x${string}`;\n  data: `0x${string}`;\n  value?: bigint;\n}\n\nexport function encodeDepositNativeData(input: {\n  account: `0x${string}`;\n}): `0x${string}` {\n  return encodeFunctionData({\n    abi: ESCROW_DEPOSIT_ABI,\n    functionName: \"depositNative\",\n    args: [input.account],\n  });\n}\n\nexport function encodeDepositTokenData(\n  input: DepositTokenInput,\n): `0x${string}` {\n  return encodeFunctionData({\n    abi: ESCROW_DEPOSIT_ABI,\n    functionName: \"depositToken\",\n    args: [input.account, input.token, input.amount],\n  });\n}\n\n// Build the full tx request for a native-VANA deposit. Feed it straight to\n// `walletClient.sendTransaction({...req, account, chain})`. ERC-20 needs a\n// prior `approve(escrow, amount)` on the token — use viem's built-in\n// `erc20Abi` for that; the SDK doesn't bundle one to avoid the import surface.\nexport function buildDepositNativeRequest(\n  config: DataPortabilityGatewayConfig,\n  input: DepositNativeInput,\n): DepositTransactionRequest {\n  return {\n    to: escrowContractAddress(config),\n    data: encodeDepositNativeData({ account: input.account }),\n    value: input.amount,\n  };\n}\n\nexport function buildDepositTokenRequest(\n  config: DataPortabilityGatewayConfig,\n  input: DepositTokenInput,\n): DepositTransactionRequest {\n  return {\n    to: escrowContractAddress(config),\n    data: encodeDepositTokenData(input),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBA,kBAAmC;AAM5B,MAAM,qBAAqB;AAAA,EAChC;AAAA,IACE,MAAM;AAAA,IACN,MAAM;AAAA,IACN,iBAAiB;AAAA,IACjB,QAAQ,CAAC,EAAE,MAAM,WAAW,MAAM,UAAU,CAAC;AAAA,IAC7C,SAAS,CAAC;AAAA,EACZ;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,MAAM;AAAA,IACN,iBAAiB;AAAA,IACjB,QAAQ;AAAA,MACN,EAAE,MAAM,WAAW,MAAM,UAAU;AAAA,MACnC,EAAE,MAAM,SAAS,MAAM,UAAU;AAAA,MACjC,EAAE,MAAM,UAAU,MAAM,UAAU;AAAA,IACpC;AAAA,IACA,SAAS,CAAC;AAAA,EACZ;AACF;AAEO,SAAS,sBACd,QACe;AACf,SAAO,OAAO,UAAU;AAC1B;AAyBO,SAAS,wBAAwB,OAEtB;AAChB,aAAO,gCAAmB;AAAA,IACxB,KAAK;AAAA,IACL,cAAc;AAAA,IACd,MAAM,CAAC,MAAM,OAAO;AAAA,EACtB,CAAC;AACH;AAEO,SAAS,uBACd,OACe;AACf,aAAO,gCAAmB;AAAA,IACxB,KAAK;AAAA,IACL,cAAc;AAAA,IACd,MAAM,CAAC,MAAM,SAAS,MAAM,OAAO,MAAM,MAAM;AAAA,EACjD,CAAC;AACH;AAMO,SAAS,0BACd,QACA,OAC2B;AAC3B,SAAO;AAAA,IACL,IAAI,sBAAsB,MAAM;AAAA,IAChC,MAAM,wBAAwB,EAAE,SAAS,MAAM,QAAQ,CAAC;AAAA,IACxD,OAAO,MAAM;AAAA,EACf;AACF;AAEO,SAAS,yBACd,QACA,OAC2B;AAC3B,SAAO;AAAA,IACL,IAAI,sBAAsB,MAAM;AAAA,IAChC,MAAM,uBAAuB,KAAK;AAAA,EACpC;AACF;","names":[]}

package/dist/protocol/escrow-deposit.d.ts

@@ -0,0 +1,47 @@
+import type { DataPortabilityGatewayConfig } from "./eip712";
+export declare const ESCROW_DEPOSIT_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "depositNative";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "depositToken";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+}];
+export declare function escrowContractAddress(config: DataPortabilityGatewayConfig): `0x${string}`;
+export interface DepositNativeInput {
+    account: `0x${string}`;
+    amount: bigint;
+}
+export interface DepositTokenInput {
+    account: `0x${string}`;
+    token: `0x${string}`;
+    amount: bigint;
+}
+export interface DepositTransactionRequest {
+    to: `0x${string}`;
+    data: `0x${string}`;
+    value?: bigint;
+}
+export declare function encodeDepositNativeData(input: {
+    account: `0x${string}`;
+}): `0x${string}`;
+export declare function encodeDepositTokenData(input: DepositTokenInput): `0x${string}`;
+export declare function buildDepositNativeRequest(config: DataPortabilityGatewayConfig, input: DepositNativeInput): DepositTransactionRequest;
+export declare function buildDepositTokenRequest(config: DataPortabilityGatewayConfig, input: DepositTokenInput): DepositTransactionRequest;

package/dist/protocol/escrow-deposit.js

@@ -0,0 +1,60 @@
+import { encodeFunctionData } from "viem";
+const ESCROW_DEPOSIT_ABI = [
+  {
+    type: "function",
+    name: "depositNative",
+    stateMutability: "payable",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "depositToken",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+function escrowContractAddress(config) {
+  return config.contracts.dataPortabilityEscrow;
+}
+function encodeDepositNativeData(input) {
+  return encodeFunctionData({
+    abi: ESCROW_DEPOSIT_ABI,
+    functionName: "depositNative",
+    args: [input.account]
+  });
+}
+function encodeDepositTokenData(input) {
+  return encodeFunctionData({
+    abi: ESCROW_DEPOSIT_ABI,
+    functionName: "depositToken",
+    args: [input.account, input.token, input.amount]
+  });
+}
+function buildDepositNativeRequest(config, input) {
+  return {
+    to: escrowContractAddress(config),
+    data: encodeDepositNativeData({ account: input.account }),
+    value: input.amount
+  };
+}
+function buildDepositTokenRequest(config, input) {
+  return {
+    to: escrowContractAddress(config),
+    data: encodeDepositTokenData(input)
+  };
+}
+export {
+  ESCROW_DEPOSIT_ABI,
+  buildDepositNativeRequest,
+  buildDepositTokenRequest,
+  encodeDepositNativeData,
+  encodeDepositTokenData,
+  escrowContractAddress
+};
+//# sourceMappingURL=escrow-deposit.js.map

package/dist/protocol/escrow-deposit.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/protocol/escrow-deposit.ts"],"sourcesContent":["/**\n * On-chain deposit primitives for the DataPortabilityEscrow contract.\n *\n * The escrow holds the finalized balance that `/v1/escrow/pay` debits against.\n * A payer credits their balance by sending one of two function calls to the\n * escrow contract — depositNative (native VANA, amount via `msg.value`) or\n * depositToken (ERC-20, caller must `approve` the escrow first). The credited\n * `account` need not equal `msg.sender`, so a third party can fund someone\n * else's escrow.\n *\n * Once the on-chain tx lands, call `GatewayClient.submitEscrowDeposit({txHash})`\n * to announce it; the gateway reconciles it into the balance and surfaces it\n * under `getEscrowBalance(account).deposits.finalized`.\n *\n * These helpers are signer/transport-agnostic — they return the raw\n * `{to, data, value?}` request object so callers can feed it to any wallet\n * stack (viem `sendTransaction`/`writeContract`, ethers, wallet-rpc, MPC,\n * Safe transactions, etc.).\n *\n * @category Protocol\n */\nimport { encodeFunctionData } from \"viem\";\nimport type { DataPortabilityGatewayConfig } from \"./eip712\";\n\n// ABI for the two deposit entry points on DataPortabilityEscrow. Same shape\n// the gateway uses to decode pending/mined tx calldata at\n// /v1/escrow/deposit time (data-gateway/lib/escrow.ts:39).\nexport const ESCROW_DEPOSIT_ABI = [\n  {\n    type: \"function\",\n    name: \"depositNative\",\n    stateMutability: \"payable\",\n    inputs: [{ name: \"account\", type: \"address\" }],\n    outputs: [],\n  },\n  {\n    type: \"function\",\n    name: \"depositToken\",\n    stateMutability: \"nonpayable\",\n    inputs: [\n      { name: \"account\", type: \"address\" },\n      { name: \"token\", type: \"address\" },\n      { name: \"amount\", type: \"uint256\" },\n    ],\n    outputs: [],\n  },\n] as const;\n\nexport function escrowContractAddress(\n  config: DataPortabilityGatewayConfig,\n): `0x${string}` {\n  return config.contracts.dataPortabilityEscrow as `0x${string}`;\n}\n\nexport interface DepositNativeInput {\n  // Address credited inside the escrow. Often the same as the wallet sending\n  // the tx, but third-party funding is supported.\n  account: `0x${string}`;\n  amount: bigint;\n}\n\nexport interface DepositTokenInput {\n  account: `0x${string}`;\n  // ERC-20 contract address.\n  token: `0x${string}`;\n  amount: bigint;\n}\n\n// Shape compatible with viem's `sendTransaction` / `writeContract` request\n// objects. `value` is omitted on the ERC-20 path because the amount lives in\n// the token contract, not `msg.value`.\nexport interface DepositTransactionRequest {\n  to: `0x${string}`;\n  data: `0x${string}`;\n  value?: bigint;\n}\n\nexport function encodeDepositNativeData(input: {\n  account: `0x${string}`;\n}): `0x${string}` {\n  return encodeFunctionData({\n    abi: ESCROW_DEPOSIT_ABI,\n    functionName: \"depositNative\",\n    args: [input.account],\n  });\n}\n\nexport function encodeDepositTokenData(\n  input: DepositTokenInput,\n): `0x${string}` {\n  return encodeFunctionData({\n    abi: ESCROW_DEPOSIT_ABI,\n    functionName: \"depositToken\",\n    args: [input.account, input.token, input.amount],\n  });\n}\n\n// Build the full tx request for a native-VANA deposit. Feed it straight to\n// `walletClient.sendTransaction({...req, account, chain})`. ERC-20 needs a\n// prior `approve(escrow, amount)` on the token — use viem's built-in\n// `erc20Abi` for that; the SDK doesn't bundle one to avoid the import surface.\nexport function buildDepositNativeRequest(\n  config: DataPortabilityGatewayConfig,\n  input: DepositNativeInput,\n): DepositTransactionRequest {\n  return {\n    to: escrowContractAddress(config),\n    data: encodeDepositNativeData({ account: input.account }),\n    value: input.amount,\n  };\n}\n\nexport function buildDepositTokenRequest(\n  config: DataPortabilityGatewayConfig,\n  input: DepositTokenInput,\n): DepositTransactionRequest {\n  return {\n    to: escrowContractAddress(config),\n    data: encodeDepositTokenData(input),\n  };\n}\n"],"mappings":"AAqBA,SAAS,0BAA0B;AAM5B,MAAM,qBAAqB;AAAA,EAChC;AAAA,IACE,MAAM;AAAA,IACN,MAAM;AAAA,IACN,iBAAiB;AAAA,IACjB,QAAQ,CAAC,EAAE,MAAM,WAAW,MAAM,UAAU,CAAC;AAAA,IAC7C,SAAS,CAAC;AAAA,EACZ;AAAA,EACA;AAAA,IACE,MAAM;AAAA,IACN,MAAM;AAAA,IACN,iBAAiB;AAAA,IACjB,QAAQ;AAAA,MACN,EAAE,MAAM,WAAW,MAAM,UAAU;AAAA,MACnC,EAAE,MAAM,SAAS,MAAM,UAAU;AAAA,MACjC,EAAE,MAAM,UAAU,MAAM,UAAU;AAAA,IACpC;AAAA,IACA,SAAS,CAAC;AAAA,EACZ;AACF;AAEO,SAAS,sBACd,QACe;AACf,SAAO,OAAO,UAAU;AAC1B;AAyBO,SAAS,wBAAwB,OAEtB;AAChB,SAAO,mBAAmB;AAAA,IACxB,KAAK;AAAA,IACL,cAAc;AAAA,IACd,MAAM,CAAC,MAAM,OAAO;AAAA,EACtB,CAAC;AACH;AAEO,SAAS,uBACd,OACe;AACf,SAAO,mBAAmB;AAAA,IACxB,KAAK;AAAA,IACL,cAAc;AAAA,IACd,MAAM,CAAC,MAAM,SAAS,MAAM,OAAO,MAAM,MAAM;AAAA,EACjD,CAAC;AACH;AAMO,SAAS,0BACd,QACA,OAC2B;AAC3B,SAAO;AAAA,IACL,IAAI,sBAAsB,MAAM;AAAA,IAChC,MAAM,wBAAwB,EAAE,SAAS,MAAM,QAAQ,CAAC;AAAA,IACxD,OAAO,MAAM;AAAA,EACf;AACF;AAEO,SAAS,yBACd,QACA,OAC2B;AAC3B,SAAO;AAAA,IACL,IAAI,sBAAsB,MAAM;AAAA,IAChC,MAAM,uBAAuB,KAAK;AAAA,EACpC;AACF;","names":[]}

package/dist/protocol/escrow-deposit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/protocol/escrow-flow.test.d.ts

@@ -0,0 +1,21 @@
+/**
+ * End-to-end test of the deposit + payment flow.
+ *
+ * The SDK is signer- and transport-agnostic. To prove the helpers compose
+ * correctly we wire them through:
+ *
+ *   - A real viem `WalletClient` against an in-memory L1 (a custom RPC
+ *     transport routes JSON-RPC calls to a Map-backed chain). The wallet
+ *     genuinely signs an EIP-1559 transaction with the depositNative
+ *     calldata produced by buildDepositNativeRequest.
+ *
+ *   - A fetch-mocked gateway that decodes that same calldata via
+ *     ESCROW_DEPOSIT_ABI, credits a balance, and later recovers the
+ *     GenericPayment EIP-712 signer with viem's recoverTypedDataAddress —
+ *     same cryptographic checks the real gateway runs.
+ *
+ * Anything weaker than this (hand-rolled sendTx, hand-rolled sig recovery)
+ * would let the SDK's encoder or domain helpers drift silently. Going through
+ * viem's real wallet + sign paths is what makes this a useful e2e.
+ */
+export {};

package/dist/protocol/fee-registry.cjs

@@ -0,0 +1,89 @@
+"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 fee_registry_exports = {};
+__export(fee_registry_exports, {
+  FEE_REGISTRY_ABI: () => FEE_REGISTRY_ABI,
+  getFee: () => getFee,
+  getOpFee: () => getOpFee
+});
+module.exports = __toCommonJS(fee_registry_exports);
+var import_viem = require("viem");
+const FEE_REGISTRY_ABI = (0, import_viem.parseAbi)([
+  "struct Fee { uint256 amount; address asset; address payee; bool enabled; }",
+  "function fees(bytes32 operation) view returns (Fee)",
+  "function operationKey(string name) pure returns (bytes32)"
+]);
+function operationNameFor(kind, opts) {
+  if (kind === "registration") {
+    return opts?.registrationOpName ?? "registration";
+  }
+  return opts?.dataAccessOpName ?? "data_access";
+}
+async function getFee(client, config, kind, opts) {
+  const address = config.contracts.feeRegistry;
+  const opName = operationNameFor(kind, opts);
+  const opKey = await client.readContract({
+    address,
+    abi: FEE_REGISTRY_ABI,
+    functionName: "operationKey",
+    args: [opName]
+  });
+  const fee = await client.readContract({
+    address,
+    abi: FEE_REGISTRY_ABI,
+    functionName: "fees",
+    args: [opKey]
+  });
+  if (!fee.enabled) {
+    throw new Error(
+      `FeeRegistry: operation "${opName}" (kind=${kind}) is not enabled \u2014 operator must call setFeeByName before payments will validate`
+    );
+  }
+  if (fee.payee === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `FeeRegistry: operation "${opName}" has zero-address payee \u2014 contract pre-flight rejects payouts to 0x0`
+    );
+  }
+  return fee;
+}
+async function getOpFee(client, config, opts) {
+  const [registration, dataAccess] = await Promise.all([
+    getFee(client, config, "registration", opts),
+    getFee(client, config, "data_access", opts)
+  ]);
+  if (registration.asset.toLowerCase() !== dataAccess.asset.toLowerCase()) {
+    throw new Error(
+      `FeeRegistry asset mismatch: registration=${registration.asset} vs data_access=${dataAccess.asset}. The gateway requires both fees to settle in the same asset.`
+    );
+  }
+  return {
+    asset: registration.asset,
+    registrationFee: registration.amount,
+    dataAccessFee: dataAccess.amount,
+    registrationPayee: registration.payee,
+    dataAccessPayee: dataAccess.payee
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FEE_REGISTRY_ABI,
+  getFee,
+  getOpFee
+});
+//# sourceMappingURL=fee-registry.cjs.map

package/dist/protocol/fee-registry.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/protocol/fee-registry.ts"],"sourcesContent":["/**\n * Adapter for the on-chain FeeRegistry contract — the source of truth the\n * gateway re-reads on every /v1/escrow/pay to size the payment amount.\n *\n * The registry stores per-operation `{amount, asset, payee, enabled}`\n * records keyed on `keccak256(name)`. SDK consumers (builders sizing\n * payments) MUST read fees from this contract rather than hardcoding\n * them, or the signed `amount` won't match the gateway's expected total\n * and /v1/escrow/pay returns 400.\n *\n * Two operation names are wired up today:\n *   - 'registration' — one-time fee charged the first time a payment\n *     lands for a grant in 'pending' payment_status.\n *   - 'data_access'  — per-access fee charged every accepted payment.\n *\n * Deployers can override the on-chain operation names via the gateway's\n * FEE_REGISTRY_REGISTRATION_OP / FEE_REGISTRY_DATA_ACCESS_OP env vars;\n * the matching SDK escape hatch is the `opts.registrationOpName` /\n * `opts.dataAccessOpName` arguments.\n *\n * This module is signer/transport-agnostic — callers pass in their own\n * `PublicClient` for the contract reads. No caching here; a long-running\n * service consumer should wrap with their own TTL. Mirrors\n * data-gateway/lib/fee-registry.ts byte-for-byte.\n *\n * @category Protocol\n */\nimport { parseAbi, type Address, type Hex, type PublicClient } from \"viem\";\nimport type { DataPortabilityGatewayConfig } from \"./eip712\";\n\nexport const FEE_REGISTRY_ABI = parseAbi([\n  \"struct Fee { uint256 amount; address asset; address payee; bool enabled; }\",\n  \"function fees(bytes32 operation) view returns (Fee)\",\n  \"function operationKey(string name) pure returns (bytes32)\",\n]);\n\nexport type FeeKind = \"registration\" | \"data_access\";\n\nexport interface FeeEntry {\n  amount: bigint;\n  // Asset the fee is denominated in. 0x0000…0000 = native VANA;\n  // anything else is an ERC-20 contract address.\n  asset: Address;\n  // The recipient the on-chain settle pass routes the fee to.\n  payee: Address;\n  enabled: boolean;\n}\n\n// Combined view that mirrors data-gateway/lib/op-fees.ts. Throws if the two\n// kinds disagree on `asset` because the pay handler accepts a single\n// `asset` on the payment payload — both fees must settle in the same one.\n// Payees can differ (registration → one treasury, data-access → another).\nexport interface OpFee {\n  asset: Address;\n  registrationFee: bigint;\n  dataAccessFee: bigint;\n  registrationPayee: Address;\n  dataAccessPayee: Address;\n}\n\nexport interface FeeRegistryOptions {\n  registrationOpName?: string;\n  dataAccessOpName?: string;\n}\n\nfunction operationNameFor(\n  kind: FeeKind,\n  opts: FeeRegistryOptions | undefined,\n): string {\n  if (kind === \"registration\") {\n    return opts?.registrationOpName ?? \"registration\";\n  }\n  return opts?.dataAccessOpName ?? \"data_access\";\n}\n\n/**\n * Reads one fee kind from the FeeRegistry. Calls the contract's\n * `operationKey(name)` first to derive the bytes32 key — matches the\n * gateway's approach exactly (could compute locally via keccak256, but\n * going through the contract eliminates any chance of encoding drift).\n *\n * Throws when:\n *  - the fee record's `enabled` flag is false (operator hasn't set it),\n *  - or the `payee` is the zero address (the contract's settle pre-flight\n *    rejects payouts to 0x0; surfacing it early gives a better error).\n */\nexport async function getFee(\n  client: PublicClient,\n  config: DataPortabilityGatewayConfig,\n  kind: FeeKind,\n  opts?: FeeRegistryOptions,\n): Promise<FeeEntry> {\n  const address = config.contracts.feeRegistry as Address;\n  const opName = operationNameFor(kind, opts);\n\n  const opKey = (await client.readContract({\n    address,\n    abi: FEE_REGISTRY_ABI,\n    functionName: \"operationKey\",\n    args: [opName],\n  })) as Hex;\n\n  const fee = (await client.readContract({\n    address,\n    abi: FEE_REGISTRY_ABI,\n    functionName: \"fees\",\n    args: [opKey],\n  })) as FeeEntry;\n\n  if (!fee.enabled) {\n    throw new Error(\n      `FeeRegistry: operation \"${opName}\" (kind=${kind}) is not enabled — operator must call setFeeByName before payments will validate`,\n    );\n  }\n  if (fee.payee === \"0x0000000000000000000000000000000000000000\") {\n    throw new Error(\n      `FeeRegistry: operation \"${opName}\" has zero-address payee — contract pre-flight rejects payouts to 0x0`,\n    );\n  }\n\n  return fee;\n}\n\n/**\n * Convenience: read both fee kinds and combine into the shape the pay\n * handler validates against. Throws if the two kinds disagree on asset\n * (the gateway requires both to settle in the same one).\n *\n * Builders use this at startup, then sign `amount = registrationFee +\n * dataAccessFee` for the first grant payment and `amount = dataAccessFee`\n * for subsequent ones.\n */\nexport async function getOpFee(\n  client: PublicClient,\n  config: DataPortabilityGatewayConfig,\n  opts?: FeeRegistryOptions,\n): Promise<OpFee> {\n  const [registration, dataAccess] = await Promise.all([\n    getFee(client, config, \"registration\", opts),\n    getFee(client, config, \"data_access\", opts),\n  ]);\n  if (registration.asset.toLowerCase() !== dataAccess.asset.toLowerCase()) {\n    throw new Error(\n      `FeeRegistry asset mismatch: registration=${registration.asset} vs data_access=${dataAccess.asset}. The gateway requires both fees to settle in the same asset.`,\n    );\n  }\n  return {\n    asset: registration.asset,\n    registrationFee: registration.amount,\n    dataAccessFee: dataAccess.amount,\n    registrationPayee: registration.payee,\n    dataAccessPayee: dataAccess.payee,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BA,kBAAoE;AAG7D,MAAM,uBAAmB,sBAAS;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AACF,CAAC;AA+BD,SAAS,iBACP,MACA,MACQ;AACR,MAAI,SAAS,gBAAgB;AAC3B,WAAO,MAAM,sBAAsB;AAAA,EACrC;AACA,SAAO,MAAM,oBAAoB;AACnC;AAaA,eAAsB,OACpB,QACA,QACA,MACA,MACmB;AACnB,QAAM,UAAU,OAAO,UAAU;AACjC,QAAM,SAAS,iBAAiB,MAAM,IAAI;AAE1C,QAAM,QAAS,MAAM,OAAO,aAAa;AAAA,IACvC;AAAA,IACA,KAAK;AAAA,IACL,cAAc;AAAA,IACd,MAAM,CAAC,MAAM;AAAA,EACf,CAAC;AAED,QAAM,MAAO,MAAM,OAAO,aAAa;AAAA,IACrC;AAAA,IACA,KAAK;AAAA,IACL,cAAc;AAAA,IACd,MAAM,CAAC,KAAK;AAAA,EACd,CAAC;AAED,MAAI,CAAC,IAAI,SAAS;AAChB,UAAM,IAAI;AAAA,MACR,2BAA2B,MAAM,WAAW,IAAI;AAAA,IAClD;AAAA,EACF;AACA,MAAI,IAAI,UAAU,8CAA8C;AAC9D,UAAM,IAAI;AAAA,MACR,2BAA2B,MAAM;AAAA,IACnC;AAAA,EACF;AAEA,SAAO;AACT;AAWA,eAAsB,SACpB,QACA,QACA,MACgB;AAChB,QAAM,CAAC,cAAc,UAAU,IAAI,MAAM,QAAQ,IAAI;AAAA,IACnD,OAAO,QAAQ,QAAQ,gBAAgB,IAAI;AAAA,IAC3C,OAAO,QAAQ,QAAQ,eAAe,IAAI;AAAA,EAC5C,CAAC;AACD,MAAI,aAAa,MAAM,YAAY,MAAM,WAAW,MAAM,YAAY,GAAG;AACvE,UAAM,IAAI;AAAA,MACR,4CAA4C,aAAa,KAAK,mBAAmB,WAAW,KAAK;AAAA,IACnG;AAAA,EACF;AACA,SAAO;AAAA,IACL,OAAO,aAAa;AAAA,IACpB,iBAAiB,aAAa;AAAA,IAC9B,eAAe,WAAW;AAAA,IAC1B,mBAAmB,aAAa;AAAA,IAChC,iBAAiB,WAAW;AAAA,EAC9B;AACF;","names":[]}

package/dist/protocol/fee-registry.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Adapter for the on-chain FeeRegistry contract — the source of truth the
+ * gateway re-reads on every /v1/escrow/pay to size the payment amount.
+ *
+ * The registry stores per-operation `{amount, asset, payee, enabled}`
+ * records keyed on `keccak256(name)`. SDK consumers (builders sizing
+ * payments) MUST read fees from this contract rather than hardcoding
+ * them, or the signed `amount` won't match the gateway's expected total
+ * and /v1/escrow/pay returns 400.
+ *
+ * Two operation names are wired up today:
+ *   - 'registration' — one-time fee charged the first time a payment
+ *     lands for a grant in 'pending' payment_status.
+ *   - 'data_access'  — per-access fee charged every accepted payment.
+ *
+ * Deployers can override the on-chain operation names via the gateway's
+ * FEE_REGISTRY_REGISTRATION_OP / FEE_REGISTRY_DATA_ACCESS_OP env vars;
+ * the matching SDK escape hatch is the `opts.registrationOpName` /
+ * `opts.dataAccessOpName` arguments.
+ *
+ * This module is signer/transport-agnostic — callers pass in their own
+ * `PublicClient` for the contract reads. No caching here; a long-running
+ * service consumer should wrap with their own TTL. Mirrors
+ * data-gateway/lib/fee-registry.ts byte-for-byte.
+ *
+ * @category Protocol
+ */
+import { type Address, type PublicClient } from "viem";
+import type { DataPortabilityGatewayConfig } from "./eip712";
+export declare const FEE_REGISTRY_ABI: readonly [{
+    readonly name: "fees";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "operation";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "uint256";
+            readonly name: "amount";
+        }, {
+            readonly type: "address";
+            readonly name: "asset";
+        }, {
+            readonly type: "address";
+            readonly name: "payee";
+        }, {
+            readonly type: "bool";
+            readonly name: "enabled";
+        }];
+    }];
+}, {
+    readonly name: "operationKey";
+    readonly type: "function";
+    readonly stateMutability: "pure";
+    readonly inputs: readonly [{
+        readonly type: "string";
+        readonly name: "name";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bytes32";
+    }];
+}];
+export type FeeKind = "registration" | "data_access";
+export interface FeeEntry {
+    amount: bigint;
+    asset: Address;
+    payee: Address;
+    enabled: boolean;
+}
+export interface OpFee {
+    asset: Address;
+    registrationFee: bigint;
+    dataAccessFee: bigint;
+    registrationPayee: Address;
+    dataAccessPayee: Address;
+}
+export interface FeeRegistryOptions {
+    registrationOpName?: string;
+    dataAccessOpName?: string;
+}
+/**
+ * Reads one fee kind from the FeeRegistry. Calls the contract's
+ * `operationKey(name)` first to derive the bytes32 key — matches the
+ * gateway's approach exactly (could compute locally via keccak256, but
+ * going through the contract eliminates any chance of encoding drift).
+ *
+ * Throws when:
+ *  - the fee record's `enabled` flag is false (operator hasn't set it),
+ *  - or the `payee` is the zero address (the contract's settle pre-flight
+ *    rejects payouts to 0x0; surfacing it early gives a better error).
+ */
+export declare function getFee(client: PublicClient, config: DataPortabilityGatewayConfig, kind: FeeKind, opts?: FeeRegistryOptions): Promise<FeeEntry>;
+/**
+ * Convenience: read both fee kinds and combine into the shape the pay
+ * handler validates against. Throws if the two kinds disagree on asset
+ * (the gateway requires both to settle in the same one).
+ *
+ * Builders use this at startup, then sign `amount = registrationFee +
+ * dataAccessFee` for the first grant payment and `amount = dataAccessFee`
+ * for subsequent ones.
+ */
+export declare function getOpFee(client: PublicClient, config: DataPortabilityGatewayConfig, opts?: FeeRegistryOptions): Promise<OpFee>;

package/dist/protocol/fee-registry.js

@@ -0,0 +1,63 @@
+import { parseAbi } from "viem";
+const FEE_REGISTRY_ABI = parseAbi([
+  "struct Fee { uint256 amount; address asset; address payee; bool enabled; }",
+  "function fees(bytes32 operation) view returns (Fee)",
+  "function operationKey(string name) pure returns (bytes32)"
+]);
+function operationNameFor(kind, opts) {
+  if (kind === "registration") {
+    return opts?.registrationOpName ?? "registration";
+  }
+  return opts?.dataAccessOpName ?? "data_access";
+}
+async function getFee(client, config, kind, opts) {
+  const address = config.contracts.feeRegistry;
+  const opName = operationNameFor(kind, opts);
+  const opKey = await client.readContract({
+    address,
+    abi: FEE_REGISTRY_ABI,
+    functionName: "operationKey",
+    args: [opName]
+  });
+  const fee = await client.readContract({
+    address,
+    abi: FEE_REGISTRY_ABI,
+    functionName: "fees",
+    args: [opKey]
+  });
+  if (!fee.enabled) {
+    throw new Error(
+      `FeeRegistry: operation "${opName}" (kind=${kind}) is not enabled \u2014 operator must call setFeeByName before payments will validate`
+    );
+  }
+  if (fee.payee === "0x0000000000000000000000000000000000000000") {
+    throw new Error(
+      `FeeRegistry: operation "${opName}" has zero-address payee \u2014 contract pre-flight rejects payouts to 0x0`
+    );
+  }
+  return fee;
+}
+async function getOpFee(client, config, opts) {
+  const [registration, dataAccess] = await Promise.all([
+    getFee(client, config, "registration", opts),
+    getFee(client, config, "data_access", opts)
+  ]);
+  if (registration.asset.toLowerCase() !== dataAccess.asset.toLowerCase()) {
+    throw new Error(
+      `FeeRegistry asset mismatch: registration=${registration.asset} vs data_access=${dataAccess.asset}. The gateway requires both fees to settle in the same asset.`
+    );
+  }
+  return {
+    asset: registration.asset,
+    registrationFee: registration.amount,
+    dataAccessFee: dataAccess.amount,
+    registrationPayee: registration.payee,
+    dataAccessPayee: dataAccess.payee
+  };
+}
+export {
+  FEE_REGISTRY_ABI,
+  getFee,
+  getOpFee
+};
+//# sourceMappingURL=fee-registry.js.map

package/dist/protocol/fee-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/protocol/fee-registry.ts"],"sourcesContent":["/**\n * Adapter for the on-chain FeeRegistry contract — the source of truth the\n * gateway re-reads on every /v1/escrow/pay to size the payment amount.\n *\n * The registry stores per-operation `{amount, asset, payee, enabled}`\n * records keyed on `keccak256(name)`. SDK consumers (builders sizing\n * payments) MUST read fees from this contract rather than hardcoding\n * them, or the signed `amount` won't match the gateway's expected total\n * and /v1/escrow/pay returns 400.\n *\n * Two operation names are wired up today:\n *   - 'registration' — one-time fee charged the first time a payment\n *     lands for a grant in 'pending' payment_status.\n *   - 'data_access'  — per-access fee charged every accepted payment.\n *\n * Deployers can override the on-chain operation names via the gateway's\n * FEE_REGISTRY_REGISTRATION_OP / FEE_REGISTRY_DATA_ACCESS_OP env vars;\n * the matching SDK escape hatch is the `opts.registrationOpName` /\n * `opts.dataAccessOpName` arguments.\n *\n * This module is signer/transport-agnostic — callers pass in their own\n * `PublicClient` for the contract reads. No caching here; a long-running\n * service consumer should wrap with their own TTL. Mirrors\n * data-gateway/lib/fee-registry.ts byte-for-byte.\n *\n * @category Protocol\n */\nimport { parseAbi, type Address, type Hex, type PublicClient } from \"viem\";\nimport type { DataPortabilityGatewayConfig } from \"./eip712\";\n\nexport const FEE_REGISTRY_ABI = parseAbi([\n  \"struct Fee { uint256 amount; address asset; address payee; bool enabled; }\",\n  \"function fees(bytes32 operation) view returns (Fee)\",\n  \"function operationKey(string name) pure returns (bytes32)\",\n]);\n\nexport type FeeKind = \"registration\" | \"data_access\";\n\nexport interface FeeEntry {\n  amount: bigint;\n  // Asset the fee is denominated in. 0x0000…0000 = native VANA;\n  // anything else is an ERC-20 contract address.\n  asset: Address;\n  // The recipient the on-chain settle pass routes the fee to.\n  payee: Address;\n  enabled: boolean;\n}\n\n// Combined view that mirrors data-gateway/lib/op-fees.ts. Throws if the two\n// kinds disagree on `asset` because the pay handler accepts a single\n// `asset` on the payment payload — both fees must settle in the same one.\n// Payees can differ (registration → one treasury, data-access → another).\nexport interface OpFee {\n  asset: Address;\n  registrationFee: bigint;\n  dataAccessFee: bigint;\n  registrationPayee: Address;\n  dataAccessPayee: Address;\n}\n\nexport interface FeeRegistryOptions {\n  registrationOpName?: string;\n  dataAccessOpName?: string;\n}\n\nfunction operationNameFor(\n  kind: FeeKind,\n  opts: FeeRegistryOptions | undefined,\n): string {\n  if (kind === \"registration\") {\n    return opts?.registrationOpName ?? \"registration\";\n  }\n  return opts?.dataAccessOpName ?? \"data_access\";\n}\n\n/**\n * Reads one fee kind from the FeeRegistry. Calls the contract's\n * `operationKey(name)` first to derive the bytes32 key — matches the\n * gateway's approach exactly (could compute locally via keccak256, but\n * going through the contract eliminates any chance of encoding drift).\n *\n * Throws when:\n *  - the fee record's `enabled` flag is false (operator hasn't set it),\n *  - or the `payee` is the zero address (the contract's settle pre-flight\n *    rejects payouts to 0x0; surfacing it early gives a better error).\n */\nexport async function getFee(\n  client: PublicClient,\n  config: DataPortabilityGatewayConfig,\n  kind: FeeKind,\n  opts?: FeeRegistryOptions,\n): Promise<FeeEntry> {\n  const address = config.contracts.feeRegistry as Address;\n  const opName = operationNameFor(kind, opts);\n\n  const opKey = (await client.readContract({\n    address,\n    abi: FEE_REGISTRY_ABI,\n    functionName: \"operationKey\",\n    args: [opName],\n  })) as Hex;\n\n  const fee = (await client.readContract({\n    address,\n    abi: FEE_REGISTRY_ABI,\n    functionName: \"fees\",\n    args: [opKey],\n  })) as FeeEntry;\n\n  if (!fee.enabled) {\n    throw new Error(\n      `FeeRegistry: operation \"${opName}\" (kind=${kind}) is not enabled — operator must call setFeeByName before payments will validate`,\n    );\n  }\n  if (fee.payee === \"0x0000000000000000000000000000000000000000\") {\n    throw new Error(\n      `FeeRegistry: operation \"${opName}\" has zero-address payee — contract pre-flight rejects payouts to 0x0`,\n    );\n  }\n\n  return fee;\n}\n\n/**\n * Convenience: read both fee kinds and combine into the shape the pay\n * handler validates against. Throws if the two kinds disagree on asset\n * (the gateway requires both to settle in the same one).\n *\n * Builders use this at startup, then sign `amount = registrationFee +\n * dataAccessFee` for the first grant payment and `amount = dataAccessFee`\n * for subsequent ones.\n */\nexport async function getOpFee(\n  client: PublicClient,\n  config: DataPortabilityGatewayConfig,\n  opts?: FeeRegistryOptions,\n): Promise<OpFee> {\n  const [registration, dataAccess] = await Promise.all([\n    getFee(client, config, \"registration\", opts),\n    getFee(client, config, \"data_access\", opts),\n  ]);\n  if (registration.asset.toLowerCase() !== dataAccess.asset.toLowerCase()) {\n    throw new Error(\n      `FeeRegistry asset mismatch: registration=${registration.asset} vs data_access=${dataAccess.asset}. The gateway requires both fees to settle in the same asset.`,\n    );\n  }\n  return {\n    asset: registration.asset,\n    registrationFee: registration.amount,\n    dataAccessFee: dataAccess.amount,\n    registrationPayee: registration.payee,\n    dataAccessPayee: dataAccess.payee,\n  };\n}\n"],"mappings":"AA2BA,SAAS,gBAA2D;AAG7D,MAAM,mBAAmB,SAAS;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AACF,CAAC;AA+BD,SAAS,iBACP,MACA,MACQ;AACR,MAAI,SAAS,gBAAgB;AAC3B,WAAO,MAAM,sBAAsB;AAAA,EACrC;AACA,SAAO,MAAM,oBAAoB;AACnC;AAaA,eAAsB,OACpB,QACA,QACA,MACA,MACmB;AACnB,QAAM,UAAU,OAAO,UAAU;AACjC,QAAM,SAAS,iBAAiB,MAAM,IAAI;AAE1C,QAAM,QAAS,MAAM,OAAO,aAAa;AAAA,IACvC;AAAA,IACA,KAAK;AAAA,IACL,cAAc;AAAA,IACd,MAAM,CAAC,MAAM;AAAA,EACf,CAAC;AAED,QAAM,MAAO,MAAM,OAAO,aAAa;AAAA,IACrC;AAAA,IACA,KAAK;AAAA,IACL,cAAc;AAAA,IACd,MAAM,CAAC,KAAK;AAAA,EACd,CAAC;AAED,MAAI,CAAC,IAAI,SAAS;AAChB,UAAM,IAAI;AAAA,MACR,2BAA2B,MAAM,WAAW,IAAI;AAAA,IAClD;AAAA,EACF;AACA,MAAI,IAAI,UAAU,8CAA8C;AAC9D,UAAM,IAAI;AAAA,MACR,2BAA2B,MAAM;AAAA,IACnC;AAAA,EACF;AAEA,SAAO;AACT;AAWA,eAAsB,SACpB,QACA,QACA,MACgB;AAChB,QAAM,CAAC,cAAc,UAAU,IAAI,MAAM,QAAQ,IAAI;AAAA,IACnD,OAAO,QAAQ,QAAQ,gBAAgB,IAAI;AAAA,IAC3C,OAAO,QAAQ,QAAQ,eAAe,IAAI;AAAA,EAC5C,CAAC;AACD,MAAI,aAAa,MAAM,YAAY,MAAM,WAAW,MAAM,YAAY,GAAG;AACvE,UAAM,IAAI;AAAA,MACR,4CAA4C,aAAa,KAAK,mBAAmB,WAAW,KAAK;AAAA,IACnG;AAAA,EACF;AACA,SAAO;AAAA,IACL,OAAO,aAAa;AAAA,IACpB,iBAAiB,aAAa;AAAA,IAC9B,eAAe,WAAW;AAAA,IAC1B,mBAAmB,aAAa;AAAA,IAChC,iBAAiB,WAAW;AAAA,EAC9B;AACF;","names":[]}

package/dist/protocol/fee-registry.test.d.ts

@@ -0,0 +1 @@
+export {};