@armory-sh/middleware 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sawyer Cutler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @armory-sh/middleware
+
+Payment verification middleware for Express, Hono, Bun, Elysia.
+
+## Install
+
+```bash
+bun add @armory-sh/middleware
+```
+
+## Use
+
+```typescript
+// Express
+import { paymentMiddleware } from '@armory-sh/middleware'
+
+app.use(paymentMiddleware({
+  requirements: {
+    to: '0x...',
+    amount: 1000000n,
+    expiry: Date.now() + 3600,
+    chainId: 'eip155:8453',
+    assetId: 'eip155:8453/erc20:0x...'
+  },
+  facilitatorUrl: 'https://facilitator.example.com'
+}))
+```
+
+---
+
+MIT License | Sawyer Cutler 2026 | Provided "AS IS" without warranty

package/dist/index.d.ts

@@ -0,0 +1,163 @@
+import { Address, CAIP2ChainId, CAIPAssetId, PaymentRequirements, SettlementResponse, PaymentPayload, ResolvedPaymentConfig, AcceptPaymentOptions, NetworkId, TokenId, ValidationError } from '@armory-sh/base';
+export { AcceptPaymentOptions, NetworkId, FacilitatorConfig as SimpleFacilitatorConfig, TokenId } from '@armory-sh/base';
+import { VerifyPaymentOptions } from '@armory-sh/facilitator';
+
+interface FacilitatorConfig {
+    url: string;
+    createHeaders?: () => Record<string, string>;
+}
+type SettlementMode = "verify" | "settle" | "async";
+type PayToAddress = Address | CAIP2ChainId | CAIPAssetId;
+interface MiddlewareConfig {
+    payTo: PayToAddress;
+    network: string | number;
+    amount: string;
+    facilitator?: FacilitatorConfig;
+    settlementMode?: SettlementMode;
+}
+interface HttpRequest {
+    headers: Record<string, string | string[] | undefined>;
+    body?: unknown;
+    method?: string;
+    url?: string;
+}
+interface HttpResponse {
+    status: number;
+    headers: Record<string, string>;
+    body?: unknown;
+}
+interface FacilitatorVerifyResult {
+    success: boolean;
+    payerAddress?: string;
+    balance?: string;
+    requiredAmount?: string;
+    error?: string;
+}
+interface FacilitatorSettleResult {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}
+
+declare const createPaymentRequirements: (config: MiddlewareConfig, version?: 1 | 2) => PaymentRequirements;
+declare const verifyWithFacilitator: (request: HttpRequest, facilitator: FacilitatorConfig) => Promise<FacilitatorVerifyResult>;
+declare const settleWithFacilitator: (request: HttpRequest, facilitator: FacilitatorConfig) => Promise<FacilitatorSettleResult>;
+declare const createPaymentRequiredHeaders: (requirements: PaymentRequirements, version: 1 | 2) => Record<string, string>;
+declare const createSettlementHeaders: (response: SettlementResponse, version: 1 | 2) => Record<string, string>;
+
+type PaymentVersion = 1 | 2;
+interface PaymentVerificationResult {
+    success: boolean;
+    payload?: PaymentPayload;
+    version?: PaymentVersion;
+    payerAddress?: string;
+    error?: string;
+}
+interface PaymentHeaders {
+    payment: string;
+    required: string;
+    response: string;
+}
+declare const getHeadersForVersion: (version: PaymentVersion) => PaymentHeaders;
+declare const getRequirementsVersion: (requirements: PaymentRequirements) => PaymentVersion;
+declare const encodeRequirements: (requirements: PaymentRequirements) => string;
+declare const decodePayload: (headerValue: string) => {
+    payload: PaymentPayload;
+    version: PaymentVersion;
+};
+declare const verifyPaymentWithRetry: (payload: PaymentPayload, requirements: PaymentRequirements, facilitatorUrl?: string, verifyOptions?: VerifyPaymentOptions) => Promise<PaymentVerificationResult>;
+declare const extractPayerAddress: (payload: PaymentPayload) => string;
+declare const createResponseHeaders: (payerAddress: string, version: PaymentVersion) => Record<string, string>;
+
+/**
+ * Simple one-line middleware API for Armory merchants
+ * Focus on DX/UX - "everything just magically works"
+ */
+
+/**
+ * Simple configuration for acceptPaymentsViaArmory middleware
+ */
+interface SimpleMiddlewareConfig {
+    /** Address to receive payments */
+    payTo: Address;
+    /** Amount to charge (default: "1.0") */
+    amount?: string;
+    /** Payment acceptance options */
+    accept?: AcceptPaymentOptions;
+    /** Fallback facilitator URL (if not using accept.facilitators) */
+    facilitatorUrl?: string;
+}
+/**
+ * Resolved middleware configuration with all options validated
+ */
+interface ResolvedMiddlewareConfig {
+    /** All valid payment configurations (network/token combinations) */
+    configs: ResolvedPaymentConfig[];
+    /** Protocol version */
+    version: 1 | 2 | "auto";
+    /** Facilitator configs */
+    facilitators: FacilitatorConfig[];
+}
+/**
+ * Resolve simple middleware config to full config
+ */
+declare const resolveMiddlewareConfig: (config: SimpleMiddlewareConfig) => ResolvedMiddlewareConfig | ValidationError;
+/**
+ * Get payment requirements for a specific network/token combination
+ */
+declare const getRequirements: (config: ResolvedMiddlewareConfig, network: NetworkId, token: TokenId) => PaymentRequirements | ValidationError;
+/**
+ * Get the primary/default middleware config for legacy middlewares
+ */
+declare const getPrimaryConfig: (resolved: ResolvedMiddlewareConfig) => MiddlewareConfig;
+/**
+ * Get all supported networks from config
+ */
+declare const getSupportedNetworks: (config: ResolvedMiddlewareConfig) => string[];
+/**
+ * Get all supported tokens from config
+ */
+declare const getSupportedTokens: (config: ResolvedMiddlewareConfig) => string[];
+/**
+ * Check if a network/token combination is supported
+ */
+declare const isSupported: (config: ResolvedMiddlewareConfig, network: NetworkId, token: TokenId) => boolean;
+
+type BunMiddleware = (request: Request) => Promise<Response | null>;
+interface BunMiddlewareConfig extends MiddlewareConfig {
+    defaultVersion?: 1 | 2;
+    waitForSettlement?: boolean;
+}
+declare const createBunMiddleware: (config: BunMiddlewareConfig) => BunMiddleware;
+/**
+ * One-line middleware setup for accepting Armory payments
+ *
+ * @example
+ * ```ts
+ * // Simple usage - default USDC on Base
+ * app.use(acceptPaymentsViaArmory({
+ *   payTo: "0xMerchantAddress...",
+ *   amount: "1.0"
+ * }));
+ *
+ * // Multi-network, multi-token support
+ * app.use(acceptPaymentsViaArmory({
+ *   payTo: "0xMerchantAddress...",
+ *   amount: "1.0",
+ *   accept: {
+ *     networks: ["base", "skale-base", "ethereum"],
+ *     tokens: ["usdc", "eurc"],
+ *     facilitators: [
+ *       { url: "https://facilitator1.com" },
+ *       { url: "https://facilitator2.com" }
+ *     ]
+ *   }
+ * }));
+ * ```
+ */
+declare const acceptPaymentsViaArmory: (config: SimpleMiddlewareConfig & {
+    defaultVersion?: 1 | 2;
+    waitForSettlement?: boolean;
+}) => BunMiddleware;
+
+export { type BunMiddleware, type BunMiddlewareConfig, type FacilitatorConfig, type FacilitatorSettleResult, type FacilitatorVerifyResult, type HttpRequest, type HttpResponse, type MiddlewareConfig, type PayToAddress, type PaymentVerificationResult, type PaymentVersion, type ResolvedMiddlewareConfig, type SettlementMode, type SimpleMiddlewareConfig, acceptPaymentsViaArmory, createBunMiddleware, createPaymentRequiredHeaders, createPaymentRequirements, createResponseHeaders, createSettlementHeaders, decodePayload, encodeRequirements, extractPayerAddress, getHeadersForVersion, getPrimaryConfig, getRequirements, getRequirementsVersion, getSupportedNetworks, getSupportedTokens, isSupported, resolveMiddlewareConfig, settleWithFacilitator, verifyPaymentWithRetry, verifyWithFacilitator };

