s402 0.1.0

package/dist/errors.d.mts

@@ -0,0 +1,48 @@
+//#region src/errors.d.ts
+/**
+ * s402 Error Types — typed error codes with recovery hints
+ *
+ * Every s402 error tells the client:
+ *   1. What went wrong (code)
+ *   2. Whether it can retry (retryable)
+ *   3. What to do about it (suggestedAction)
+ */
+declare const s402ErrorCode: {
+  readonly INSUFFICIENT_BALANCE: "INSUFFICIENT_BALANCE";
+  readonly MANDATE_EXPIRED: "MANDATE_EXPIRED";
+  readonly MANDATE_LIMIT_EXCEEDED: "MANDATE_LIMIT_EXCEEDED";
+  readonly STREAM_DEPLETED: "STREAM_DEPLETED";
+  readonly ESCROW_DEADLINE_PASSED: "ESCROW_DEADLINE_PASSED";
+  readonly UNLOCK_DECRYPTION_FAILED: "UNLOCK_DECRYPTION_FAILED";
+  readonly FINALITY_TIMEOUT: "FINALITY_TIMEOUT";
+  readonly FACILITATOR_UNAVAILABLE: "FACILITATOR_UNAVAILABLE";
+  readonly INVALID_PAYLOAD: "INVALID_PAYLOAD";
+  readonly SCHEME_NOT_SUPPORTED: "SCHEME_NOT_SUPPORTED";
+  readonly NETWORK_MISMATCH: "NETWORK_MISMATCH";
+  readonly SIGNATURE_INVALID: "SIGNATURE_INVALID";
+  readonly REQUIREMENTS_EXPIRED: "REQUIREMENTS_EXPIRED";
+  readonly VERIFICATION_FAILED: "VERIFICATION_FAILED";
+};
+type s402ErrorCodeType = (typeof s402ErrorCode)[keyof typeof s402ErrorCode];
+interface s402ErrorInfo {
+  code: s402ErrorCodeType;
+  message: string;
+  retryable: boolean;
+  suggestedAction: string;
+}
+/**
+ * Create a typed s402 error with recovery hints.
+ */
+declare function createS402Error(code: s402ErrorCodeType, message?: string): s402ErrorInfo;
+/**
+ * s402 error class for throwing in code.
+ */
+declare class s402Error extends Error {
+  readonly code: s402ErrorCodeType;
+  readonly retryable: boolean;
+  readonly suggestedAction: string;
+  constructor(code: s402ErrorCodeType, message?: string);
+  toJSON(): s402ErrorInfo;
+}
+//#endregion
+export { createS402Error, s402Error, s402ErrorCode, s402ErrorCodeType, s402ErrorInfo };

package/dist/errors.mjs

