@armory-sh/base 0.2.27-alpha.23.76 → 0.2.27-alpha.23.78

package/dist/payment-client.d.ts

@@ -1,4 +1,4 @@
-import type { PaymentPayload, PaymentRequirements, VerifyResponse, SettlementResponse } from "./types/x402";
+import type { PaymentPayload, PaymentRequirements, SettlementResponse, VerifyResponse } from "./types/x402";
 export interface FacilitatorClientConfig {
     url: string;
     createHeaders?: () => Record<string, string> | Promise<Record<string, string>>;

package/dist/payment-requirements.d.ts

@@ -1,5 +1,5 @@
-import type { PaymentRequirementsV2, Address } from "./types/v2";
 import type { NetworkId, TokenId, ValidationError } from "./types/api";
+import type { Address, PaymentRequirementsV2 } from "./types/v2";
 export interface PaymentConfig {
     payTo: Address | string;
     chains?: NetworkId[];

package/dist/types/api.d.ts

@@ -2,8 +2,8 @@
  * Simple, developer-friendly API types for Armory
  * Focuses on DX/UX - "everything just magically works"
  */
+import type { CustomToken, NetworkConfig } from "./networks";
 import type { Address, CAIPAssetId } from "./v2";
-import type { NetworkConfig, CustomToken } from "./networks";
 /**
  * Network identifier - flexible input that resolves to a chain
  * - Network name: "base", "ethereum", "skale-base"

package/dist/types/hooks.d.ts

@@ -7,11 +7,13 @@
  *
  * Hooks allow extensibility without custom code in each client package.
  */
-import type { PaymentPayloadV2, PaymentRequirementsV2, Extensions, Address } from "./v2";
+import type { Address, Extensions, PaymentPayloadV2, PaymentRequirementsV2 } from "./v2";
 export interface PaymentRequiredContext {
     url: RequestInfo | URL;
     requestInit: RequestInit | undefined;
+    accepts: PaymentRequirementsV2[];
     requirements: PaymentRequirementsV2;
+    selectedRequirement?: PaymentRequirementsV2;
     serverExtensions: Extensions | undefined;
     fromAddress: Address;
     nonce: `0x${string}`;
@@ -33,3 +35,17 @@ export interface HookConfig<TWallet = unknown> {
     name?: string;
 }
 export type HookRegistry<TWallet = unknown> = Record<string, HookConfig<TWallet>>;
+export interface ClientHookErrorContext {
+    error: unknown;
+    phase: "onPaymentRequired" | "selectRequirement" | "beforeSignPayment" | "afterPaymentResponse";
+}
+export interface ClientHook<TWallet = unknown> {
+    name?: string;
+    onPaymentRequired?: (context: PaymentRequiredContext) => HookResult;
+    selectRequirement?: (context: PaymentRequiredContext) => PaymentRequirementsV2 | undefined | Promise<PaymentRequirementsV2 | undefined>;
+    beforeSignPayment?: (context: PaymentPayloadContext<TWallet>) => HookResult;
+    afterPaymentResponse?: (context: PaymentPayloadContext<TWallet> & {
+        response: Response;
+    }) => HookResult;
+    onError?: (context: ClientHookErrorContext) => HookResult;
+}

package/dist/types/protocol.d.ts

@@ -3,7 +3,7 @@
  *
  * Simplified to support only x402 V2 format (Coinbase compatible)
  */
-import type { PaymentPayloadV2, PaymentRequirementsV2, SettlementResponseV2, PaymentRequiredV2, Address } from "./v2";
+import type { Address, PaymentPayloadV2, PaymentRequiredV2, PaymentRequirementsV2, SettlementResponseV2 } from "./v2";
 export type PaymentPayload = PaymentPayloadV2;
 export type PaymentRequirements = PaymentRequirementsV2;
 export type SettlementResponse = SettlementResponseV2;

package/dist/utils/x402.d.ts

@@ -3,7 +3,7 @@
  *
  * Helper functions for nonce generation, amount conversion, and other utilities.
  */
-import type { Hex, Address } from "../types/x402";
+import type { Address, Hex } from "../types/x402";
 /**
  * Generate a random 32-byte nonce as hex string
  * Matches Coinbase SDK format: "0x" + 64 hex characters

package/dist/validation.d.ts

@@ -2,7 +2,7 @@
  * Comprehensive validation for Armory configurations
  * Ensures networks, tokens, and facilitators are compatible
  */
-import type { NetworkId, TokenId, FacilitatorConfig, ResolvedNetwork, ResolvedToken, ResolvedFacilitator, ResolvedPaymentConfig, ValidationError, PaymentErrorCode } from "./types/api";
+import type { FacilitatorConfig, NetworkId, PaymentErrorCode, ResolvedFacilitator, ResolvedNetwork, ResolvedPaymentConfig, ResolvedToken, TokenId, ValidationError } from "./types/api";
 export declare const createError: (code: PaymentErrorCode, message: string, details?: Partial<ValidationError>) => ValidationError;
 export declare const normalizeNetworkName: (name: string) => string;
 export declare const resolveNetwork: (input: unknown) => ResolvedNetwork | ValidationError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@armory-sh/base",
-  "version": "0.2.27-alpha.23.76",
+  "version": "0.2.27-alpha.23.78",
   "license": "MIT",
   "author": "Sawyer Cutler <sawyer@dirtroad.dev>",
   "keywords": [
@@ -28,10 +28,21 @@
       "bun": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./types/hooks": {
+      "types": "./src/types/hooks.ts",
+      "bun": "./src/types/hooks.ts",
+      "default": "./src/types/hooks.ts"
+    },
+    "./client-hooks-runtime": {
+      "types": "./src/client-hooks-runtime.ts",
+      "bun": "./src/client-hooks-runtime.ts",
+      "default": "./src/client-hooks-runtime.ts"
+    },
     "./dist/*": "./dist/*.js"
   },
   "files": [
     "dist",
+    "src",
     "README.md"
   ],
   "publishConfig": {
@@ -50,6 +61,8 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsup && tsc --emitDeclarationOnly",
+    "lint": "bun run build",
+    "format": "bun run lint",
     "test": "bun test",
     "typecheck": "tsc --noEmit"
   }

package/src/abi/erc20.ts

@@ -0,0 +1,84 @@
+export type TransferWithAuthorizationParams = readonly [
+  from: `0x${string}`,
+  to: `0x${string}`,
+  amount: bigint,
+  validAfter: bigint,
+  expiry: bigint,
+  v: number,
+  r: `0x${string}`,
+  s: `0x${string}`,
+];
+
+export type ReceiveWithAuthorizationParams = readonly [
+  from: `0x${string}`,
+  to: `0x${string}`,
+  amount: bigint,
+  validAfter: bigint,
+  expiry: bigint,
+  v: number,
+  r: `0x${string}`,
+  s: `0x${string}`,
+];
+
+export type BalanceOfParams = readonly [account: `0x${string}`];
+export type BalanceOfReturnType = bigint;
+export type NameReturnType = string;
+export type SymbolReturnType = string;
+
+export const ERC20_ABI = [
+  {
+    type: "function",
+    name: "transferWithAuthorization",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "expiry", type: "uint256" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" },
+    ],
+    outputs: [],
+  },
+  {
+    type: "function",
+    name: "receiveWithAuthorization",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "expiry", type: "uint256" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" },
+    ],
+    outputs: [],
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "balance", type: "uint256" }],
+  },
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+  },
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+  },
+] as const;
+
+export type ERC20Abi = typeof ERC20_ABI;

