@armory-sh/client-web3 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,29 @@
+# @armory-sh/client-web3
+
+Web3.js client for creating and signing Armory payments.
+
+## Install
+
+```bash
+bun add @armory-sh/client-web3
+```
+
+## Use
+
+```typescript
+import { Web3 } from 'web3'
+import { createArmoryPayment } from '@armory-sh/client-web3'
+
+const web3 = new Web3('https://mainnet.base.org')
+
+const payment = await createArmoryPayment(web3, {
+  to: '0x...',
+  amount: 1000000n,
+  chainId: 'eip155:8453',
+  assetId: 'eip155:8453/erc20:0x...'
+})
+```
+
+---
+
+MIT License | Sawyer Cutler 2026 | Provided "AS IS" without warranty

package/dist/index.d.ts

@@ -0,0 +1,147 @@
+import { Web3BaseWalletAccount, Web3BaseWallet } from 'web3-types';
+import { PaymentPayloadV1, PaymentPayloadV2, CustomToken, NetworkConfig, PaymentRequirementsV1, PaymentRequirementsV2, SettlementResponseV1, SettlementResponseV2 } from '@armory-sh/base';
+export { EIP712_TYPES as CORE_EIP712_TYPES, USDC_DOMAIN as CORE_USDC_DOMAIN, NETWORKS, NetworkConfig, PaymentPayload, PaymentPayloadV1, PaymentPayloadV2, PaymentRequirements, PaymentRequirementsV1, PaymentRequirementsV2, SettlementResponse, SettlementResponseV1, SettlementResponseV2, V1_HEADERS, V2_HEADERS, createEIP712Domain as createCoreEIP712Domain, createTransferWithAuthorization as createCoreTransferWithAuthorization, decodePaymentV1, decodePaymentV2, decodeSettlementV1, decodeSettlementV2, encodePaymentV1, encodePaymentV2, encodeSettlementV1, encodeSettlementV2, getMainnets, getNetworkByChainId, getNetworkConfig, getPaymentHeaderName, getPaymentRequiredHeaderName, getPaymentResponseHeaderName, getPaymentVersionFromPayload, getRequirementsVersion, getSettlementVersion, getTestnets, getTxHash, isAddress, isCAIP2ChainId, isCAIPAssetId, isSettlementSuccessful, isV1, isV2, validateTransferWithAuthorization as validateCoreTransferWithAuthorization } from '@armory-sh/base';
+
+type Web3Account = Web3BaseWalletAccount | Web3BaseWallet<Web3BaseWalletAccount>;
+/** Token configuration - can use pre-configured tokens from @armory-sh/tokens */
+type Token = CustomToken;
+interface Web3ClientConfig {
+    account: Web3Account;
+    network: NetworkConfig | string;
+    version?: 1 | 2;
+    rpcUrl?: string;
+    /** Pre-configured token object (overrides individual fields below) */
+    token?: Token;
+    /** Override EIP-712 domain name for custom tokens */
+    domainName?: string;
+    /** Override EIP-712 domain version for custom tokens */
+    domainVersion?: string;
+}
+interface PaymentSignatureResult {
+    v?: number;
+    r?: string;
+    s?: string;
+    signature?: {
+        v: number;
+        r: string;
+        s: string;
+    };
+    payload: PaymentPayloadV1 | PaymentPayloadV2;
+}
+interface PaymentSignOptions {
+    amount: string | bigint;
+    to: string;
+    nonce?: string;
+    expiry?: number;
+    validAfter?: number;
+}
+interface X402RequestContext {
+    url: string;
+    method: string;
+    headers: Record<string, string> | Headers;
+    body?: string | Record<string, unknown> | null;
+    version: 1 | 2;
+}
+interface X402TransportOptions {
+    client: Web3X402Client;
+    autoSign?: boolean;
+    maxRetries?: number;
+}
+interface Web3X402Client {
+    getAccount(): Web3Account;
+    getNetwork(): NetworkConfig;
+    getVersion(): 1 | 2;
+    signPayment(options: PaymentSignOptions): Promise<PaymentSignatureResult>;
+    createPaymentHeaders(options: PaymentSignOptions): Promise<Headers>;
+    handlePaymentRequired(requirements: PaymentRequirementsV1 | PaymentRequirementsV2): Promise<PaymentSignatureResult>;
+    verifySettlement(response: SettlementResponseV1 | SettlementResponseV2): boolean;
+}
+interface X402Transport {
+    fetch(url: string | Request, init?: RequestInit): Promise<Response>;
+    getClient(): Web3X402Client;
+}
+interface Web3TransferWithAuthorization {
+    from: string;
+    to: string;
+    value: string | bigint;
+    validAfter: string | bigint;
+    validBefore: string | bigint;
+    nonce: string | bigint;
+}
+interface Web3EIP712Domain {
+    name: string;
+    version: string;
+    chainId: string | number;
+    verifyingContract: string;
+    [key: string]: string | number;
+}
+declare const isV1Requirements: (requirements: PaymentRequirementsV1 | PaymentRequirementsV2) => requirements is PaymentRequirementsV1;
+declare const isV2Requirements: (requirements: PaymentRequirementsV1 | PaymentRequirementsV2) => requirements is PaymentRequirementsV2;
+declare const isV1Settlement: (response: SettlementResponseV1 | SettlementResponseV2) => response is SettlementResponseV1;
+declare const isV2Settlement: (response: SettlementResponseV1 | SettlementResponseV2) => response is SettlementResponseV2;
+
+declare const createX402Client: (config: Web3ClientConfig) => Web3X402Client;
+
+declare const createX402Transport: (options: X402TransportOptions) => X402Transport;
+declare const createFetchWithX402: (transport: X402Transport) => (url: string | Request, init?: RequestInit) => Promise<Response>;
+
+declare const EIP712_TYPES: {
+    readonly EIP712Domain: readonly [{
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly name: "version";
+        readonly type: "string";
+    }, {
+        readonly name: "chainId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "verifyingContract";
+        readonly type: "address";
+    }];
+    readonly TransferWithAuthorization: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validAfter";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validBefore";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+};
+declare const USDC_DOMAIN: {
+    readonly NAME: "USD Coin";
+    readonly VERSION: "2";
+};
+declare const createEIP712Domain: (chainId: number | string, contractAddress: string, domainName?: string, domainVersion?: string) => Web3EIP712Domain;
+declare const createTransferWithAuthorization: (params: Web3TransferWithAuthorization) => Record<string, string>;
+declare const validateTransferWithAuthorization: (message: Web3TransferWithAuthorization) => boolean;
+declare const parseSignature: (signature: string) => {
+    v: number;
+    r: string;
+    s: string;
+};
+declare const concatenateSignature: (v: number, r: string, s: string) => string;
+declare const adjustVForChainId: (v: number, chainId: number) => number;
+declare const signTypedData: (_account: Web3BaseWalletAccount | Web3BaseWallet<Web3BaseWalletAccount>, _domain: Web3EIP712Domain, _message: Record<string, string>) => Promise<{
+    v: number;
+    r: string;
+    s: string;
+}>;
+declare const signWithPrivateKey: (_privateKey: string, _domain: Web3EIP712Domain, _message: Record<string, string>) => Promise<{
+    v: number;
+    r: string;
+    s: string;
+}>;
+
+export { EIP712_TYPES, type PaymentSignOptions, type PaymentSignatureResult, type Token, USDC_DOMAIN, type Web3Account, type Web3ClientConfig, type Web3EIP712Domain, type Web3TransferWithAuthorization, type Web3X402Client, type X402RequestContext, type X402Transport, type X402TransportOptions, adjustVForChainId, concatenateSignature, createEIP712Domain, createFetchWithX402, createTransferWithAuthorization, createX402Client, createX402Transport, isV1Requirements, isV1Settlement, isV2Requirements, isV2Settlement, parseSignature, signTypedData, signWithPrivateKey, validateTransferWithAuthorization };