package/dist/index.js

@@ -0,0 +1,403 @@
+// src/core.ts
+import { getNetworkConfig, getNetworkByChainId } from "@armory-sh/base";
+var getNetworkName = (network) => {
+  if (typeof network === "string") return network;
+  const net = getNetworkByChainId(network);
+  if (!net) throw new Error(`No network found for chainId: ${network}`);
+  return net.name.toLowerCase().replace(" mainnet", "").replace(" sepolia", "-sepolia");
+};
+var createV1Requirements = (config, expiry) => {
+  const networkName = getNetworkName(config.network);
+  const network = getNetworkConfig(networkName);
+  if (!network) throw new Error(`Unsupported network: ${networkName}`);
+  return {
+    amount: config.amount,
+    network: networkName,
+    contractAddress: network.usdcAddress,
+    payTo: config.payTo,
+    expiry
+  };
+};
+var createV2Requirements = (config, expiry) => {
+  const networkName = getNetworkName(config.network);
+  const network = getNetworkConfig(networkName);
+  if (!network) throw new Error(`Unsupported network: ${networkName}`);
+  return {
+    amount: config.amount,
+    to: config.payTo,
+    chainId: network.caip2Id,
+    assetId: network.caipAssetId,
+    nonce: `${Date.now()}-${crypto.randomUUID()}`,
+    expiry
+  };
+};
+var createPaymentRequirements = (config, version = 1) => {
+  const expiry = Math.floor(Date.now() / 1e3) + 3600;
+  return version === 1 ? createV1Requirements(config, expiry) : createV2Requirements(config, expiry);
+};
+var findHeaderValue = (headers, name) => {
+  const value = headers[name];
+  if (typeof value === "string") return value;
+  if (Array.isArray(value) && value.length > 0) return value[0];
+  const lowerName = name.toLowerCase();
+  for (const [key, val] of Object.entries(headers)) {
+    if (key.toLowerCase() === lowerName) {
+      if (typeof val === "string") return val;
+      if (Array.isArray(val) && val.length > 0) return val[0];
+    }
+  }
+  return void 0;
+};
+var parseHeader = (header) => {
+  try {
+    if (header.startsWith("{")) return JSON.parse(header);
+    return JSON.parse(atob(header));
+  } catch {
+    return null;
+  }
+};
+var extractPaymentPayload = (request) => {
+  const v1Header = findHeaderValue(request.headers, "X-PAYMENT");
+  if (v1Header) return parseHeader(v1Header);
+  const v2Header = findHeaderValue(request.headers, "PAYMENT-SIGNATURE");
+  if (v2Header) return parseHeader(v2Header);
+  return null;
+};
+var postFacilitator = async (url, headers, body) => {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...headers },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(error || `Request failed: ${response.status}`);
+  }
+  return response.json();
+};
+var verifyWithFacilitator = async (request, facilitator) => {
+  const payload = extractPaymentPayload(request);
+  if (!payload) {
+    return { success: false, error: "No payment payload found in request headers" };
+  }
+  try {
+    const url = new URL("/verify", facilitator.url);
+    const headers = facilitator.createHeaders?.() ?? {};
+    const data = await postFacilitator(url.toString(), headers, { payload, headers: request.headers });
+    return {
+      success: true,
+      payerAddress: data.payerAddress,
+      balance: data.balance,
+      requiredAmount: data.requiredAmount
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown verification error"
+    };
+  }
+};
+var settleWithFacilitator = async (request, facilitator) => {
+  const payload = extractPaymentPayload(request);
+  if (!payload) {
+    return { success: false, error: "No payment payload found in request headers" };
+  }
+  try {
+    const url = new URL("/settle", facilitator.url);
+    const headers = facilitator.createHeaders?.() ?? {};
+    const data = await postFacilitator(url.toString(), headers, { payload, headers: request.headers });
+    return {
+      success: true,
+      txHash: data.txHash
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown settlement error"
+    };
+  }
+};
+var encode = (data) => btoa(JSON.stringify(data));
+var createPaymentRequiredHeaders = (requirements, version) => {
+  if (version === 1) {
+    return { "X-PAYMENT-REQUIRED": encode(requirements) };
+  }
+  return { "PAYMENT-REQUIRED": encode(requirements) };
+};
+var createSettlementHeaders = (response, version) => {
+  if (version === 1) {
+    return { "X-PAYMENT-RESPONSE": encode(response) };
+  }
+  return { "PAYMENT-RESPONSE": encode(response) };
+};
+
+// src/payment-utils.ts
+import { decodePayment, detectPaymentVersion, isPaymentV1 } from "@armory-sh/base";
+import { verifyPayment } from "@armory-sh/facilitator";
+var getHeadersForVersion = (version) => version === 1 ? { payment: "X-PAYMENT", required: "X-PAYMENT-REQUIRED", response: "X-PAYMENT-RESPONSE" } : { payment: "PAYMENT-SIGNATURE", required: "PAYMENT-REQUIRED", response: "PAYMENT-RESPONSE" };
+var getRequirementsVersion = (requirements) => "contractAddress" in requirements && "network" in requirements ? 1 : 2;
+var encodeRequirements = (requirements) => JSON.stringify(requirements);
+var decodePayload = (headerValue) => {
+  const headers = new Headers();
+  headers.set(headerValue.startsWith("{") ? "PAYMENT-SIGNATURE" : "X-PAYMENT", headerValue);
+  const payload = decodePayment(headers);
+  const version = detectPaymentVersion(headers) ?? 2;
+  return { payload, version };
+};
+var verifyWithFacilitator2 = async (facilitatorUrl, payload, requirements, verifyOptions) => {
+  try {
+    const response = await fetch(`${facilitatorUrl}/verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ payload, requirements, options: verifyOptions })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      return { success: false, error: JSON.stringify(error) };
+    }
+    const result = await response.json();
+    if (!result.success) {
+      return { success: false, error: result.error ?? "Verification failed" };
+    }
+    return { success: true, payerAddress: result.payerAddress ?? "" };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown facilitator error"
+    };
+  }
+};
+var verifyLocally = async (payload, requirements, verifyOptions) => {
+  const result = await verifyPayment(payload, requirements, verifyOptions);
+  if (!result.success) {
+    return {
+      success: false,
+      error: JSON.stringify({
+        error: "Payment verification failed",
+        reason: result.error.name,
+        message: result.error.message
+      })
+    };
+  }
+  return { success: true, payerAddress: result.payerAddress };
+};
+var verifyPaymentWithRetry = async (payload, requirements, facilitatorUrl, verifyOptions) => facilitatorUrl ? verifyWithFacilitator2(facilitatorUrl, payload, requirements, verifyOptions) : verifyLocally(payload, requirements, verifyOptions);
+var extractPayerAddress = (payload) => isPaymentV1(payload) ? payload.from : payload.from;
+var createResponseHeaders = (payerAddress, version) => ({
+  [getHeadersForVersion(version).response]: JSON.stringify({
+    status: "verified",
+    payerAddress,
+    version
+  })
+});
+
+// src/bun.ts
+import { decodePayment as decodePayment2, isV1, isV2 } from "@armory-sh/base";
+
+// src/simple.ts
+import {
+  resolveNetwork,
+  resolveToken,
+  validateAcceptConfig,
+  isValidationError
+} from "@armory-sh/base";
+var resolveMiddlewareConfig = (config) => {
+  const { payTo, amount = "1.0", accept = {}, facilitatorUrl } = config;
+  const acceptOptions = facilitatorUrl ? {
+    ...accept,
+    facilitators: accept.facilitators ? [...Array.isArray(accept.facilitators) ? accept.facilitators : [accept.facilitators], { url: facilitatorUrl }] : { url: facilitatorUrl }
+  } : accept;
+  const result = validateAcceptConfig(acceptOptions, payTo, amount);
+  if (!result.success) {
+    return result.error;
+  }
+  const facilitatorConfigs = result.config[0]?.facilitators.map((f) => ({
+    url: f.url,
+    createHeaders: f.input.headers
+  })) ?? [];
+  return {
+    configs: result.config,
+    version: acceptOptions.version ?? "auto",
+    facilitators: facilitatorConfigs
+  };
+};
+var getRequirements = (config, network, token) => {
+  const resolvedNetwork = resolveNetwork(network);
+  if (isValidationError(resolvedNetwork)) {
+    return resolvedNetwork;
+  }
+  const resolvedToken = resolveToken(token, resolvedNetwork);
+  if (isValidationError(resolvedToken)) {
+    return resolvedToken;
+  }
+  const matchingConfig = config.configs.find(
+    (c) => c.network.config.chainId === resolvedNetwork.config.chainId && c.token.config.contractAddress.toLowerCase() === resolvedToken.config.contractAddress.toLowerCase()
+  );
+  if (!matchingConfig) {
+    return {
+      code: "TOKEN_NOT_ON_NETWORK",
+      message: `No configuration found for network "${network}" with token "${token}"`
+    };
+  }
+  const version = config.version === "auto" ? 2 : config.version;
+  return createPaymentRequirements(
+    {
+      payTo: matchingConfig.payTo,
+      network: matchingConfig.network.config.name,
+      amount: matchingConfig.amount,
+      facilitator: config.facilitators[0]
+    },
+    version
+  );
+};
+var getPrimaryConfig = (resolved) => {
+  const primary = resolved.configs[0];
+  if (!primary) {
+    throw new Error("No valid payment configurations found");
+  }
+  return {
+    payTo: primary.payTo,
+    network: primary.network.config.name,
+    amount: primary.amount,
+    facilitator: resolved.facilitators[0],
+    settlementMode: "verify"
+  };
+};
+var getSupportedNetworks = (config) => {
+  const networks = new Set(config.configs.map((c) => c.network.config.name));
+  return Array.from(networks);
+};
+var getSupportedTokens = (config) => {
+  const tokens = new Set(config.configs.map((c) => c.token.config.symbol));
+  return Array.from(tokens);
+};
+var isSupported = (config, network, token) => {
+  const resolvedNetwork = resolveNetwork(network);
+  if (isValidationError(resolvedNetwork)) {
+    return false;
+  }
+  const resolvedToken = resolveToken(token, resolvedNetwork);
+  if (isValidationError(resolvedToken)) {
+    return false;
+  }
+  return config.configs.some(
+    (c) => c.network.config.chainId === resolvedNetwork.config.chainId && c.token.config.contractAddress.toLowerCase() === resolvedToken.config.contractAddress.toLowerCase()
+  );
+};
+
+// src/bun.ts
+var parsePaymentHeader = async (request) => {
+  const v1 = request.headers.get("X-PAYMENT");
+  if (v1) {
+    const headers = new Headers({ "X-PAYMENT": v1 });
+    const payload = decodePayment2(headers);
+    return isV1(payload) ? { payload, version: 1, payerAddress: payload.from } : null;
+  }
+  const v2 = request.headers.get("PAYMENT-SIGNATURE");
+  if (v2) {
+    const headers = new Headers({ "PAYMENT-SIGNATURE": v2 });
+    const payload = decodePayment2(headers);
+    return isV2(payload) ? { payload, version: 2, payerAddress: payload.from } : null;
+  }
+  return null;
+};
+var toHttpRequest = (request) => {
+  const headers = {};
+  request.headers.forEach((v, k) => {
+    headers[k] = v;
+  });
+  return { headers, method: request.method, url: request.url };
+};
+var errorResponse = (error, status, headers) => new Response(JSON.stringify({ error }), {
+  status,
+  headers: { "Content-Type": "application/json", ...headers }
+});
+var createSettlementResponse = (success, txHash) => ({
+  status: success ? "success" : "failed",
+  txHash,
+  txId: txHash,
+  timestamp: Math.floor(Date.now() / 1e3)
+});
+var successResponse = (payerAddress, version, settlement) => {
+  const isSuccess = settlement ? "success" in settlement ? settlement.success : settlement.status === "success" : void 0;
+  const txHash = settlement?.txHash;
+  return new Response(
+    JSON.stringify({
+      verified: true,
+      payerAddress,
+      version,
+      settlement: settlement ? { success: isSuccess, txHash } : void 0
+    }),
+    {
+      status: 200,
+      headers: {
+        "Content-Type": "application/json",
+        "X-Payment-Verified": "true",
+        "X-Payer-Address": payerAddress,
+        ...settlement ? createSettlementHeaders(settlement, version) : {}
+      }
+    }
+  );
+};
+var createBunMiddleware = (config) => {
+  const { facilitator, settlementMode = "verify", defaultVersion = 2, waitForSettlement = false } = config;
+  const requirementsV1 = createPaymentRequirements(config, 1);
+  const requirementsV2 = createPaymentRequirements(config, 2);
+  return async (request) => {
+    const paymentResult = await parsePaymentHeader(request);
+    if (!paymentResult) {
+      const requirements = defaultVersion === 1 ? requirementsV1 : requirementsV2;
+      return errorResponse("Payment required", 402, createPaymentRequiredHeaders(requirements, defaultVersion));
+    }
+    const { version, payerAddress } = paymentResult;
+    if (facilitator) {
+      const verifyResult = await verifyWithFacilitator(toHttpRequest(request), facilitator);
+      if (!verifyResult.success) {
+        const requirements = version === 1 ? requirementsV1 : requirementsV2;
+        return errorResponse(`Payment verification failed: ${verifyResult.error}`, 402, createPaymentRequiredHeaders(requirements, version));
+      }
+    }
+    if (settlementMode === "settle" && facilitator) {
+      const settle = async () => {
+        const result = await settleWithFacilitator(toHttpRequest(request), facilitator);
+        return result.success ? successResponse(payerAddress, version, createSettlementResponse(true, result.txHash)) : errorResponse(result.error ?? "Settlement failed", 400);
+      };
+      return waitForSettlement ? await settle() : (settle().catch(console.error), successResponse(payerAddress, version));
+    }
+    return successResponse(payerAddress, version);
+  };
+};
+var acceptPaymentsViaArmory = (config) => {
+  const resolved = resolveMiddlewareConfig(config);
+  if ("code" in resolved) {
+    throw new Error(`Invalid payment configuration: ${resolved.message}`);
+  }
+  const primaryConfig = getPrimaryConfig(resolved);
+  return createBunMiddleware({
+    ...primaryConfig,
+    defaultVersion: config.defaultVersion ?? 2,
+    waitForSettlement: config.waitForSettlement ?? false
+  });
+};
+export {
+  acceptPaymentsViaArmory,
+  createBunMiddleware,
+  createPaymentRequiredHeaders,
+  createPaymentRequirements,
+  createResponseHeaders,
+  createSettlementHeaders,
+  decodePayload,
+  encodeRequirements,
+  extractPayerAddress,
+  getHeadersForVersion,
+  getPrimaryConfig,
+  getRequirements,
+  getRequirementsVersion,
+  getSupportedNetworks,
+  getSupportedTokens,
+  isSupported,
+  resolveMiddlewareConfig,
+  settleWithFacilitator,
+  verifyPaymentWithRetry,
+  verifyWithFacilitator
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@armory-sh/middleware",
+  "version": "0.2.0",
+  "license": "MIT",
+  "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./dist/*": "./dist/*.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thegreataxios/armory.git",
+    "directory": "packages/middleware"
+  },
+  "dependencies": {
+    "@armory-sh/base": "workspace:*",
+    "@armory-sh/facilitator": "workspace:*"
+  },
+  "devDependencies": {
+    "typescript": "5.9.3",
+    "bun-types": "latest"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "bun test"
+  }
+}