package/src/client-hooks-runtime.ts

@@ -0,0 +1,133 @@
+import type {
+  ClientHook,
+  ClientHookErrorContext,
+  PaymentPayloadContext,
+  PaymentRequiredContext,
+} from "./types/hooks";
+import type { PaymentRequirementsV2 } from "./types/v2";
+
+const notifyError = async <TWallet>(
+  hooks: ClientHook<TWallet>[] | undefined,
+  context: ClientHookErrorContext,
+): Promise<void> => {
+  if (!hooks?.length) {
+    return;
+  }
+
+  for (const hook of hooks) {
+    if (!hook.onError) {
+      continue;
+    }
+    await hook.onError(context);
+  }
+};
+
+export const runOnPaymentRequiredHooks = async <TWallet>(
+  hooks: ClientHook<TWallet>[] | undefined,
+  context: PaymentRequiredContext,
+): Promise<void> => {
+  if (!hooks?.length) {
+    return;
+  }
+
+  for (const hook of hooks) {
+    if (!hook.onPaymentRequired) {
+      continue;
+    }
+    try {
+      await hook.onPaymentRequired(context);
+    } catch (error) {
+      await notifyError(hooks, { error, phase: "onPaymentRequired" });
+      throw error;
+    }
+  }
+};
+
+export const selectRequirementWithHooks = async <TWallet>(
+  hooks: ClientHook<TWallet>[] | undefined,
+  context: PaymentRequiredContext,
+): Promise<PaymentRequirementsV2> => {
+  if (!context.accepts.length) {
+    throw new Error("No payment requirements found in accepts array");
+  }
+
+  let selected = context.accepts[0];
+
+  if (!hooks?.length) {
+    context.selectedRequirement = selected;
+    context.requirements = selected;
+    return selected;
+  }
+
+  for (const hook of hooks) {
+    if (!hook.selectRequirement) {
+      continue;
+    }
+    try {
+      const override = await hook.selectRequirement({
+        ...context,
+        selectedRequirement: selected,
+        requirements: selected,
+      });
+      if (!override) {
+        continue;
+      }
+      const isValid = context.accepts.some((accept) => accept === override);
+      if (!isValid) {
+        throw new Error(
+          "Hook selectRequirement must return an item from accepts",
+        );
+      }
+      selected = override;
+    } catch (error) {
+      await notifyError(hooks, { error, phase: "selectRequirement" });
+      throw error;
+    }
+  }
+
+  context.selectedRequirement = selected;
+  context.requirements = selected;
+  return selected;
+};
+
+export const runBeforeSignPaymentHooks = async <TWallet>(
+  hooks: ClientHook<TWallet>[] | undefined,
+  context: PaymentPayloadContext<TWallet>,
+): Promise<void> => {
+  if (!hooks?.length) {
+    return;
+  }
+
+  for (const hook of hooks) {
+    if (!hook.beforeSignPayment) {
+      continue;
+    }
+    try {
+      await hook.beforeSignPayment(context);
+    } catch (error) {
+      await notifyError(hooks, { error, phase: "beforeSignPayment" });
+      throw error;
+    }
+  }
+};
+
+export const runAfterPaymentResponseHooks = async <TWallet>(
+  hooks: ClientHook<TWallet>[] | undefined,
+  context: PaymentPayloadContext<TWallet> & { response: Response },
+): Promise<void> => {
+  if (!hooks?.length) {
+    return;
+  }
+
+  for (const hook of hooks) {
+    if (!hook.afterPaymentResponse) {
+      continue;
+    }
+    try {
+      await hook.afterPaymentResponse(context);
+    } catch (error) {
+      await notifyError(hooks, { error, phase: "afterPaymentResponse" });
+      throw error;
+    }
+  }
+};

