@armory-sh/middleware-bun 0.3.26 → 0.3.28

package/dist/{chunk-WLKV5FDR.js → chunk-BJBLQMMR.js}

@@ -8,7 +8,9 @@ var toSlug = (network) => {
     return normalizeNetworkName(net.name);
   }
   if (network.startsWith("eip155:")) {
-    const chainId = parseInt(network.split(":")[1], 10);
+    const chainPart = network.split(":")[1];
+    if (!chainPart) throw new Error(`Invalid network format: ${network}`);
+    const chainId = parseInt(chainPart, 10);
     const net = getNetworkByChainId(chainId);
     if (!net) throw new Error(`No network found for chainId: ${chainId}`);
     return normalizeNetworkName(net.name);
@@ -38,12 +40,16 @@ var createV2Requirements = (config, expiry) => {
   const network = getNetworkConfig(networkName);
   if (!network) throw new Error(`Unsupported network: ${networkName}`);
   return {
+    scheme: "exact",
     amount: config.amount,
-    to: config.payTo,
-    chainId: getChainId(config.network),
-    assetId: network.caipAssetId,
-    nonce: `${Date.now()}-${crypto.randomUUID()}`,
-    expiry
+    network: getChainId(config.network),
+    asset: network.usdcAddress,
+    payTo: config.payTo,
+    maxTimeoutSeconds: Math.max(1, expiry - Math.floor(Date.now() / 1e3)),
+    extra: {
+      name: "USDC",
+      version: "2"
+    }
   };
 };
 var createPaymentRequirements = (config) => {
@@ -80,7 +86,9 @@ var parsePaymentHeader = async (request, requirements) => {
   const paymentSig = request.headers.get(PAYMENT_SIGNATURE_HEADER);
   if (paymentSig) {
     try {
-      const payload = decodePayloadHeader(paymentSig, { accepted: requirements });
+      const payload = decodePayloadHeader(paymentSig, {
+        accepted: requirements
+      });
       return { payload, payerAddress: extractPayerAddress(payload) };
     } catch {
     }
@@ -133,32 +141,58 @@ var createRouteAwareBunMiddleware = (config, handler) => {
   const { routes: resolvedRoutes, error: configError } = resolveRouteConfig(config);
   const middleware = async (request) => {
     if (configError) {
-      return errorResponse(`Payment middleware configuration error: ${configError.message}`, 500);
+      return errorResponse(
+        `Payment middleware configuration error: ${configError.message}`,
+        500
+      );
     }
     const path = new URL(request.url).pathname;
-    const matchedRoute = resolvedRoutes.find((r) => matchRoute(r.pattern, path));
+    const matchedRoute = resolvedRoutes.find(
+      (r) => matchRoute(r.pattern, path)
+    );
     if (!matchedRoute) {
       return null;
     }
     const routeConfig = matchedRoute.config;
-    const { facilitator, settlementMode = "settle", waitForSettlement = false } = routeConfig;
+    const {
+      facilitator,
+      settlementMode = "settle",
+      waitForSettlement = false
+    } = routeConfig;
     const requirements = createPaymentRequirements(routeConfig);
     const paymentResult = await parsePaymentHeader(request, requirements);
     if (!paymentResult) {
-      return errorResponse("Payment required", 402, createPaymentRequiredHeaders(requirements), [requirements]);
+      return errorResponse(
+        "Payment required",
+        402,
+        createPaymentRequiredHeaders(requirements),
+        [requirements]
+      );
     }
     const { payerAddress, payload } = paymentResult;
     if (facilitator) {
-      const verifyResult = await verifyPayment(payload, requirements, { url: facilitator.url });
+      const verifyResult = await verifyPayment(payload, requirements, {
+        url: facilitator.url
+      });
       if (!verifyResult.isValid) {
-        return errorResponse(`Payment verification failed: ${verifyResult.invalidReason}`, 402, createPaymentRequiredHeaders(requirements), [requirements]);
+        return errorResponse(
+          `Payment verification failed: ${verifyResult.invalidReason}`,
+          402,
+          createPaymentRequiredHeaders(requirements),
+          [requirements]
+        );
       }
     }
     if (!handler) {
       if (settlementMode === "settle" && facilitator) {
         const settle = async () => {
-          const result = await settlePayment(payload, requirements, { url: facilitator.url });
-          return result.success ? successResponse(payerAddress, createSettlementResponse(true, result.transaction)) : errorResponse(result.errorReason ?? "Settlement failed", 400);
+          const result = await settlePayment(payload, requirements, {
+            url: facilitator.url
+          });
+          return result.success ? successResponse(
+            payerAddress,
+            createSettlementResponse(true, result.transaction)
+          ) : errorResponse(result.errorReason ?? "Settlement failed", 400);
         };
         if (waitForSettlement) {
           return await settle();
@@ -172,9 +206,14 @@ var createRouteAwareBunMiddleware = (config, handler) => {
     if (response.status >= 400 || settlementMode !== "settle" || !facilitator) {
       return response;
     }
-    const settleResult = await settlePayment(payload, requirements, { url: facilitator.url });
+    const settleResult = await settlePayment(payload, requirements, {
+      url: facilitator.url
+    });
     if (!settleResult.success) {
-      return errorResponse(settleResult.errorReason ?? "Settlement failed", 502);
+      return errorResponse(
+        settleResult.errorReason ?? "Settlement failed",
+        502
+      );
     }
     const settlement = createSettlementResponse(true, settleResult.transaction);
     return appendSettlementHeaders(response, settlement);

package/dist/index.d.ts

@@ -1,2 +1,10 @@
-export { B as BunHandler, a as BunMiddleware, b as BunMiddlewareConfig, RouteAwareBunMiddlewareConfig, c as createBunMiddleware, createRouteAwareBunMiddleware } from './routes.js';
+import { M as MiddlewareConfig, B as BunHandler, a as BunMiddleware } from './routes-C69V5KAQ.js';
+export { P as PaymentConfig, R as ResolvedRequirementsConfig, b as RouteAwareBunMiddlewareConfig, c as createPaymentRequirements, d as createRouteAwareBunMiddleware, p as paymentMiddleware, r as resolveFacilitatorUrlFromRequirement } from './routes-C69V5KAQ.js';
 import '@armory-sh/base';
+
+interface BunMiddlewareConfig extends MiddlewareConfig {
+    waitForSettlement?: boolean;
+}
+declare const createBunMiddleware: (config: BunMiddlewareConfig, handler?: BunHandler) => BunMiddleware | ((request: Request) => Promise<Response>);
+
+export { BunHandler, BunMiddleware, type BunMiddlewareConfig, createBunMiddleware };

package/dist/index.js

@@ -1,19 +1,255 @@
-import { createPaymentRequirements } from './chunk-WLKV5FDR.js';
-export { createRouteAwareBunMiddleware } from './chunk-WLKV5FDR.js';
-import { createPaymentRequiredHeaders, verifyPayment, settlePayment, PAYMENT_SIGNATURE_HEADER, decodePayloadHeader, extractPayerAddress, createSettlementHeaders } from '@armory-sh/base';
+import { createPaymentRequirements as createPaymentRequirements$1 } from './chunk-BJBLQMMR.js';
+export { createRouteAwareBunMiddleware } from './chunk-BJBLQMMR.js';
+import { resolveNetwork, isValidationError, resolveToken, createPaymentRequirements, PAYMENT_SIGNATURE_HEADER, decodePayloadHeader, findRequirementByAccepted, verifyPayment, extractPayerAddress, settlePayment, createPaymentRequiredHeaders, TOKENS, registerToken, createSettlementHeaders, getSupported } from '@armory-sh/base';
 
+var extensionCapabilityCache = /* @__PURE__ */ new Map();
+var EXTENSION_CAPABILITY_TTL_MS = 5 * 60 * 1e3;
+function ensureTokensRegistered() {
+  for (const token of Object.values(TOKENS)) {
+    try {
+      registerToken(token);
+    } catch {
+    }
+  }
+}
+function resolveFacilitatorUrlFromRequirement(config, requirement) {
+  const chainId = parseInt(requirement.network.split(":")[1] || "0", 10);
+  const assetAddress = requirement.asset.toLowerCase();
+  if (config.facilitatorUrlByToken) {
+    for (const [chainKey, tokenMap] of Object.entries(
+      config.facilitatorUrlByToken
+    )) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (isValidationError(resolvedChain) || resolvedChain.config.chainId !== chainId) {
+        continue;
+      }
+      for (const [tokenKey, url] of Object.entries(tokenMap)) {
+        const resolvedToken = resolveToken(tokenKey, resolvedChain);
+        if (!isValidationError(resolvedToken) && resolvedToken.config.contractAddress.toLowerCase() === assetAddress) {
+          return url;
+        }
+      }
+    }
+  }
+  if (config.facilitatorUrlByChain) {
+    for (const [chainKey, url] of Object.entries(
+      config.facilitatorUrlByChain
+    )) {
+      const resolvedChain = resolveNetwork(chainKey);
+      if (!isValidationError(resolvedChain) && resolvedChain.config.chainId === chainId) {
+        return url;
+      }
+    }
+  }
+  return config.facilitatorUrl;
+}
+function createPaymentRequirements2(config) {
+  if (config.requirements) {
+    return {
+      requirements: Array.isArray(config.requirements) ? config.requirements : [config.requirements]
+    };
+  }
+  if (!config.payTo) {
+    return {
+      requirements: [],
+      error: {
+        code: "VALIDATION_FAILED",
+        message: "Missing payment configuration: provide payTo or explicit requirements"
+      }
+    };
+  }
+  ensureTokensRegistered();
+  return createPaymentRequirements(config);
+}
+async function resolvePaymentRequiredExtensions(config, requirements) {
+  if (!config.extensions) {
+    return {};
+  }
+  let filtered = { ...config.extensions };
+  for (const requirement of requirements) {
+    const facilitatorUrl = resolveFacilitatorUrlFromRequirement(config, requirement);
+    if (!facilitatorUrl) {
+      continue;
+    }
+    const cacheKey = `${facilitatorUrl}|${requirement.network.toLowerCase()}`;
+    const now = Date.now();
+    let keys = extensionCapabilityCache.get(cacheKey);
+    if (!keys || keys.expiresAt <= now) {
+      try {
+        const supported = await getSupported({ url: facilitatorUrl });
+        const nextKeys = /* @__PURE__ */ new Set();
+        for (const kind of supported.kinds) {
+          if (kind.network.toLowerCase() !== requirement.network.toLowerCase()) {
+            continue;
+          }
+          if (kind.extra && typeof kind.extra === "object") {
+            for (const key of Object.keys(kind.extra)) {
+              nextKeys.add(key);
+            }
+          }
+        }
+        keys = { expiresAt: now + EXTENSION_CAPABILITY_TTL_MS, keys: nextKeys };
+      } catch {
+        keys = { expiresAt: now + EXTENSION_CAPABILITY_TTL_MS, keys: /* @__PURE__ */ new Set() };
+      }
+      extensionCapabilityCache.set(cacheKey, keys);
+    }
+    filtered = Object.fromEntries(
+      Object.entries(filtered).filter(([key]) => keys.keys.has(key))
+    );
+    if (Object.keys(filtered).length === 0) {
+      return {};
+    }
+  }
+  return filtered;
+}
+var errorResponse = (error, status, headers, accepts) => new Response(JSON.stringify({ error, accepts }), {
+  status,
+  headers: { "Content-Type": "application/json", ...headers }
+});
+var successResponse = (payerAddress, settlement) => {
+  return new Response(
+    JSON.stringify({
+      verified: true,
+      payerAddress,
+      settlement: void 0
+    }),
+    {
+      status: 200,
+      headers: {
+        "Content-Type": "application/json",
+        "X-Payment-Verified": "true",
+        "X-Payer-Address": payerAddress,
+        ...{}
+      }
+    }
+  );
+};
+var appendSettlementHeaders = (response, settlement) => {
+  const headers = new Headers(response.headers);
+  const settlementHeaders = createSettlementHeaders(settlement);
+  for (const [key, value] of Object.entries(settlementHeaders)) {
+    headers.set(key, value);
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+};
+var paymentMiddleware = (config, handler) => {
+  const { requirements, error } = createPaymentRequirements2(config);
+  const resolvePaymentRequiredHeaders = async () => createPaymentRequiredHeaders(requirements, {
+    extensions: await resolvePaymentRequiredExtensions(
+      config,
+      requirements
+    )
+  });
+  return async (request) => {
+    if (error) {
+      return errorResponse(
+        "Payment middleware configuration error",
+        500,
+        void 0,
+        [error.message]
+      );
+    }
+    const primaryRequirement = requirements[0];
+    if (!primaryRequirement) {
+      return errorResponse(
+        "Payment middleware configuration error: No payment requirements configured",
+        500
+      );
+    }
+    const paymentSig = request.headers.get(PAYMENT_SIGNATURE_HEADER);
+    if (!paymentSig) {
+      const requiredHeaders = await resolvePaymentRequiredHeaders();
+      return errorResponse(
+        "Payment required",
+        402,
+        requiredHeaders,
+        [requirements]
+      );
+    }
+    let payload;
+    try {
+      payload = decodePayloadHeader(paymentSig, {
+        accepted: primaryRequirement
+      });
+    } catch {
+      return errorResponse("Invalid payment payload", 400);
+    }
+    const selectedRequirement = findRequirementByAccepted(
+      requirements,
+      payload.accepted
+    );
+    if (!selectedRequirement) {
+      return errorResponse(
+        "Invalid payment payload: accepted requirement is not configured for this endpoint",
+        400
+      );
+    }
+    const facilitatorUrl = resolveFacilitatorUrlFromRequirement(
+      config,
+      selectedRequirement
+    );
+    if (!facilitatorUrl) {
+      return errorResponse(
+        "Payment middleware configuration error: Facilitator URL is required",
+        500
+      );
+    }
+    const verifyResult = await verifyPayment(
+      payload,
+      selectedRequirement,
+      { url: facilitatorUrl }
+    );
+    if (!verifyResult.isValid) {
+      const requiredHeaders = await resolvePaymentRequiredHeaders();
+      return errorResponse(
+        `Payment verification failed: ${verifyResult.invalidReason}`,
+        402,
+        requiredHeaders
+      );
+    }
+    const payerAddress = verifyResult.payer ?? extractPayerAddress(payload);
+    if (!handler) {
+      return successResponse(payerAddress);
+    }
+    const response = await handler(request);
+    if (response.status >= 400) {
+      return response;
+    }
+    const settleResult = await settlePayment(
+      payload,
+      selectedRequirement,
+      { url: facilitatorUrl }
+    );
+    if (!settleResult.success) {
+      return errorResponse(
+        settleResult.errorReason ?? "Settlement failed",
+        502
+      );
+    }
+    return appendSettlementHeaders(response, settleResult);
+  };
+};
+
+// src/index.ts
 var parsePaymentHeader = async (request, requirements) => {
   const paymentSig = request.headers.get(PAYMENT_SIGNATURE_HEADER);
   if (paymentSig) {
     try {
-      const payload = decodePayloadHeader(paymentSig, { accepted: requirements });
+      const payload = decodePayloadHeader(paymentSig, {
+        accepted: requirements
+      });
       return { payload, payerAddress: extractPayerAddress(payload) };
     } catch {
     }
   }
   return null;
 };
-var errorResponse = (error, status, headers, accepts) => new Response(JSON.stringify({ error, accepts }), {
+var errorResponse2 = (error, status, headers, accepts) => new Response(JSON.stringify({ error, accepts }), {
   status,
   headers: { "Content-Type": "application/json", ...headers }
 });
@@ -23,7 +259,7 @@ var createSettlementResponse = (success, txHash) => ({
   errorReason: void 0 ,
   network: "base"
 });
-var successResponse = (payerAddress, settlement) => {
+var successResponse2 = (payerAddress, settlement) => {
   const isSuccess = settlement?.success;
   const txHash = settlement?.transaction;
   return new Response(
@@ -43,7 +279,7 @@ var successResponse = (payerAddress, settlement) => {
     }
   );
 };
-var appendSettlementHeaders = (response, settlement) => {
+var appendSettlementHeaders2 = (response, settlement) => {
   const headers = new Headers(response.headers);
   const settlementHeaders = createSettlementHeaders(settlement);
   for (const [key, value] of Object.entries(settlementHeaders)) {
@@ -56,44 +292,72 @@ var appendSettlementHeaders = (response, settlement) => {
   });
 };
 var createBunMiddleware = (config, handler) => {
-  const { facilitator, settlementMode = "settle", waitForSettlement = false } = config;
-  const requirements = createPaymentRequirements(config);
+  const {
+    facilitator,
+    settlementMode = "settle",
+    waitForSettlement = false
+  } = config;
+  const requirements = createPaymentRequirements$1(config);
   const middleware = async (request) => {
     const paymentResult = await parsePaymentHeader(request, requirements);
     if (!paymentResult) {
-      return errorResponse("Payment required", 402, createPaymentRequiredHeaders(requirements), [requirements]);
+      return errorResponse2(
+        "Payment required",
+        402,
+        createPaymentRequiredHeaders(requirements),
+        [requirements]
+      );
     }
     const { payerAddress, payload } = paymentResult;
     if (facilitator) {
-      const verifyResult = await verifyPayment(payload, requirements, { url: facilitator.url });
+      const verifyResult = await verifyPayment(
+        payload,
+        requirements,
+        { url: facilitator.url }
+      );
       if (!verifyResult.isValid) {
-        return errorResponse(`Payment verification failed: ${verifyResult.invalidReason}`, 402, createPaymentRequiredHeaders(requirements), [requirements]);
+        return errorResponse2(
+          `Payment verification failed: ${verifyResult.invalidReason}`,
+          402,
+          createPaymentRequiredHeaders(requirements),
+          [requirements]
+        );
       }
     }
     if (!handler) {
       if (settlementMode === "settle" && facilitator) {
         const settle = async () => {
-          const result = await settlePayment(payload, requirements, { url: facilitator.url });
-          return result.success ? successResponse(payerAddress, createSettlementResponse(true, result.transaction)) : errorResponse(result.errorReason ?? "Settlement failed", 400);
+          const result = await settlePayment(payload, requirements, {
+            url: facilitator.url
+          });
+          return result.success ? successResponse2(
+            payerAddress,
+            createSettlementResponse(true, result.transaction)
+          ) : errorResponse2(result.errorReason ?? "Settlement failed", 400);
         };
         if (waitForSettlement) {
           return await settle();
         }
         settle().catch(console.error);
-        return successResponse(payerAddress);
+        return successResponse2(payerAddress);
       }
-      return successResponse(payerAddress);
+      return successResponse2(payerAddress);
     }
     const response = await handler(request);
     if (response.status >= 400 || settlementMode !== "settle" || !facilitator) {
       return response;
     }
-    const settleResult = await settlePayment(payload, requirements, { url: facilitator.url });
+    const settleResult = await settlePayment(payload, requirements, {
+      url: facilitator.url
+    });
     if (!settleResult.success) {
-      return errorResponse(settleResult.errorReason ?? "Settlement failed", 502);
+      return errorResponse2(
+        settleResult.errorReason ?? "Settlement failed",
+        502
+      );
     }
     const settlement = createSettlementResponse(true, settleResult.transaction);
-    return appendSettlementHeaders(response, settlement);
+    return appendSettlementHeaders2(response, settlement);
   };
   if (!handler) {
     return middleware;
@@ -101,10 +365,10 @@ var createBunMiddleware = (config, handler) => {
   return async (request) => {
     const result = await middleware(request);
     if (!result) {
-      return errorResponse("Payment middleware returned no response", 500);
+      return errorResponse2("Payment middleware returned no response", 500);
     }
     return result;
   };
 };
 
-export { createBunMiddleware };
+export { createBunMiddleware, createPaymentRequirements2 as createPaymentRequirements, paymentMiddleware, resolveFacilitatorUrlFromRequirement };

package/dist/routes-C69V5KAQ.d.ts

@@ -0,0 +1,49 @@
+import { PaymentRequirementsV2, PayToAddress, FacilitatorConfig, SettlementMode } from '@armory-sh/base';
+
+type NetworkId = string | number;
+type TokenId = string;
+interface PaymentConfig {
+    payTo?: string;
+    requirements?: PaymentRequirementsV2 | PaymentRequirementsV2[];
+    chains?: NetworkId[];
+    chain?: NetworkId;
+    tokens?: TokenId[];
+    token?: TokenId;
+    amount?: string;
+    maxTimeoutSeconds?: number;
+    facilitatorUrl?: string;
+    facilitatorUrlByChain?: Record<string, string>;
+    facilitatorUrlByToken?: Record<string, Record<string, string>>;
+    extensions?: Record<string, unknown>;
+}
+interface ResolvedRequirementsConfig {
+    requirements: PaymentRequirementsV2[];
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+type BunMiddleware$1 = (request: Request) => Promise<Response | null>;
+type BunHandler = (request: Request) => Promise<Response> | Response;
+declare function resolveFacilitatorUrlFromRequirement(config: PaymentConfig, requirement: PaymentRequirementsV2): string | undefined;
+declare function createPaymentRequirements(config: PaymentConfig): ResolvedRequirementsConfig;
+declare const paymentMiddleware: (config: PaymentConfig, handler?: BunHandler) => BunMiddleware$1;
+
+interface MiddlewareConfig {
+    payTo: PayToAddress;
+    network: string | number;
+    amount: string;
+    facilitator?: FacilitatorConfig;
+    settlementMode?: SettlementMode;
+}
+
+type BunMiddleware = (request: Request) => Promise<Response | null>;
+interface RouteAwareBunMiddlewareConfig extends MiddlewareConfig {
+    route?: string;
+    routes?: string[];
+    perRoute?: Record<string, Partial<MiddlewareConfig>>;
+    waitForSettlement?: boolean;
+}
+declare const createRouteAwareBunMiddleware: (config: RouteAwareBunMiddlewareConfig, handler?: BunHandler) => BunMiddleware | ((request: Request) => Promise<Response>);
+
+export { type BunHandler as B, type MiddlewareConfig as M, type PaymentConfig as P, type ResolvedRequirementsConfig as R, type BunMiddleware$1 as a, type RouteAwareBunMiddlewareConfig as b, createPaymentRequirements as c, createRouteAwareBunMiddleware as d, type BunMiddleware as e, paymentMiddleware as p, resolveFacilitatorUrlFromRequirement as r };

package/dist/routes.d.ts

@@ -1,27 +1,2 @@
-import { PayToAddress, FacilitatorConfig, SettlementMode } from '@armory-sh/base';
-
-interface MiddlewareConfig {
-    payTo: PayToAddress;
-    network: string | number;
-    amount: string;
-    facilitator?: FacilitatorConfig;
-    settlementMode?: SettlementMode;
-}
-
-type BunMiddleware$1 = (request: Request) => Promise<Response | null>;
-interface RouteAwareBunMiddlewareConfig extends MiddlewareConfig {
-    route?: string;
-    routes?: string[];
-    perRoute?: Record<string, Partial<MiddlewareConfig>>;
-    waitForSettlement?: boolean;
-}
-declare const createRouteAwareBunMiddleware: (config: RouteAwareBunMiddlewareConfig, handler?: BunHandler) => BunMiddleware$1 | ((request: Request) => Promise<Response>);
-
-type BunMiddleware = (request: Request) => Promise<Response | null>;
-type BunHandler = (request: Request) => Promise<Response> | Response;
-interface BunMiddlewareConfig extends MiddlewareConfig {
-    waitForSettlement?: boolean;
-}
-declare const createBunMiddleware: (config: BunMiddlewareConfig, handler?: BunHandler) => BunMiddleware | ((request: Request) => Promise<Response>);
-
-export { type BunHandler as B, type BunMiddleware$1 as BunMiddleware, type RouteAwareBunMiddlewareConfig, type BunMiddleware as a, type BunMiddlewareConfig as b, createBunMiddleware as c, createRouteAwareBunMiddleware };
+export { e as BunMiddleware, b as RouteAwareBunMiddlewareConfig, d as createRouteAwareBunMiddleware } from './routes-C69V5KAQ.js';
+import '@armory-sh/base';

package/dist/routes.js

@@ -1 +1 @@
-export { createRouteAwareBunMiddleware } from './chunk-WLKV5FDR.js';
+export { createRouteAwareBunMiddleware } from './chunk-BJBLQMMR.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/middleware-bun",
-  "version": "0.3.26",
+  "version": "0.3.28",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "keywords": [
@@ -43,7 +43,7 @@
     "directory": "packages/middleware-bun"
   },
   "dependencies": {
-    "@armory-sh/base": "0.2.28"
+    "@armory-sh/base": "0.2.30"
   },
   "devDependencies": {
     "bun-types": "latest",
@@ -52,6 +52,8 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsup",
+    "lint": "bun run build",
+    "format": "bun run lint",
     "test": "bun test"
   }
 }