@@ -0,0 +1,123 @@
+//#region src/errors.ts
+/**
+* s402 Error Types — typed error codes with recovery hints
+*
+* Every s402 error tells the client:
+*   1. What went wrong (code)
+*   2. Whether it can retry (retryable)
+*   3. What to do about it (suggestedAction)
+*/
+const s402ErrorCode = {
+	INSUFFICIENT_BALANCE: "INSUFFICIENT_BALANCE",
+	MANDATE_EXPIRED: "MANDATE_EXPIRED",
+	MANDATE_LIMIT_EXCEEDED: "MANDATE_LIMIT_EXCEEDED",
+	STREAM_DEPLETED: "STREAM_DEPLETED",
+	ESCROW_DEADLINE_PASSED: "ESCROW_DEADLINE_PASSED",
+	UNLOCK_DECRYPTION_FAILED: "UNLOCK_DECRYPTION_FAILED",
+	FINALITY_TIMEOUT: "FINALITY_TIMEOUT",
+	FACILITATOR_UNAVAILABLE: "FACILITATOR_UNAVAILABLE",
+	INVALID_PAYLOAD: "INVALID_PAYLOAD",
+	SCHEME_NOT_SUPPORTED: "SCHEME_NOT_SUPPORTED",
+	NETWORK_MISMATCH: "NETWORK_MISMATCH",
+	SIGNATURE_INVALID: "SIGNATURE_INVALID",
+	REQUIREMENTS_EXPIRED: "REQUIREMENTS_EXPIRED",
+	VERIFICATION_FAILED: "VERIFICATION_FAILED"
+};
+/** Error recovery hints for each error code */
+const ERROR_HINTS = {
+	INSUFFICIENT_BALANCE: {
+		retryable: false,
+		suggestedAction: "Top up wallet balance or try with a smaller amount"
+	},
+	MANDATE_EXPIRED: {
+		retryable: false,
+		suggestedAction: "Request a new mandate from the delegator"
+	},
+	MANDATE_LIMIT_EXCEEDED: {
+		retryable: false,
+		suggestedAction: "Request mandate increase or split across transactions"
+	},
+	STREAM_DEPLETED: {
+		retryable: true,
+		suggestedAction: "Top up the stream deposit"
+	},
+	ESCROW_DEADLINE_PASSED: {
+		retryable: false,
+		suggestedAction: "Create a new escrow with a later deadline"
+	},
+	UNLOCK_DECRYPTION_FAILED: {
+		retryable: true,
+		suggestedAction: "Re-request decryption key with a fresh session key"
+	},
+	FINALITY_TIMEOUT: {
+		retryable: true,
+		suggestedAction: "Transaction submitted but not confirmed — retry finality check"
+	},
+	FACILITATOR_UNAVAILABLE: {
+		retryable: true,
+		suggestedAction: "Fall back to direct settlement if signer is available"
+	},
+	INVALID_PAYLOAD: {
+		retryable: false,
+		suggestedAction: "Check payload format and re-sign the transaction"
+	},
+	SCHEME_NOT_SUPPORTED: {
+		retryable: false,
+		suggestedAction: "Use the \"exact\" scheme (always supported for x402 compat)"
+	},
+	NETWORK_MISMATCH: {
+		retryable: false,
+		suggestedAction: "Ensure client and server are on the same Sui network"
+	},
+	SIGNATURE_INVALID: {
+		retryable: false,
+		suggestedAction: "Re-sign the transaction with the correct keypair"
+	},
+	REQUIREMENTS_EXPIRED: {
+		retryable: true,
+		suggestedAction: "Re-fetch payment requirements from the server"
+	},
+	VERIFICATION_FAILED: {
+		retryable: false,
+		suggestedAction: "Check payment amount and transaction structure"
+	}
+};
+/**
+* Create a typed s402 error with recovery hints.
+*/
+function createS402Error(code, message) {
+	const hints = ERROR_HINTS[code];
+	return {
+		code,
+		message: message ?? code,
+		retryable: hints.retryable,
+		suggestedAction: hints.suggestedAction
+	};
+}
+/**
+* s402 error class for throwing in code.
+*/
+var s402Error = class extends Error {
+	code;
+	retryable;
+	suggestedAction;
+	constructor(code, message) {
+		const info = createS402Error(code, message);
+		super(info.message);
+		this.name = "s402Error";
+		this.code = info.code;
+		this.retryable = info.retryable;
+		this.suggestedAction = info.suggestedAction;
+	}
+	toJSON() {
+		return {
+			code: this.code,
+			message: this.message,
+			retryable: this.retryable,
+			suggestedAction: this.suggestedAction
+		};
+	}
+};
+
+//#endregion
+export { createS402Error, s402Error, s402ErrorCode };

package/dist/http.d.mts