package/src/data/tokens.ts

@@ -0,0 +1,199 @@
+import type { CustomToken } from "../types/networks";
+
+export const USDC_BASE: CustomToken = {
+  symbol: "USDC",
+  name: "USDC",
+  version: "2",
+  contractAddress:
+    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as `0x${string}`,
+  chainId: 8453,
+  decimals: 6,
+};
+
+export const EURC_BASE: CustomToken = {
+  symbol: "EURC",
+  name: "EURC",
+  version: "2",
+  contractAddress:
+    "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42" as `0x${string}`,
+  chainId: 8453,
+  decimals: 6,
+};
+
+export const USDC_BASE_SEPOLIA: CustomToken = {
+  symbol: "USDC",
+  name: "USDC",
+  version: "2",
+  contractAddress:
+    "0x036CbD53842c5426634e7929541eC2318f3dCF7e" as `0x${string}`,
+  chainId: 84532,
+  decimals: 6,
+};
+
+export const USDC_SKALE_BASE: CustomToken = {
+  symbol: "USDC",
+  name: "Bridged USDC (SKALE Bridge)",
+  version: "2",
+  contractAddress:
+    "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20" as `0x${string}`,
+  chainId: 1187947933,
+  decimals: 6,
+};
+
+export const SKL_SKALE_BASE: CustomToken = {
+  symbol: "SKL",
+  name: "SKALE",
+  version: "1",
+  contractAddress:
+    "0xE0595a049d02b7674572b0d59cd4880Db60EDC50" as `0x${string}`,
+  chainId: 1187947933,
+  decimals: 18,
+};
+
+export const USDT_SKALE_BASE: CustomToken = {
+  symbol: "USDT",
+  name: "Tether USD",
+  version: "1",
+  contractAddress:
+    "0x2bF5bF154b515EaA82C31a65ec11554fF5aF7fCA" as `0x${string}`,
+  chainId: 1187947933,
+  decimals: 6,
+};
+
+export const WBTC_SKALE_BASE: CustomToken = {
+  symbol: "WBTC",
+  name: "Wrapped BTC",
+  version: "1",
+  contractAddress:
+    "0x1aeeCFE5454c83B42D8A316246CAc9739E7f690e" as `0x${string}`,
+  chainId: 1187947933,
+  decimals: 8,
+};
+
+export const WETH_SKALE_BASE: CustomToken = {
+  symbol: "WETH",
+  name: "Wrapped Ether",
+  version: "1",
+  contractAddress:
+    "0x7bD39ABBd0Dd13103542cAe3276C7fA332bCA486" as `0x${string}`,
+  chainId: 1187947933,
+  decimals: 18,
+};
+
+export const SKL_SKALE_BASE_SEPOLIA: CustomToken = {
+  symbol: "SKL",
+  name: "SKALE",
+  version: "1",
+  contractAddress:
+    "0xaf2e0ff5b5f51553fdb34ce7f04a6c3201cee57b" as `0x${string}`,
+  chainId: 324705682,
+  decimals: 18,
+};
+
+export const USDC_SKALE_BASE_SEPOLIA: CustomToken = {
+  symbol: "USDC",
+  name: "Bridged USDC (SKALE Bridge)",
+  version: "2",
+  contractAddress:
+    "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD" as `0x${string}`,
+  chainId: 324705682,
+  decimals: 6,
+};
+
+export const USDT_SKALE_BASE_SEPOLIA: CustomToken = {
+  symbol: "USDT",
+  name: "Tether USD",
+  version: "1",
+  contractAddress:
+    "0x3ca0a49f511c2c89c4dcbbf1731120d8919050bf" as `0x${string}`,
+  chainId: 324705682,
+  decimals: 6,
+};
+
+export const WBTC_SKALE_BASE_SEPOLIA: CustomToken = {
+  symbol: "WBTC",
+  name: "Wrapped BTC",
+  version: "1",
+  contractAddress:
+    "0x4512eacd4186b025186e1cf6cc0d89497c530e87" as `0x${string}`,
+  chainId: 324705682,
+  decimals: 8,
+};
+
+export const WETH_SKALE_BASE_SEPOLIA: CustomToken = {
+  symbol: "WETH",
+  name: "Wrapped Ether",
+  version: "1",
+  contractAddress:
+    "0xf94056bd7f6965db3757e1b145f200b7346b4fc0" as `0x${string}`,
+  chainId: 324705682,
+  decimals: 18,
+};
+
+export const TOKENS = {
+  USDC_BASE,
+  USDC_BASE_SEPOLIA,
+  EURC_BASE,
+  USDC_SKALE_BASE,
+  USDT_SKALE_BASE,
+  WBTC_SKALE_BASE,
+  WETH_SKALE_BASE,
+  SKL_SKALE_BASE,
+  SKL_SKALE_BASE_SEPOLIA,
+  USDC_SKALE_BASE_SEPOLIA,
+  USDT_SKALE_BASE_SEPOLIA,
+  WBTC_SKALE_BASE_SEPOLIA,
+  WETH_SKALE_BASE_SEPOLIA,
+} as const;
+
+function getToken(
+  chainId: number,
+  contractAddress: string,
+): CustomToken | undefined {
+  const tokens = Object.values(TOKENS);
+  return tokens.find(
+    (t) =>
+      t.chainId === chainId &&
+      t.contractAddress.toLowerCase() === contractAddress.toLowerCase(),
+  );
+}
+
+function getAllTokens(): CustomToken[] {
+  return Object.values(TOKENS);
+}
+
+function getTokensBySymbol(symbol: string): CustomToken[] {
+  return getAllTokens().filter(
+    (t) => t.symbol.toUpperCase() === symbol.toUpperCase(),
+  );
+}
+
+function getTokensByChain(chainId: number): CustomToken[] {
+  return getAllTokens().filter((t) => t.chainId === chainId);
+}
+
+export function getUSDCTokens(): CustomToken[] {
+  return getTokensBySymbol("USDC");
+}
+
+export function getEURCTokens(): CustomToken[] {
+  return getTokensBySymbol("EURC");
+}
+
+export function getSKLTokens(): CustomToken[] {
+  return getTokensBySymbol("SKL");
+}
+
+export function getUSDTTokens(): CustomToken[] {
+  return getTokensBySymbol("USDT");
+}
+
+export function getWBTCTokens(): CustomToken[] {
+  return getTokensBySymbol("WBTC");
+}
+
+export function getWETHTokens(): CustomToken[] {
+  return getTokensBySymbol("WETH");
+}
+
+export { getToken, getAllTokens, getTokensBySymbol, getTokensByChain };

