@opendatalabs/vana-sdk 3.13.2 → 3.13.4-pr.184.80a4b1f

package/dist/index.node.cjs

@@ -1184,6 +1184,7 @@ __export(index_node_exports, {
   CallbackStorage: () => CallbackStorage,
   ContractFactory: () => ContractFactory,
   ContractNotFoundError: () => ContractNotFoundError,
+  DATA_ACCESS_OP_TYPE: () => DATA_ACCESS_OP_TYPE,
   DATA_REGISTRY_STATUS_ABI: () => DATA_REGISTRY_STATUS_ABI,
   DataFileEnvelopeSchema: () => DataFileEnvelopeSchema,
   DataPointStatus: () => DataPointStatus,
@@ -1193,6 +1194,7 @@ __export(index_node_exports, {
   ExpiredTokenError: () => ExpiredTokenError,
   FEE_REGISTRY_ABI: () => FEE_REGISTRY_ABI,
   GENERIC_PAYMENT_TYPES: () => GENERIC_PAYMENT_TYPES,
+  GRANT_OP_TYPE: () => GRANT_OP_TYPE,
   GRANT_REGISTRATION_TYPES: () => GRANT_REGISTRATION_TYPES,
   GRANT_REVOCATION_TYPES: () => GRANT_REVOCATION_TYPES,
   GoogleDriveStorage: () => GoogleDriveStorage,
@@ -1238,8 +1240,12 @@ __export(index_node_exports, {
   VanaError: () => VanaError,
   VanaStorage: () => VanaStorage,
   assertValidPkceVerifier: () => assertValidPkceVerifier,
+  authorizeEscrowPayment: () => authorizeEscrowPayment,
+  authorizeGrantPayment: () => authorizeGrantPayment,
   buildDepositNativeRequest: () => buildDepositNativeRequest,
   buildDepositTokenRequest: () => buildDepositTokenRequest,
+  buildEscrowPaymentHeader: () => buildEscrowPaymentHeader,
+  buildGrantPaymentHeader: () => buildGrantPaymentHeader,
   buildMarkDataPointUnavailableRequest: () => buildMarkDataPointUnavailableRequest,
   buildPersonalServerDataReadRequest: () => buildPersonalServerDataReadRequest,
   buildPersonalServerLiteOwnerBindingMessage: () => buildPersonalServerLiteOwnerBindingMessage,
@@ -1256,6 +1262,7 @@ __export(index_node_exports, {
   contractCacheForTesting: () => contractCacheForTesting,
   createBrowserPlatformAdapter: () => createBrowserPlatformAdapter,
   createDataFileEnvelope: () => createDataFileEnvelope,
+  createDefaultNonceSource: () => createDefaultNonceSource,
   createEscrowGatewayClient: () => createEscrowGatewayClient,
   createGatewayClient: () => createGatewayClient,
   createNodePlatformAdapter: () => createNodePlatformAdapter,
@@ -1300,8 +1307,11 @@ __export(index_node_exports, {
   mokshaServices: () => mokshaServices,
   mokshaTestnet: () => mokshaTestnet2,
   parsePSError: () => parsePSError,
+  parsePersonalServerPaymentRequired: () => parsePersonalServerPaymentRequired,
   parseScope: () => parseScope,
   parseWeb3SignedHeader: () => parseWeb3SignedHeader,
+  paymentReceiptFromHeader: () => paymentReceiptFromHeader,
+  paymentResponseMetadataFromHeader: () => paymentResponseMetadataFromHeader,
   personalServerDataReadPath: () => personalServerDataReadPath,
   personalServerRegistrationDomain: () => personalServerRegistrationDomain,
   readPersonalServerData: () => readPersonalServerData,
@@ -1315,6 +1325,8 @@ __export(index_node_exports, {
   signPersonalServerLiteOwnerBinding: () => signPersonalServerLiteOwnerBinding,
   signPersonalServerLiteOwnerBindingWithAccountClient: () => signPersonalServerLiteOwnerBindingWithAccountClient,
   signPersonalServerRegistrationWithAccount: () => signPersonalServerRegistrationWithAccount,
+  toDirectFeeBreakdown: () => toDirectFeeBreakdown,
+  toDirectPaymentReceipt: () => toDirectPaymentReceipt,
   vanaMainnet: () => vanaMainnet2,
   verifyGrantRegistration: () => verifyGrantRegistration,
   verifyPkceChallenge: () => verifyPkceChallenge,
@@ -34147,6 +34159,462 @@ function createEscrowGatewayClient(baseUrl) {
   };
 }
 
+// src/direct/escrow-payment.ts
+var GRANT_OP_TYPE = "grant";
+var DATA_ACCESS_OP_TYPE = "data_access";
+function toDirectFeeBreakdown(breakdown) {
+  return {
+    registrationFee: breakdown.registrationFee,
+    dataAccessFee: breakdown.dataAccessFee,
+    registrationPaid: breakdown.registrationPaid
+  };
+}
+function toDirectPaymentReceipt(result) {
+  return {
+    opType: result.opType,
+    opId: result.opId,
+    asset: result.asset,
+    amount: result.amount,
+    paymentNonce: result.paymentNonce,
+    breakdown: toDirectFeeBreakdown(result.breakdown),
+    paidAt: result.paidAt
+  };
+}
+function createDefaultNonceSource() {
+  const counters = /* @__PURE__ */ new Map();
+  return (payerAddress) => {
+    const key = payerAddress.toLowerCase();
+    const next = (counters.get(key) ?? 0n) + 1n;
+    counters.set(key, next);
+    return next;
+  };
+}
+var processLocalNonceSource = createDefaultNonceSource();
+var UINT256_MAX = (1n << 256n) - 1n;
+var ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+var BYTES32_RE = /^0x[0-9a-fA-F]{64}$/;
+var SIGNATURE_RE = /^0x[0-9a-fA-F]{130}$/;
+function isUint256Decimal(value, allowZero) {
+  const pattern = allowZero ? /^(0|[1-9]\d*)$/ : /^[1-9]\d*$/;
+  return value.length <= UINT256_MAX.toString().length && pattern.test(value) && BigInt(value) <= UINT256_MAX;
+}
+function isValidAccessRecord(record) {
+  return BYTES32_RE.test(record.dataPointId) && isUint256Decimal(record.version, false) && ADDRESS_RE.test(record.accessor) && BYTES32_RE.test(record.recordId) && SIGNATURE_RE.test(record.signature);
+}
+function validateSigningOperation(payerAddress, required) {
+  if (!ADDRESS_RE.test(payerAddress)) {
+    throw new Error("Payment payer must be a 20-byte EVM address");
+  }
+  if (!BYTES32_RE.test(required.opId)) {
+    throw new Error("Payment operation id must be a 32-byte hex value");
+  }
+  if (!ADDRESS_RE.test(required.asset || NATIVE_ASSET_ADDRESS)) {
+    throw new Error("Payment asset must be a 20-byte EVM address");
+  }
+  if (!isUint256Decimal(required.amount, true)) {
+    throw new Error("Payment amount must be a canonical uint256 decimal");
+  }
+  if (required.paymentNonce !== void 0 && !isUint256Decimal(required.paymentNonce, false)) {
+    throw new Error("Payment nonce must be a positive uint256 decimal");
+  }
+  const accessRecord = required.accessRecord;
+  if (required.opType === DATA_ACCESS_OP_TYPE) {
+    if (!accessRecord || !isValidAccessRecord(accessRecord)) {
+      throw new Error("Data-access payment requires a valid access record");
+    }
+    if (required.opId.toLowerCase() !== accessRecord.recordId.toLowerCase()) {
+      throw new Error(
+        "Data-access payment operation id must equal the access record id"
+      );
+    }
+    if (accessRecord.accessor.toLowerCase() !== payerAddress.toLowerCase()) {
+      throw new Error(
+        "Data-access payment accessor must equal the payment payer address"
+      );
+    }
+    return;
+  }
+  if (required.amount === "0") {
+    if (!accessRecord || !isValidAccessRecord(accessRecord) || accessRecord.accessor.toLowerCase() !== payerAddress.toLowerCase()) {
+      throw new Error(
+        "Zero-amount grant payments require a valid access record for the payer"
+      );
+    }
+  }
+}
+function base64EncodeJson(value) {
+  const bytes = new TextEncoder().encode(JSON.stringify(value));
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function base64DecodeJson(value) {
+  const binary = atob(value);
+  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+async function signEscrowPayment(params) {
+  const { payerAddress, required, config } = params;
+  validateSigningOperation(payerAddress, required);
+  const nonceSource = config.nonceSource ?? processLocalNonceSource;
+  const paymentNonce = BigInt(
+    required.paymentNonce ?? await nonceSource(payerAddress)
+  );
+  const asset = required.asset || NATIVE_ASSET_ADDRESS;
+  const opId = required.opId;
+  const amount = BigInt(required.amount);
+  if (amount < 0n || amount > UINT256_MAX) {
+    throw new Error("Payment amount must be a uint256");
+  }
+  if (paymentNonce <= 0n || paymentNonce > UINT256_MAX) {
+    throw new Error("Payment nonce must be a positive uint256");
+  }
+  const message = {
+    payerAddress,
+    opType: required.opType,
+    opId,
+    asset,
+    amount,
+    paymentNonce
+  };
+  const signature = await config.signTypedData({
+    domain: genericPaymentDomain(config.chainId, config.escrowContract),
+    types: GENERIC_PAYMENT_TYPES,
+    primaryType: "GenericPayment",
+    message
+  });
+  return {
+    message: {
+      ...message,
+      amount: amount.toString(),
+      paymentNonce: paymentNonce.toString()
+    },
+    signature,
+    ...required.accessRecord ? { accessRecord: required.accessRecord } : {}
+  };
+}
+async function buildEscrowPaymentHeader(params) {
+  const signed = await signEscrowPayment(params);
+  const payment = {
+    x402Version: 1,
+    scheme: "vana-escrow-grant",
+    network: params.required.network ?? `vana:${params.config.chainId}`,
+    payload: signed
+  };
+  return base64EncodeJson(payment);
+}
+async function buildGrantPaymentHeader(params) {
+  return buildEscrowPaymentHeader({
+    ...params,
+    required: {
+      ...params.required,
+      opType: GRANT_OP_TYPE,
+      opId: params.required.grantId
+    }
+  });
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function stringField(value, key) {
+  const field = value?.[key];
+  return typeof field === "string" ? field : void 0;
+}
+function isCanonicalIsoTimestamp(value) {
+  try {
+    return new Date(value).toISOString() === value;
+  } catch {
+    return false;
+  }
+}
+function paymentResponseMetadataFromHeader(header) {
+  if (!header) return void 0;
+  try {
+    const result = asRecord(base64DecodeJson(header));
+    const breakdown = asRecord(result?.breakdown);
+    const opType = stringField(result, "opType");
+    const opId = stringField(result, "opId");
+    const payerAddress = stringField(result, "payerAddress");
+    const asset = stringField(result, "asset");
+    const amount = stringField(result, "amount");
+    const paymentNonce = stringField(result, "paymentNonce");
+    const registrationFee = stringField(breakdown, "registrationFee");
+    const dataAccessFee = stringField(breakdown, "dataAccessFee");
+    const paidAt = stringField(result, "paidAt");
+    if (result?.success !== true || !opType || !opId || !BYTES32_RE.test(opId) || !payerAddress || !ADDRESS_RE.test(payerAddress) || !asset || !ADDRESS_RE.test(asset) || !amount || !isUint256Decimal(amount, true) || !paymentNonce || !isUint256Decimal(paymentNonce, false) || !registrationFee || !isUint256Decimal(registrationFee, true) || !dataAccessFee || !isUint256Decimal(dataAccessFee, true) || typeof breakdown?.registrationPaid !== "boolean" || !paidAt || !isCanonicalIsoTimestamp(paidAt)) {
+      return void 0;
+    }
+    return {
+      opType,
+      opId,
+      asset,
+      amount,
+      paymentNonce,
+      breakdown: {
+        registrationFee,
+        dataAccessFee,
+        registrationPaid: breakdown.registrationPaid
+      },
+      paidAt
+    };
+  } catch {
+    return void 0;
+  }
+}
+function paymentReceiptFromHeader(header) {
+  return paymentResponseMetadataFromHeader(header);
+}
+async function authorizeGrantPayment(params) {
+  return authorizeEscrowPayment({
+    ...params,
+    required: {
+      ...params.required,
+      opType: GRANT_OP_TYPE,
+      opId: params.required.grantId
+    }
+  });
+}
+async function authorizeEscrowPayment(params) {
+  const { payerAddress, config } = params;
+  const signed = await signEscrowPayment(params);
+  const result = await config.client.payForOp({
+    payerAddress,
+    opType: signed.message.opType,
+    opId: signed.message.opId,
+    asset: signed.message.asset,
+    amount: signed.message.amount,
+    paymentNonce: signed.message.paymentNonce,
+    signature: signed.signature,
+    accessRecord: signed.accessRecord
+  });
+  return toDirectPaymentReceipt(result);
+}
+
+// src/direct/errors.ts
+var PersonalServerReadError = class extends VanaError {
+  constructor(message, status, details) {
+    super(message, "DIRECT_PERSONAL_SERVER_READ_ERROR");
+    this.status = status;
+    this.details = details;
+  }
+  status;
+  details;
+};
+
+// src/direct/personal-server-read.ts
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function stringField2(record, field) {
+  const value = record?.[field];
+  return typeof value === "string" ? value : void 0;
+}
+function parseAccessRecord(value) {
+  const record = asRecord2(value);
+  const dataPointId = stringField2(record, "dataPointId");
+  const version = stringField2(record, "version");
+  const accessor = stringField2(record, "accessor");
+  const recordId = stringField2(record, "recordId");
+  const signature = stringField2(record, "signature");
+  if (!dataPointId || !version || !accessor || !recordId || !signature) {
+    return void 0;
+  }
+  return {
+    dataPointId,
+    version,
+    accessor,
+    recordId,
+    signature
+  };
+}
+function isBytes32Hex(value) {
+  return /^0x[0-9a-fA-F]{64}$/.test(value);
+}
+var UINT256_MAX2 = (1n << 256n) - 1n;
+function isAddressHex(value) {
+  return /^0x[0-9a-fA-F]{40}$/.test(value);
+}
+function isUint256Decimal2(value, allowZero) {
+  const pattern = allowZero ? /^(0|[1-9]\d*)$/ : /^[1-9]\d*$/;
+  return value.length <= UINT256_MAX2.toString().length && pattern.test(value) && BigInt(value) <= UINT256_MAX2;
+}
+function isValidDataAccessRecord(record) {
+  return isBytes32Hex(record.dataPointId) && isUint256Decimal2(record.version, false) && isAddressHex(record.accessor) && isBytes32Hex(record.recordId) && /^0x[0-9a-fA-F]{130}$/.test(record.signature);
+}
+function parseLegacyGrantOperation(params) {
+  const { challengeGrantId, challengeOpId, challengeOpType, grantId } = params;
+  const opType = challengeOpType ?? GRANT_OP_TYPE;
+  if (opType !== GRANT_OP_TYPE) {
+    throw new PersonalServerReadError(
+      "Personal Server payment challenge used an unsupported escrow op type",
+      402,
+      { opType: challengeOpType }
+    );
+  }
+  const opId = challengeOpId ?? challengeGrantId ?? grantId;
+  if (!opId || !isBytes32Hex(opId)) {
+    throw new PersonalServerReadError(
+      "Personal Server payment challenge used an invalid escrow op id",
+      402,
+      { opId }
+    );
+  }
+  if (opId.toLowerCase() !== grantId.toLowerCase()) {
+    throw new PersonalServerReadError(
+      "Personal Server payment challenge did not match the requested grant",
+      402,
+      { opId, grantId }
+    );
+  }
+  return { opType: GRANT_OP_TYPE, opId };
+}
+function hasDataAccessMarker(body) {
+  if (stringField2(body, "opType") === DATA_ACCESS_OP_TYPE) return true;
+  return Array.isArray(body.accepts) && body.accepts.some((value) => {
+    const accept = asRecord2(value);
+    return stringField2(asRecord2(accept?.message), "opType") === DATA_ACCESS_OP_TYPE;
+  });
+}
+function parseCanonicalDataAccessAccept(value) {
+  const accept = asRecord2(value);
+  const message = asRecord2(accept?.message);
+  if (stringField2(accept, "scheme") !== "vana-escrow-grant" || stringField2(message, "opType") !== DATA_ACCESS_OP_TYPE) {
+    return null;
+  }
+  const network = stringField2(accept, "network");
+  const payerAddress = stringField2(message, "payerAddress");
+  const opId = stringField2(message, "opId");
+  const asset = stringField2(message, "asset");
+  const amount = stringField2(message, "amount");
+  const paymentNonce = stringField2(message, "paymentNonce");
+  const accessRecord = parseAccessRecord(accept?.accessRecord);
+  const acceptAsset = stringField2(accept, "asset");
+  const acceptAmount = stringField2(accept, "amount");
+  if (!network || !payerAddress || !isAddressHex(payerAddress) || !opId || !isBytes32Hex(opId) || !asset || !isAddressHex(asset) || !amount || !isUint256Decimal2(amount, true) || !paymentNonce || !isUint256Decimal2(paymentNonce, false) || !accessRecord || !isValidDataAccessRecord(accessRecord) || payerAddress.toLowerCase() !== accessRecord.accessor.toLowerCase() || opId.toLowerCase() !== accessRecord.recordId.toLowerCase() || !acceptAsset || acceptAsset.toLowerCase() !== asset.toLowerCase() || acceptAmount !== amount) {
+    return null;
+  }
+  return {
+    opType: DATA_ACCESS_OP_TYPE,
+    opId,
+    network,
+    paymentNonce,
+    accessRecord,
+    asset,
+    amount
+  };
+}
+function parseCanonicalDataAccessPayment(params) {
+  const { body, grantId, raw } = params;
+  if (body.x402Version !== 1 || body.error !== "PAYMENT_REQUIRED") {
+    throw new PersonalServerReadError(
+      "Personal Server data-access payment response was not a canonical x402 challenge",
+      402
+    );
+  }
+  const operation = Array.isArray(body.accepts) ? body.accepts.map(parseCanonicalDataAccessAccept).find((candidate) => candidate !== null) : void 0;
+  if (!operation) {
+    throw new PersonalServerReadError(
+      "Personal Server data-access payment challenge was untrusted or incomplete",
+      402
+    );
+  }
+  return { grantId, raw, ...operation };
+}
+function preferredLegacyAccept(body) {
+  if (!Array.isArray(body.accepts)) return void 0;
+  return body.accepts.map(asRecord2).find((accept) => {
+    const message = asRecord2(accept?.message);
+    return stringField2(accept, "scheme") === "vana-escrow-grant" && stringField2(message, "opType") === GRANT_OP_TYPE;
+  });
+}
+async function parsePersonalServerPaymentRequired(res, grantId) {
+  let raw = void 0;
+  try {
+    raw = await res.json();
+  } catch {
+    raw = void 0;
+  }
+  const body = asRecord2(raw) ?? {};
+  if (hasDataAccessMarker(body)) {
+    return parseCanonicalDataAccessPayment({ body, grantId, raw });
+  }
+  const hasAcceptsEnvelope = Object.prototype.hasOwnProperty.call(
+    body,
+    "accepts"
+  );
+  if (hasAcceptsEnvelope && (body.x402Version !== 1 || body.error !== "PAYMENT_REQUIRED")) {
+    throw new PersonalServerReadError(
+      "Personal Server grant payment response was not a canonical x402 challenge",
+      402
+    );
+  }
+  const accept = preferredLegacyAccept(body);
+  if (hasAcceptsEnvelope && !accept) {
+    throw new PersonalServerReadError(
+      "Personal Server grant payment challenge had no compatible escrow offer",
+      402
+    );
+  }
+  if (accept) {
+    const message = asRecord2(accept.message);
+    const network = stringField2(accept, "network");
+    const payerAddress = stringField2(message, "payerAddress");
+    const opId = stringField2(message, "opId");
+    const asset = stringField2(message, "asset");
+    const amount = stringField2(message, "amount");
+    const paymentNonce = stringField2(message, "paymentNonce");
+    const acceptAsset = stringField2(accept, "asset");
+    const acceptAmount = stringField2(accept, "amount");
+    const accessRecord2 = parseAccessRecord(accept.accessRecord);
+    const hasAccessRecord = accept.accessRecord !== void 0;
+    if (!network || !payerAddress || !isAddressHex(payerAddress) || !opId || !isBytes32Hex(opId) || !asset || !isAddressHex(asset) || !amount || !isUint256Decimal2(amount, true) || !paymentNonce || !isUint256Decimal2(paymentNonce, false) || !acceptAsset || acceptAsset.toLowerCase() !== asset.toLowerCase() || acceptAmount !== amount || hasAccessRecord && (!accessRecord2 || !isValidDataAccessRecord(accessRecord2) || accessRecord2.accessor.toLowerCase() !== payerAddress.toLowerCase()) || amount === "0" && !accessRecord2) {
+      throw new PersonalServerReadError(
+        "Personal Server grant payment challenge was untrusted or incomplete",
+        402
+      );
+    }
+    const operation2 = parseLegacyGrantOperation({
+      challengeOpId: opId,
+      challengeOpType: stringField2(message, "opType"),
+      grantId
+    });
+    return {
+      grantId,
+      ...operation2,
+      network,
+      paymentNonce,
+      asset,
+      amount,
+      raw,
+      ...accessRecord2 ? { accessRecord: accessRecord2 } : {}
+    };
+  }
+  const challengeGrantId = stringField2(body, "grantId");
+  const challengeOpId = stringField2(body, "opId");
+  const challengeOpType = stringField2(body, "opType");
+  const accessRecord = parseAccessRecord(body.accessRecord);
+  const operation = parseLegacyGrantOperation({
+    challengeGrantId,
+    challengeOpId,
+    challengeOpType,
+    grantId
+  });
+  const amountValue = stringField2(body, "amount") ?? stringField2(body, "maxAmountRequired") ?? "0";
+  const payment = {
+    grantId,
+    network: stringField2(body, "network"),
+    paymentNonce: stringField2(body, "paymentNonce"),
+    asset: stringField2(body, "asset") ?? NATIVE_ASSET_ADDRESS,
+    amount: amountValue,
+    raw
+  };
+  return {
+    ...payment,
+    ...operation,
+    ...accessRecord ? { accessRecord } : {}
+  };
+}
+
 // src/types/ps-errors.ts
 var PSError = class extends Error {
   constructor(code, message) {
@@ -34222,6 +34690,7 @@ async function parsePSError(response) {
   CallbackStorage,
   ContractFactory,
   ContractNotFoundError,
+  DATA_ACCESS_OP_TYPE,
   DATA_REGISTRY_STATUS_ABI,
   DataFileEnvelopeSchema,
   DataPointStatus,
@@ -34231,6 +34700,7 @@ async function parsePSError(response) {
   ExpiredTokenError,
   FEE_REGISTRY_ABI,
   GENERIC_PAYMENT_TYPES,
+  GRANT_OP_TYPE,
   GRANT_REGISTRATION_TYPES,
   GRANT_REVOCATION_TYPES,
   GoogleDriveStorage,
@@ -34276,8 +34746,12 @@ async function parsePSError(response) {
   VanaError,
   VanaStorage,
   assertValidPkceVerifier,
+  authorizeEscrowPayment,
+  authorizeGrantPayment,
   buildDepositNativeRequest,
   buildDepositTokenRequest,
+  buildEscrowPaymentHeader,
+  buildGrantPaymentHeader,
   buildMarkDataPointUnavailableRequest,
   buildPersonalServerDataReadRequest,
   buildPersonalServerLiteOwnerBindingMessage,
@@ -34294,6 +34768,7 @@ async function parsePSError(response) {
   contractCacheForTesting,
   createBrowserPlatformAdapter,
   createDataFileEnvelope,
+  createDefaultNonceSource,
   createEscrowGatewayClient,
   createGatewayClient,
   createNodePlatformAdapter,
@@ -34338,8 +34813,11 @@ async function parsePSError(response) {
   mokshaServices,
   mokshaTestnet,
   parsePSError,
+  parsePersonalServerPaymentRequired,
   parseScope,
   parseWeb3SignedHeader,
+  paymentReceiptFromHeader,
+  paymentResponseMetadataFromHeader,
   personalServerDataReadPath,
   personalServerRegistrationDomain,
   readPersonalServerData,
@@ -34353,6 +34831,8 @@ async function parsePSError(response) {
   signPersonalServerLiteOwnerBinding,
   signPersonalServerLiteOwnerBindingWithAccountClient,
   signPersonalServerRegistrationWithAccount,
+  toDirectFeeBreakdown,
+  toDirectPaymentReceipt,
   vanaMainnet,
   verifyGrantRegistration,
   verifyPkceChallenge,