@@ -0,0 +1,67 @@
+import { s402PaymentPayload, s402PaymentRequirements, s402SettleResponse } from "./types.mjs";
+
+//#region src/http.d.ts
+/** Encode payment requirements for the `payment-required` header */
+declare function encodePaymentRequired(requirements: s402PaymentRequirements): string;
+/** Encode payment payload for the `x-payment` header */
+declare function encodePaymentPayload(payload: s402PaymentPayload): string;
+/** Encode settlement response for the `payment-response` header */
+declare function encodeSettleResponse(response: s402SettleResponse): string;
+/** Return a clean object with only known s402 requirement fields. */
+declare function pickRequirementsFields(obj: Record<string, unknown>): s402PaymentRequirements;
+/** Decode payment requirements from the `payment-required` header */
+declare function decodePaymentRequired(header: string): s402PaymentRequirements;
+/** Decode payment payload from the `x-payment` header */
+declare function decodePaymentPayload(header: string): s402PaymentPayload;
+/** Decode settlement response from the `payment-response` header */
+declare function decodeSettleResponse(header: string): s402SettleResponse;
+/**
+ * Check that a string represents a canonical non-negative integer (valid for Sui MIST amounts).
+ * Rejects leading zeros ("007"), empty strings, negatives, decimals.
+ * Accepts "0" as the only zero representation.
+ */
+declare function isValidAmount(s: string): boolean;
+/**
+ * Validate mandate requirements sub-object.
+ * Mandate is protocol-level (used for authorization decisions), so we validate fully.
+ */
+declare function validateMandateShape(value: unknown): void;
+/**
+ * Validate stream sub-object.
+ * Checks required fields are present and correctly typed.
+ */
+declare function validateStreamShape(value: unknown): void;
+/**
+ * Validate escrow sub-object.
+ */
+declare function validateEscrowShape(value: unknown): void;
+/**
+ * Validate unlock sub-object (pay-to-decrypt encrypted content).
+ */
+declare function validateUnlockShape(value: unknown): void;
+/**
+ * Validate prepaid sub-object.
+ */
+declare function validatePrepaidShape(value: unknown): void;
+/**
+ * Validate all optional sub-objects on a requirements record.
+ * Called from validateRequirementsShape during wire decode and compat normalization.
+ */
+declare function validateSubObjects(record: Record<string, unknown>): void;
+/** Validate that decoded payment requirements have the required shape. */
+declare function validateRequirementsShape(obj: unknown): void;
+/**
+ * Detect whether a 402 response uses s402 or x402 protocol.
+ *
+ * Check: decode the `payment-required` header and look for `s402Version`.
+ * If present → s402. If absent → x402 (or raw 402).
+ */
+declare function detectProtocol(headers: Headers): 's402' | 'x402' | 'unknown';
+/**
+ * Extract s402 payment requirements from a 402 Response.
+ * Returns null if the header is missing, malformed, or not s402 format.
+ * For x402 responses, decode the header manually and use normalizeRequirements().
+ */
+declare function extractRequirementsFromResponse(response: Response): s402PaymentRequirements | null;
+//#endregion
+export { decodePaymentPayload, decodePaymentRequired, decodeSettleResponse, detectProtocol, encodePaymentPayload, encodePaymentRequired, encodeSettleResponse, extractRequirementsFromResponse, isValidAmount, pickRequirementsFields, validateEscrowShape, validateMandateShape, validatePrepaidShape, validateRequirementsShape, validateStreamShape, validateSubObjects, validateUnlockShape };

package/dist/http.mjs