package/dist/index.js

@@ -0,0 +1,504 @@
+// src/client.ts
+import { Web3 } from "web3";
+import {
+  getNetworkConfig,
+  encodePaymentV1,
+  encodePaymentV2
+} from "@armory-sh/base";
+
+// src/eip3009.ts
+var EIP712_TYPES = {
+  EIP712Domain: [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" }
+  ],
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+var USDC_DOMAIN = {
+  NAME: "USD Coin",
+  VERSION: "2"
+};
+var toQuantity = (value) => {
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "number") return `0x${value.toString(16)}`;
+  return value;
+};
+var toBigInt = (value) => {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") return BigInt(Math.floor(value));
+  if (typeof value === "string") {
+    return value.startsWith("0x") ? BigInt(value) : BigInt(value);
+  }
+  throw new Error(`Invalid value type: ${typeof value}`);
+};
+var createEIP712Domain = (chainId, contractAddress, domainName, domainVersion) => ({
+  name: domainName ?? USDC_DOMAIN.NAME,
+  version: domainVersion ?? USDC_DOMAIN.VERSION,
+  chainId: toQuantity(chainId),
+  verifyingContract: contractAddress.toLowerCase()
+});
+var createTransferWithAuthorization = (params) => ({
+  from: params.from.toLowerCase(),
+  to: params.to.toLowerCase(),
+  value: toQuantity(params.value),
+  validAfter: toQuantity(params.validAfter),
+  validBefore: toQuantity(params.validBefore),
+  nonce: toQuantity(params.nonce)
+});
+var validateTransferWithAuthorization = (message) => {
+  const addressRegex = /^0x[a-fA-F0-9]{40}$/;
+  if (!addressRegex.test(message.from)) {
+    throw new Error(`Invalid "from" address: ${message.from}`);
+  }
+  if (!addressRegex.test(message.to)) {
+    throw new Error(`Invalid "to" address: ${message.to}`);
+  }
+  const value = toBigInt(message.value);
+  if (value < 0n) {
+    throw new Error(`"value" must be non-negative: ${value}`);
+  }
+  const validAfter = toBigInt(message.validAfter);
+  const validBefore = toBigInt(message.validBefore);
+  if (validAfter < 0n) {
+    throw new Error(`"validAfter" must be non-negative: ${validAfter}`);
+  }
+  if (validBefore < 0n) {
+    throw new Error(`"validBefore" must be non-negative: ${validBefore}`);
+  }
+  if (validAfter >= validBefore) {
+    throw new Error(
+      `"validAfter" (${validAfter}) must be before "validBefore" (${validBefore})`
+    );
+  }
+  const nonce = toBigInt(message.nonce);
+  if (nonce < 0n) {
+    throw new Error(`"nonce" must be non-negative: ${nonce}`);
+  }
+  return true;
+};
+var parseSignature = (signature) => {
+  const hexSig = signature.startsWith("0x") ? signature.slice(2) : signature;
+  if (hexSig.length !== 130) {
+    throw new Error(`Invalid signature length: ${hexSig.length} (expected 130)`);
+  }
+  return {
+    r: `0x${hexSig.slice(0, 64)}`,
+    s: `0x${hexSig.slice(64, 128)}`,
+    v: parseInt(hexSig.slice(128, 130), 16)
+  };
+};
+var concatenateSignature = (v, r, s) => {
+  const rHex = r.startsWith("0x") ? r.slice(2) : r;
+  const sHex = s.startsWith("0x") ? s.slice(2) : s;
+  const vHex = v.toString(16).padStart(2, "0");
+  return `0x${rHex}${sHex}${vHex}`;
+};
+var adjustVForChainId = (v, chainId) => {
+  if (v === 27 || v === 28) return v;
+  const chainIdBit = chainId * 2 + 35;
+  return v - chainIdBit + 27;
+};
+var signTypedData = async (_account, _domain, _message) => {
+  throw new Error(
+    "EIP-712 signing requires web3-eth-personal or wallet provider."
+  );
+};
+var signWithPrivateKey = async (_privateKey, _domain, _message) => {
+  throw new Error(
+    "Direct private key signing not implemented. Use wallet provider's signTypedData method instead."
+  );
+};
+
+// src/client.ts
+var DEFAULT_EXPIRY_SECONDS = 3600;
+var DEFAULT_VALID_AFTER = 0;
+var extractDomainConfig = (config) => {
+  if (config.token) {
+    return {
+      domainName: config.token.name,
+      domainVersion: config.token.version
+    };
+  }
+  return {
+    domainName: config.domainName,
+    domainVersion: config.domainVersion
+  };
+};
+var createClientState = (config) => {
+  const network = typeof config.network === "string" ? getNetworkConfig(config.network) ?? (() => {
+    throw new Error(`Unknown network: ${config.network}`);
+  })() : config.network;
+  const { domainName, domainVersion } = extractDomainConfig(config);
+  return {
+    account: config.account,
+    version: config.version ?? 2,
+    network,
+    web3: new Web3(config.rpcUrl ?? network.rpcUrl),
+    domainName,
+    domainVersion
+  };
+};
+var getAddress = (account) => {
+  if ("address" in account) return account.address;
+  if (Array.isArray(account) && account[0]) return account[0].address;
+  throw new Error("Unable to get address from account");
+};
+var parseSignature2 = (signature) => {
+  const hexSig = signature.startsWith("0x") ? signature.slice(2) : signature;
+  if (hexSig.length !== 130) throw new Error(`Invalid signature length: ${hexSig.length}`);
+  return {
+    r: `0x${hexSig.slice(0, 64)}`,
+    s: `0x${hexSig.slice(64, 128)}`,
+    v: parseInt(hexSig.slice(128, 130), 16)
+  };
+};
+var signTypedDataWrapper = async (account, domain, message) => {
+  const acc = account;
+  if (typeof acc.signTypedData === "function") {
+    const sig = await acc.signTypedData(domain, message);
+    return parseSignature2(sig);
+  }
+  const getAddress2 = () => {
+    if ("address" in account) return account.address;
+    if (Array.isArray(account) && account[0]) return account[0].address;
+    throw new Error("Unable to get address from account");
+  };
+  if (typeof acc.request === "function") {
+    const sig = await acc.request({
+      method: "eth_signTypedData_v4",
+      params: [getAddress2(), JSON.stringify({ domain, message })]
+    });
+    return parseSignature2(sig);
+  }
+  if ("privateKey" in account && typeof account.privateKey === "string") {
+    throw new Error("Direct private key signing not implemented. Use wallet provider with signTypedData.");
+  }
+  throw new Error("Account does not support EIP-712 signing.");
+};
+var signPaymentV1 = async (state, params) => {
+  const { from, to, amount, nonce, expiry, validAfter } = params;
+  const { network, domainName, domainVersion } = state;
+  const domain = createEIP712Domain(network.chainId, network.usdcAddress, domainName, domainVersion);
+  const message = createTransferWithAuthorization({
+    from,
+    to,
+    value: amount,
+    validAfter: `0x${validAfter.toString(16)}`,
+    validBefore: `0x${expiry.toString(16)}`,
+    nonce: `0x${nonce}`
+  });
+  const signature = await signTypedDataWrapper(state.account, domain, message);
+  const payload = {
+    from,
+    to,
+    amount,
+    nonce,
+    expiry,
+    v: signature.v,
+    r: signature.r,
+    s: signature.s,
+    chainId: network.chainId,
+    contractAddress: network.usdcAddress,
+    network: network.name.toLowerCase().replace(" ", "-")
+  };
+  return { v: signature.v, r: signature.r, s: signature.s, payload };
+};
+var signPaymentV2 = async (state, params) => {
+  const { from, to, amount, nonce, expiry } = params;
+  const { network, domainName, domainVersion } = state;
+  const domain = createEIP712Domain(network.chainId, network.usdcAddress, domainName, domainVersion);
+  const message = createTransferWithAuthorization({
+    from,
+    to,
+    value: amount,
+    validAfter: "0x0",
+    validBefore: `0x${expiry.toString(16)}`,
+    nonce: `0x${nonce}`
+  });
+  const signature = await signTypedDataWrapper(state.account, domain, message);
+  const payload = {
+    from,
+    to,
+    amount,
+    nonce,
+    expiry,
+    signature: {
+      v: signature.v,
+      r: signature.r,
+      s: signature.s
+    },
+    chainId: network.caip2Id,
+    assetId: network.caipAssetId
+  };
+  return { signature: payload.signature, payload };
+};
+var createX402Client = (config) => {
+  const state = createClientState(config);
+  return {
+    getAccount: () => state.account,
+    getNetwork: () => state.network,
+    getVersion: () => state.version,
+    signPayment: async (options) => {
+      const from = getAddress(state.account);
+      const to = options.to;
+      const amount = options.amount.toString();
+      const nonce = options.nonce ?? crypto.randomUUID();
+      const expiry = options.expiry ?? Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS;
+      if (state.version === 1) {
+        return signPaymentV1(state, {
+          from,
+          to,
+          amount,
+          nonce,
+          expiry,
+          validAfter: options.validAfter ?? DEFAULT_VALID_AFTER
+        });
+      }
+      return signPaymentV2(state, { from, to, amount, nonce, expiry });
+    },
+    createPaymentHeaders: async (options) => {
+      const result = await signPayment(options, state);
+      const headers = new Headers();
+      if (state.version === 1) {
+        headers.set("X-PAYMENT", encodePaymentV1(result.payload));
+      } else {
+        headers.set("PAYMENT-SIGNATURE", encodePaymentV2(result.payload));
+      }
+      return headers;
+    },
+    handlePaymentRequired: async (requirements) => {
+      if ("contractAddress" in requirements) {
+        const req2 = requirements;
+        return signPayment({
+          amount: req2.amount,
+          to: req2.payTo,
+          expiry: req2.expiry
+        }, state);
+      }
+      const req = requirements;
+      const to = typeof req.to === "string" ? req.to : "0x0000000000000000000000000000000000000000";
+      return signPayment({
+        amount: req.amount,
+        to,
+        nonce: req.nonce,
+        expiry: req.expiry
+      }, state);
+    },
+    verifySettlement: (response) => {
+      return "success" in response ? response.success : response.status === "success";
+    }
+  };
+};
+var signPayment = async (options, state) => {
+  const from = getAddress(state.account);
+  if (state.version === 1) {
+    return signPaymentV1(state, {
+      from,
+      to: options.to,
+      amount: options.amount.toString(),
+      nonce: options.nonce ?? crypto.randomUUID(),
+      expiry: options.expiry ?? Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS,
+      validAfter: options.validAfter ?? DEFAULT_VALID_AFTER
+    });
+  }
+  return signPaymentV2(state, {
+    from,
+    to: options.to,
+    amount: options.amount.toString(),
+    nonce: options.nonce ?? crypto.randomUUID(),
+    expiry: options.expiry ?? Math.floor(Date.now() / 1e3) + DEFAULT_EXPIRY_SECONDS
+  });
+};
+
+// src/transport.ts
+import { V1_HEADERS, V2_HEADERS, encodePaymentV1 as encodePaymentV12, encodePaymentV2 as encodePaymentV22 } from "@armory-sh/base";
+var DEFAULT_MAX_RETRIES = 3;
+var detectProtocolVersion = (response, client) => {
+  if (response.headers.has(V2_HEADERS.PAYMENT_REQUIRED) || response.headers.has("PAYMENT-REQUIRED")) {
+    return 2;
+  }
+  if (response.headers.has("X-PAYMENT-REQUIRED")) {
+    return 1;
+  }
+  return client.getVersion();
+};
+var parsePaymentRequirements = async (response, version) => {
+  if (version === 2) {
+    const header = response.headers.get(V2_HEADERS.PAYMENT_REQUIRED);
+    if (header) return JSON.parse(header);
+  } else {
+    const header = response.headers.get("X-PAYMENT-REQUIRED");
+    if (header) {
+      const json = Buffer.from(header, "base64").toString("utf-8");
+      return JSON.parse(json);
+    }
+  }
+  return JSON.parse(await response.clone().text());
+};
+var createPaymentHeaders = (payload, version) => {
+  const headers = new Headers();
+  if (version === 1) {
+    headers.set(V1_HEADERS.PAYMENT, encodePaymentV12(payload));
+  } else {
+    headers.set(V2_HEADERS.PAYMENT_SIGNATURE, encodePaymentV22(payload));
+  }
+  return headers;
+};
+var isPaymentRelatedError = (error) => error.message.includes("402") || error.message.includes("payment") || error.message.includes("signature");
+var backoff = (attempt) => {
+  const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 1e4);
+  return new Promise((resolve) => setTimeout(resolve, delay));
+};
+var handlePaymentRequired = async (response, client) => {
+  const version = detectProtocolVersion(response, client);
+  const requirements = await parsePaymentRequirements(response, version);
+  const result = await client.handlePaymentRequired(
+    requirements
+  );
+  return createPaymentHeaders(result.payload, version);
+};
+var mergePaymentHeaders = (init = {}, paymentHeaders) => {
+  const existingHeaders = new Headers(init.headers);
+  for (const [key, value] of paymentHeaders.entries()) {
+    existingHeaders.set(key, value);
+  }
+  return { ...init, headers: existingHeaders };
+};
+var createX402Transport = (options) => {
+  const client = options.client;
+  const autoSign = options.autoSign ?? true;
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  return {
+    getClient: () => client,
+    fetch: async (url, init) => {
+      let attempt = 0;
+      let lastError;
+      while (attempt < maxRetries) {
+        attempt++;
+        try {
+          const response = await fetch(url, init);
+          if (response.status === 402 && autoSign) {
+            const paymentHeaders = await handlePaymentRequired(response, client);
+            const newInit = mergePaymentHeaders(init, paymentHeaders);
+            return await fetch(url, newInit);
+          }
+          return response;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          if (!isPaymentRelatedError(lastError)) {
+            throw lastError;
+          }
+          if (attempt < maxRetries) {
+            await backoff(attempt);
+          }
+        }
+      }
+      throw lastError ?? new Error("Max retries exceeded");
+    }
+  };
+};
+var createFetchWithX402 = (transport) => (url, init) => transport.fetch(url, init);
+
+// src/types.ts
+var isV1Requirements = (requirements) => "contractAddress" in requirements;
+var isV2Requirements = (requirements) => "chainId" in requirements && "assetId" in requirements;
+var isV1Settlement = (response) => "success" in response;
+var isV2Settlement = (response) => "status" in response;
+
+// src/index.ts
+import {
+  V1_HEADERS as V1_HEADERS2,
+  encodePaymentV1 as encodePaymentV13,
+  decodePaymentV1,
+  encodeSettlementV1,
+  decodeSettlementV1,
+  V2_HEADERS as V2_HEADERS2,
+  isCAIP2ChainId,
+  isCAIPAssetId,
+  isAddress,
+  encodePaymentV2 as encodePaymentV23,
+  decodePaymentV2,
+  encodeSettlementV2,
+  decodeSettlementV2,
+  isV1,
+  isV2,
+  getPaymentVersionFromPayload,
+  getRequirementsVersion,
+  getSettlementVersion,
+  getPaymentHeaderName,
+  getPaymentResponseHeaderName,
+  getPaymentRequiredHeaderName,
+  isSettlementSuccessful,
+  getTxHash,
+  NETWORKS,
+  getNetworkConfig as getNetworkConfig2,
+  getNetworkByChainId,
+  getMainnets,
+  getTestnets,
+  EIP712_TYPES as EIP712_TYPES2,
+  USDC_DOMAIN as USDC_DOMAIN2,
+  createEIP712Domain as createEIP712Domain2,
+  createTransferWithAuthorization as createTransferWithAuthorization2,
+  validateTransferWithAuthorization as validateTransferWithAuthorization2
+} from "@armory-sh/base";
+export {
+  EIP712_TYPES2 as CORE_EIP712_TYPES,
+  USDC_DOMAIN2 as CORE_USDC_DOMAIN,
+  EIP712_TYPES,
+  NETWORKS,
+  USDC_DOMAIN,
+  V1_HEADERS2 as V1_HEADERS,
+  V2_HEADERS2 as V2_HEADERS,
+  adjustVForChainId,
+  concatenateSignature,
+  createEIP712Domain2 as createCoreEIP712Domain,
+  createTransferWithAuthorization2 as createCoreTransferWithAuthorization,
+  createEIP712Domain,
+  createFetchWithX402,
+  createTransferWithAuthorization,
+  createX402Client,
+  createX402Transport,
+  decodePaymentV1,
+  decodePaymentV2,
+  decodeSettlementV1,
+  decodeSettlementV2,
+  encodePaymentV13 as encodePaymentV1,
+  encodePaymentV23 as encodePaymentV2,
+  encodeSettlementV1,
+  encodeSettlementV2,
+  getMainnets,
+  getNetworkByChainId,
+  getNetworkConfig2 as getNetworkConfig,
+  getPaymentHeaderName,
+  getPaymentRequiredHeaderName,
+  getPaymentResponseHeaderName,
+  getPaymentVersionFromPayload,
+  getRequirementsVersion,
+  getSettlementVersion,
+  getTestnets,
+  getTxHash,
+  isAddress,
+  isCAIP2ChainId,
+  isCAIPAssetId,
+  isSettlementSuccessful,
+  isV1,
+  isV1Requirements,
+  isV1Settlement,
+  isV2,
+  isV2Requirements,
+  isV2Settlement,
+  parseSignature,
+  signTypedData,
+  signWithPrivateKey,
+  validateTransferWithAuthorization2 as validateCoreTransferWithAuthorization,
+  validateTransferWithAuthorization
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@armory-sh/client-web3",
+  "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/client-web3"
+  },
+  "dependencies": {
+    "@armory-sh/base": "workspace:*",
+    "web3": "4.16.0",
+    "web3-types": "1.10.0"
+  },
+  "devDependencies": {
+    "typescript": "5.9.3",
+    "bun-types": "latest"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "bun test",
+    "example": "bun run examples/"
+  }
+}