package/src/eip712.ts

@@ -0,0 +1,108 @@
+export type TypedDataDomain = {
+  name?: string;
+  version?: string;
+  chainId?: number;
+  verifyingContract?: `0x${string}`;
+  salt?: `0x${string}`;
+};
+
+export interface EIP712Domain {
+  name: string;
+  version: string;
+  chainId: number;
+  verifyingContract: `0x${string}`;
+}
+
+export interface TransferWithAuthorization {
+  from: `0x${string}`;
+  to: `0x${string}`;
+  value: bigint;
+  validAfter: bigint;
+  validBefore: bigint;
+  nonce: `0x${string}`;
+}
+
+export type TransferWithAuthorizationRecord = TransferWithAuthorization &
+  Record<string, unknown>;
+
+export type TypedDataField = { name: string; type: string };
+
+export type EIP712Types = {
+  TransferWithAuthorization: TypedDataField[];
+};
+
+export const EIP712_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" },
+  ] as const,
+} as const satisfies EIP712Types;
+
+export const USDC_DOMAIN = {
+  NAME: "USD Coin",
+  VERSION: "2",
+} as const;
+
+export const createEIP712Domain = (
+  chainId: number,
+  contractAddress: `0x${string}`,
+): EIP712Domain => ({
+  name: USDC_DOMAIN.NAME,
+  version: USDC_DOMAIN.VERSION,
+  chainId,
+  verifyingContract: contractAddress,
+});
+
+export const createTransferWithAuthorization = (
+  params: Omit<
+    TransferWithAuthorization,
+    "value" | "validAfter" | "validBefore" | "nonce"
+  > & {
+    value: bigint | number;
+    validAfter: bigint | number;
+    validBefore: bigint | number;
+    nonce: `0x${string}`;
+  },
+): TransferWithAuthorizationRecord => ({
+  from: params.from,
+  to: params.to,
+  value: BigInt(params.value),
+  validAfter: BigInt(params.validAfter),
+  validBefore: BigInt(params.validBefore),
+  nonce: params.nonce,
+});
+
+const isAddress = (value: string): boolean => /^0x[a-fA-F0-9]{40}$/.test(value);
+
+const isBytes32 = (value: string): boolean => /^0x[a-fA-F0-9]{64}$/.test(value);
+
+export const validateTransferWithAuthorization = (
+  message: TransferWithAuthorization,
+): boolean => {
+  if (!isAddress(message.from))
+    throw new Error(`Invalid "from" address: ${message.from}`);
+  if (!isAddress(message.to))
+    throw new Error(`Invalid "to" address: ${message.to}`);
+  if (message.value < 0n)
+    throw new Error(`"value" must be non-negative: ${message.value}`);
+  if (message.validAfter < 0n)
+    throw new Error(`"validAfter" must be non-negative: ${message.validAfter}`);
+  if (message.validBefore < 0n)
+    throw new Error(
+      `"validBefore" must be non-negative: ${message.validBefore}`,
+    );
+  if (message.validAfter >= message.validBefore) {
+    throw new Error(
+      `"validAfter" (${message.validAfter}) must be before "validBefore" (${message.validBefore})`,
+    );
+  }
+  if (!isBytes32(message.nonce))
+    throw new Error(
+      `"nonce" must be a valid bytes32 hex string: ${message.nonce}`,
+    );
+  return true;
+};