@@ -0,0 +1,274 @@
+import { S402_HEADERS } from "./types.mjs";
+import { s402Error } from "./errors.mjs";
+
+//#region src/http.ts
+/** Encode a UTF-8 string to base64. Safe for any Unicode content. */
+function toBase64(str) {
+	const bytes = new TextEncoder().encode(str);
+	return btoa(Array.from(bytes, (b) => String.fromCharCode(b)).join(""));
+}
+/** Decode base64 to a UTF-8 string. Safe for any Unicode content. */
+function fromBase64(b64) {
+	const binary = atob(b64);
+	const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+	return new TextDecoder().decode(bytes);
+}
+/** Encode payment requirements for the `payment-required` header */
+function encodePaymentRequired(requirements) {
+	return toBase64(JSON.stringify(requirements));
+}
+/** Encode payment payload for the `x-payment` header */
+function encodePaymentPayload(payload) {
+	return toBase64(JSON.stringify(payload));
+}
+/** Encode settlement response for the `payment-response` header */
+function encodeSettleResponse(response) {
+	return toBase64(JSON.stringify(response));
+}
+/**
+* Maximum base64 header size (64KB). Defense-in-depth against oversized payloads.
+* Most HTTP servers enforce smaller limits (Node: 16KB, CF Workers: 128KB),
+* but a wire format library should not rely on runtime enforcement.
+*/
+const MAX_HEADER_BYTES = 64 * 1024;
+/**
+* Known top-level keys on s402PaymentRequirements.
+* Single source of truth — compat.ts imports pickRequirementsFields from here.
+* Used by decodePaymentRequired to strip unknown keys at the HTTP trust boundary.
+*/
+const S402_REQUIREMENTS_KEYS = new Set([
+	"s402Version",
+	"accepts",
+	"network",
+	"asset",
+	"amount",
+	"payTo",
+	"facilitatorUrl",
+	"mandate",
+	"protocolFeeBps",
+	"protocolFeeAddress",
+	"receiptRequired",
+	"settlementMode",
+	"expiresAt",
+	"stream",
+	"escrow",
+	"unlock",
+	"prepaid",
+	"extensions"
+]);
+/** Return a clean object with only known s402 requirement fields. */
+function pickRequirementsFields(obj) {
+	const result = {};
+	for (const key of S402_REQUIREMENTS_KEYS) if (key in obj) result[key] = obj[key];
+	return result;
+}
+/** Decode payment requirements from the `payment-required` header */
+function decodePaymentRequired(header) {
+	if (header.length > MAX_HEADER_BYTES) throw new s402Error("INVALID_PAYLOAD", `payment-required header exceeds maximum size (${header.length} > ${MAX_HEADER_BYTES})`);
+	let parsed;
+	try {
+		parsed = JSON.parse(fromBase64(header));
+	} catch (e) {
+		throw new s402Error("INVALID_PAYLOAD", `Failed to decode payment-required header: ${e instanceof Error ? e.message : "invalid base64 or JSON"}`);
+	}
+	validateRequirementsShape(parsed);
+	return pickRequirementsFields(parsed);
+}
+/** Decode payment payload from the `x-payment` header */
+function decodePaymentPayload(header) {
+	if (header.length > MAX_HEADER_BYTES) throw new s402Error("INVALID_PAYLOAD", `x-payment header exceeds maximum size (${header.length} > ${MAX_HEADER_BYTES})`);
+	let parsed;
+	try {
+		parsed = JSON.parse(fromBase64(header));
+	} catch (e) {
+		throw new s402Error("INVALID_PAYLOAD", `Failed to decode x-payment header: ${e instanceof Error ? e.message : "invalid base64 or JSON"}`);
+	}
+	validatePayloadShape(parsed);
+	return parsed;
+}
+/** Decode settlement response from the `payment-response` header */
+function decodeSettleResponse(header) {
+	if (header.length > MAX_HEADER_BYTES) throw new s402Error("INVALID_PAYLOAD", `payment-response header exceeds maximum size (${header.length} > ${MAX_HEADER_BYTES})`);
+	let parsed;
+	try {
+		parsed = JSON.parse(fromBase64(header));
+	} catch (e) {
+		throw new s402Error("INVALID_PAYLOAD", `Failed to decode payment-response header: ${e instanceof Error ? e.message : "invalid base64 or JSON"}`);
+	}
+	validateSettleShape(parsed);
+	return parsed;
+}
+/** Valid s402 payment scheme values */
+const VALID_SCHEMES = new Set([
+	"exact",
+	"stream",
+	"escrow",
+	"unlock",
+	"prepaid"
+]);
+/**
+* Check that a string represents a canonical non-negative integer (valid for Sui MIST amounts).
+* Rejects leading zeros ("007"), empty strings, negatives, decimals.
+* Accepts "0" as the only zero representation.
+*/
+function isValidAmount(s) {
+	return /^(0|[1-9][0-9]*)$/.test(s);
+}
+/** Helper: assert obj is a plain object (not null/array/primitive). */
+function assertPlainObject(value, label) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) throw new s402Error("INVALID_PAYLOAD", `${label} must be a plain object, got ${Array.isArray(value) ? "array" : typeof value}`);
+}
+/** Helper: assert field is a string. */
+function assertString(obj, field, label) {
+	if (typeof obj[field] !== "string") throw new s402Error("INVALID_PAYLOAD", `${label}.${field} must be a string, got ${typeof obj[field]}`);
+}
+/** Helper: assert optional field is a string if present. */
+function assertOptionalString(obj, field, label) {
+	if (obj[field] !== void 0 && typeof obj[field] !== "string") throw new s402Error("INVALID_PAYLOAD", `${label}.${field} must be a string if provided, got ${typeof obj[field]}`);
+}
+/**
+* Validate mandate requirements sub-object.
+* Mandate is protocol-level (used for authorization decisions), so we validate fully.
+*/
+function validateMandateShape(value) {
+	assertPlainObject(value, "mandate");
+	const obj = value;
+	if (typeof obj.required !== "boolean") throw new s402Error("INVALID_PAYLOAD", `mandate.required must be a boolean, got ${typeof obj.required}`);
+	assertOptionalString(obj, "minPerTx", "mandate");
+	assertOptionalString(obj, "coinType", "mandate");
+}
+/**
+* Validate stream sub-object.
+* Checks required fields are present and correctly typed.
+*/
+function validateStreamShape(value) {
+	assertPlainObject(value, "stream");
+	const obj = value;
+	assertString(obj, "ratePerSecond", "stream");
+	assertString(obj, "budgetCap", "stream");
+	assertString(obj, "minDeposit", "stream");
+	assertOptionalString(obj, "streamSetupUrl", "stream");
+}
+/**
+* Validate escrow sub-object.
+*/
+function validateEscrowShape(value) {
+	assertPlainObject(value, "escrow");
+	const obj = value;
+	assertString(obj, "seller", "escrow");
+	assertString(obj, "deadlineMs", "escrow");
+	assertOptionalString(obj, "arbiter", "escrow");
+}
+/**
+* Validate unlock sub-object (pay-to-decrypt encrypted content).
+*/
+function validateUnlockShape(value) {
+	assertPlainObject(value, "unlock");
+	const obj = value;
+	assertString(obj, "encryptionId", "unlock");
+	assertString(obj, "walrusBlobId", "unlock");
+	assertString(obj, "encryptionPackageId", "unlock");
+}
+/**
+* Validate prepaid sub-object.
+*/
+function validatePrepaidShape(value) {
+	assertPlainObject(value, "prepaid");
+	const obj = value;
+	assertString(obj, "ratePerCall", "prepaid");
+	assertString(obj, "minDeposit", "prepaid");
+	assertString(obj, "withdrawalDelayMs", "prepaid");
+	assertOptionalString(obj, "maxCalls", "prepaid");
+}
+/**
+* Validate all optional sub-objects on a requirements record.
+* Called from validateRequirementsShape during wire decode and compat normalization.
+*/
+function validateSubObjects(record) {
+	if (record.mandate !== void 0) validateMandateShape(record.mandate);
+	if (record.stream !== void 0) validateStreamShape(record.stream);
+	if (record.escrow !== void 0) validateEscrowShape(record.escrow);
+	if (record.unlock !== void 0) validateUnlockShape(record.unlock);
+	if (record.prepaid !== void 0) validatePrepaidShape(record.prepaid);
+}
+/** Validate that decoded payment requirements have the required shape. */
+function validateRequirementsShape(obj) {
+	if (obj == null || typeof obj !== "object") throw new s402Error("INVALID_PAYLOAD", "Payment requirements is not an object");
+	const record = obj;
+	if (record.s402Version === void 0) throw new s402Error("INVALID_PAYLOAD", "Missing s402Version. For x402 format, use normalizeRequirements() from s402/compat.");
+	if (record.s402Version !== "1") throw new s402Error("INVALID_PAYLOAD", `Unsupported s402 version "${record.s402Version}". This library supports version "1".`);
+	const missing = [];
+	if (!Array.isArray(record.accepts)) missing.push("accepts (array)");
+	if (typeof record.network !== "string") missing.push("network (string)");
+	if (typeof record.asset !== "string") missing.push("asset (string)");
+	if (typeof record.amount !== "string") missing.push("amount (string)");
+	else if (!isValidAmount(record.amount)) throw new s402Error("INVALID_PAYLOAD", `Invalid amount "${record.amount}": must be a non-negative integer string`);
+	if (typeof record.payTo !== "string") missing.push("payTo (string)");
+	if (missing.length > 0) throw new s402Error("INVALID_PAYLOAD", `Malformed payment requirements: missing ${missing.join(", ")}`);
+	if (Array.isArray(record.accepts) && record.accepts.length === 0) throw new s402Error("INVALID_PAYLOAD", "accepts array must contain at least one scheme");
+	const accepts = record.accepts;
+	for (const scheme of accepts) if (typeof scheme !== "string") throw new s402Error("INVALID_PAYLOAD", `Invalid entry in accepts array: expected string, got ${typeof scheme}`);
+	if (record.protocolFeeBps !== void 0) {
+		if (typeof record.protocolFeeBps !== "number" || !Number.isFinite(record.protocolFeeBps) || record.protocolFeeBps < 0 || record.protocolFeeBps > 1e4) throw new s402Error("INVALID_PAYLOAD", `protocolFeeBps must be a finite number between 0 and 10000, got ${record.protocolFeeBps}`);
+	}
+	if (record.expiresAt !== void 0) {
+		if (typeof record.expiresAt !== "number" || !Number.isFinite(record.expiresAt)) throw new s402Error("INVALID_PAYLOAD", `expiresAt must be a finite number (Unix timestamp ms), got ${typeof record.expiresAt}`);
+	}
+	validateSubObjects(record);
+}
+/** Validate that a decoded payment payload has the required shape. */
+function validatePayloadShape(obj) {
+	if (obj == null || typeof obj !== "object") throw new s402Error("INVALID_PAYLOAD", "Payment payload is not an object");
+	const record = obj;
+	if (record.s402Version !== void 0 && record.s402Version !== "1") throw new s402Error("INVALID_PAYLOAD", `Unsupported s402 version "${record.s402Version}" in payment payload. This library supports version "1".`);
+	const missing = [];
+	if (typeof record.scheme !== "string") missing.push("scheme");
+	else if (!VALID_SCHEMES.has(record.scheme)) throw new s402Error("INVALID_PAYLOAD", `Unknown payment scheme "${record.scheme}". Valid: ${[...VALID_SCHEMES].join(", ")}`);
+	if (record.payload == null || typeof record.payload !== "object") missing.push("payload");
+	if (missing.length > 0) throw new s402Error("INVALID_PAYLOAD", `Malformed payment payload: missing ${missing.join(", ")}`);
+	const inner = record.payload;
+	if (typeof inner.transaction !== "string") throw new s402Error("INVALID_PAYLOAD", `payload.transaction must be a string, got ${typeof inner.transaction}`);
+	if (typeof inner.signature !== "string") throw new s402Error("INVALID_PAYLOAD", `payload.signature must be a string, got ${typeof inner.signature}`);
+	if (record.scheme === "unlock" && typeof inner.encryptionId !== "string") throw new s402Error("INVALID_PAYLOAD", `unlock payload requires encryptionId (string), got ${typeof inner.encryptionId}`);
+	if (record.scheme === "prepaid" && typeof inner.ratePerCall !== "string") throw new s402Error("INVALID_PAYLOAD", `prepaid payload requires ratePerCall (string), got ${typeof inner.ratePerCall}`);
+}
+/** Validate that a decoded settle response has the required shape. */
+function validateSettleShape(obj) {
+	if (obj == null || typeof obj !== "object") throw new s402Error("INVALID_PAYLOAD", "Settle response is not an object");
+	if (typeof obj.success !== "boolean") throw new s402Error("INVALID_PAYLOAD", "Malformed settle response: missing or invalid \"success\" (boolean)");
+}
+/**
+* Detect whether a 402 response uses s402 or x402 protocol.
+*
+* Check: decode the `payment-required` header and look for `s402Version`.
+* If present → s402. If absent → x402 (or raw 402).
+*/
+function detectProtocol(headers) {
+	const paymentRequired = headers.get(S402_HEADERS.PAYMENT_REQUIRED);
+	if (!paymentRequired) return "unknown";
+	try {
+		const decoded = JSON.parse(fromBase64(paymentRequired));
+		if (decoded != null && typeof decoded === "object" && "s402Version" in decoded) return "s402";
+		if (decoded != null && typeof decoded === "object" && "x402Version" in decoded) return "x402";
+		return "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+/**
+* Extract s402 payment requirements from a 402 Response.
+* Returns null if the header is missing, malformed, or not s402 format.
+* For x402 responses, decode the header manually and use normalizeRequirements().
+*/
+function extractRequirementsFromResponse(response) {
+	const header = response.headers.get(S402_HEADERS.PAYMENT_REQUIRED);
+	if (!header) return null;
+	try {
+		return decodePaymentRequired(header);
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+export { decodePaymentPayload, decodePaymentRequired, decodeSettleResponse, detectProtocol, encodePaymentPayload, encodePaymentRequired, encodeSettleResponse, extractRequirementsFromResponse, isValidAmount, pickRequirementsFields, validateEscrowShape, validateMandateShape, validatePrepaidShape, validateRequirementsShape, validateStreamShape, validateSubObjects, validateUnlockShape };