@atxp/base 0.10.5 → 0.10.6

package/dist/baseAppPaymentMaker.d.ts

@@ -0,0 +1,24 @@
+import { Logger, Currency, PaymentMaker, AccountId, PaymentIdentifier, Destination } from '@atxp/common';
+import { SpendPermission } from './types.js';
+import { type EphemeralSmartWallet } from './smartWalletHelpers.js';
+export declare class BaseAppPaymentMaker implements PaymentMaker {
+    private logger;
+    private spendPermission;
+    private smartWallet;
+    private chainId;
+    private usdcAddress;
+    constructor(spendPermission: SpendPermission, smartWallet: EphemeralSmartWallet, logger?: Logger, chainId?: number);
+    getSourceAddress(_params: {
+        amount: BigNumber;
+        currency: Currency;
+        receiver: string;
+        memo: string;
+    }): string;
+    generateJWT({ paymentRequestId, codeChallenge, accountId }: {
+        paymentRequestId: string;
+        codeChallenge: string;
+        accountId?: AccountId | null;
+    }): Promise<string>;
+    makePayment(destinations: Destination[], memo: string, _paymentRequestId?: string): Promise<PaymentIdentifier | null>;
+}
+//# sourceMappingURL=baseAppPaymentMaker.d.ts.map

package/dist/baseConstants.d.ts

@@ -0,0 +1,10 @@
+export declare const USDC_CONTRACT_ADDRESS_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+export declare const USDC_CONTRACT_ADDRESS_BASE_SEPOLIA = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
+/**
+ * Get USDC contract address for Base chain by chain ID
+ * @param chainId - Chain ID (8453 for mainnet, 84532 for sepolia)
+ * @returns USDC contract address
+ * @throws Error if chain ID is not supported
+ */
+export declare const getBaseUSDCAddress: (chainId: number) => string;
+//# sourceMappingURL=baseConstants.d.ts.map

package/dist/basePaymentMaker.d.ts

@@ -0,0 +1,23 @@
+import type { PaymentMaker } from '@atxp/client';
+import { Logger, Currency, AccountId, PaymentIdentifier, Destination } from '@atxp/common';
+import { WalletClient, PublicActions } from "viem";
+type ExtendedWalletClient = WalletClient & PublicActions;
+export declare class BasePaymentMaker implements PaymentMaker {
+    protected signingClient: ExtendedWalletClient;
+    protected logger: Logger;
+    constructor(baseRPCUrl: string, walletClient: WalletClient, logger?: Logger);
+    getSourceAddress(_params: {
+        amount: BigNumber;
+        currency: Currency;
+        receiver: string;
+        memo: string;
+    }): string;
+    generateJWT({ paymentRequestId, codeChallenge, accountId }: {
+        paymentRequestId: string;
+        codeChallenge: string;
+        accountId?: AccountId | null;
+    }): Promise<string>;
+    makePayment(destinations: Destination[], _memo: string, _paymentRequestId?: string): Promise<PaymentIdentifier | null>;
+}
+export {};
+//# sourceMappingURL=basePaymentMaker.d.ts.map

package/dist/cache.d.ts

@@ -0,0 +1,19 @@
+import { SpendPermission } from './types.js';
+import { Hex } from '@atxp/client';
+import { type ICache, JsonCache, BrowserCache, MemoryCache } from '@atxp/common';
+/**
+ * Stored permission data structure
+ */
+export interface Intermediary {
+    /** Ephemeral wallet private key */
+    privateKey: Hex;
+    /** Spend permission from Base */
+    permission: SpendPermission;
+}
+/**
+ * Type-safe cache wrapper for permission data
+ */
+export declare class IntermediaryCache extends JsonCache<Intermediary> {
+}
+export { type ICache, BrowserCache, MemoryCache };
+//# sourceMappingURL=cache.d.ts.map

package/dist/mainWalletPaymentMaker.d.ts

@@ -0,0 +1,30 @@
+import BigNumber from 'bignumber.js';
+import { Logger, Currency, PaymentMaker, AccountId, PaymentIdentifier, Destination } from '@atxp/common';
+export type MainWalletProvider = {
+    request: (params: {
+        method: string;
+        params?: any[];
+    }) => Promise<any>;
+};
+export declare class MainWalletPaymentMaker implements PaymentMaker {
+    private walletAddress;
+    private provider;
+    private logger;
+    private chainId;
+    private usdcAddress;
+    constructor(walletAddress: string, provider: MainWalletProvider, logger?: Logger, chainId?: number);
+    getSourceAddress(_params: {
+        amount: BigNumber;
+        currency: Currency;
+        receiver: string;
+        memo: string;
+    }): string;
+    generateJWT(payload: {
+        paymentRequestId: string;
+        codeChallenge: string;
+        accountId?: AccountId | null;
+    }): Promise<string>;
+    makePayment(destinations: Destination[], _memo: string, _paymentRequestId?: string): Promise<PaymentIdentifier | null>;
+    private waitForTransactionConfirmations;
+}
+//# sourceMappingURL=mainWalletPaymentMaker.d.ts.map

package/dist/smartWalletHelpers.d.ts

@@ -0,0 +1,19 @@
+import { type Account, type Address, type Hex } from 'viem';
+import { type BundlerClient, type SmartAccount } from 'viem/account-abstraction';
+export interface EphemeralSmartWallet {
+    address: Address;
+    client: BundlerClient;
+    account: SmartAccount;
+    signer: Account;
+}
+/**
+ * Creates an ephemeral smart wallet with paymaster support.
+ *
+ * Uses Alchemy infrastructure if ALCHEMY_API_KEY and ALCHEMY_GAS_POLICY_ID
+ * environment variables are set, otherwise falls back to Coinbase.
+ *
+ * @param privateKey - Private key for the wallet signer
+ * @param chainId - Chain ID (defaults to 8453 for Base mainnet, can be 84532 for Base Sepolia)
+ */
+export declare function toEphemeralSmartWallet(privateKey: Hex, chainId?: number): Promise<EphemeralSmartWallet>;
+//# sourceMappingURL=smartWalletHelpers.d.ts.map

package/dist/spendPermissionShim.d.ts

@@ -0,0 +1,19 @@
+import { Eip1193Provider, SpendPermission } from "./types.js";
+export declare function requestSpendPermission(params: {
+    account: string;
+    spender: string;
+    token: string;
+    chainId: number;
+    allowance: bigint;
+    periodInDays: number;
+    provider: Eip1193Provider;
+}): Promise<SpendPermission>;
+export declare function prepareSpendCallData(params: {
+    permission: SpendPermission;
+    amount: bigint;
+}): Promise<{
+    to: string;
+    data: string;
+    value: bigint;
+}[]>;
+//# sourceMappingURL=spendPermissionShim.d.ts.map

package/dist/testHelpers.d.ts

@@ -0,0 +1,79 @@
+import type { SpendPermission } from './types.js';
+import type { EphemeralSmartWallet } from './smartWalletHelpers.js';
+import type { Address } from 'viem';
+export declare const TEST_WALLET_ADDRESS: Address;
+export declare const TEST_SMART_WALLET_ADDRESS: Address;
+export declare const TEST_RECEIVER_ADDRESS: Address;
+export declare const TEST_PRIVATE_KEY: `0x${string}`;
+export declare const TEST_PAYMASTER_URL = "https://api.developer.coinbase.com/rpc/v1/base/snPdXqIzOGhRkGNJvEHM5bl9Hm3yRO3m";
+export declare const TEST_BUNDLER_URL = "https://api.developer.coinbase.com/rpc/v1/base";
+export declare function mockProvider({ request }?: {
+    request?: import("vitest").Mock<import("@vitest/spy").Procedure> | undefined;
+}): {
+    request: import("vitest").Mock<import("@vitest/spy").Procedure>;
+};
+export declare function mockSpendPermission({ signature, account, spender, token, allowance, // 10 USDC
+period, // 7 days
+start, end, salt, extraData, chainId }?: {
+    signature?: `0x${string}` | undefined;
+    account?: `0x${string}` | undefined;
+    spender?: `0x${string}` | undefined;
+    token?: string | undefined;
+    allowance?: string | undefined;
+    period?: number | undefined;
+    start?: number | undefined;
+    end?: number | undefined;
+    salt?: string | undefined;
+    extraData?: `0x${string}` | undefined;
+    chainId?: 8453 | undefined;
+}): SpendPermission;
+export declare function removeTimestamps<T extends Record<string, any>>(obj: T): T;
+export declare function expectTimestampAround(timestamp: number, expectedOffset?: number, tolerance?: number): void;
+export declare function mockExpiredSpendPermission(overrides?: {}): SpendPermission;
+export declare function mockSmartAccount({ address, signMessage }?: {
+    address?: `0x${string}` | undefined;
+    signMessage?: import("vitest").Mock<import("@vitest/spy").Procedure> | undefined;
+}): any;
+export declare function mockBundlerClient({ sendUserOperation, waitForUserOperationReceipt, waitForTransactionReceipt }?: {
+    sendUserOperation?: import("vitest").Mock<import("@vitest/spy").Procedure> | undefined;
+    waitForUserOperationReceipt?: import("vitest").Mock<import("@vitest/spy").Procedure> | undefined;
+    waitForTransactionReceipt?: import("vitest").Mock<import("@vitest/spy").Procedure> | undefined;
+}): any;
+export declare function mockFailedBundlerClient({ failureType }?: {
+    failureType?: string | undefined;
+}): any;
+export declare function mockEphemeralSmartWallet({ address, account, client, privateKey }?: {
+    address?: `0x${string}` | undefined;
+    account?: any;
+    client?: any;
+    privateKey?: `0x${string}` | undefined;
+}): EphemeralSmartWallet;
+export declare function mockSpendCalls({ calls }?: {
+    calls?: {
+        to: string;
+        data: string;
+        value: string;
+    }[] | undefined;
+}): {
+    to: string;
+    data: string;
+    value: string;
+}[];
+export declare function setupInitializationMocks({ provider, smartAccount, bundlerClient, spendPermission, ephemeralWallet }?: {
+    provider?: {
+        request: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    } | undefined;
+    smartAccount?: any;
+    bundlerClient?: any;
+    spendPermission?: SpendPermission | undefined;
+    ephemeralWallet?: EphemeralSmartWallet | undefined;
+}): Promise<any>;
+export declare function setupPaymentMocks({ spendCalls }?: {
+    spendCalls?: {
+        to: string;
+        data: string;
+        value: string;
+    }[] | undefined;
+}): Promise<any>;
+export declare function getCacheKey(walletAddress: string): string;
+//# sourceMappingURL=testHelpers.d.ts.map

package/dist/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Represents a spending permission with limits
+ */
+export type SpendPermission = {
+    /** UTC timestamp for when the permission was granted */
+    createdAt?: number;
+    /** Hash of the permission in hex format */
+    permissionHash?: string;
+    /** Cryptographic signature in hex format */
+    signature: string;
+    /** Chain ID */
+    chainId?: number;
+    /** The permission details */
+    permission: {
+        /** Wallet address of the account */
+        account: string;
+        /** Address of the contract/entity allowed to spend */
+        spender: string;
+        /** Address of the token being spent */
+        token: string;
+        /** Maximum amount allowed as base 10 numeric string */
+        allowance: string;
+        /** Time period in seconds */
+        period: number;
+        /** Start time in unix seconds */
+        start: number;
+        /** Expiration time in unix seconds */
+        end: number;
+        /** Salt as base 10 numeric string */
+        salt: string;
+        /** Additional data in hex format */
+        extraData: string;
+    };
+};
+export type Eip1193Provider = {
+    request: (params: {
+        method: string;
+        params?: unknown[];
+    }) => Promise<unknown>;
+};
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atxp/base",
-  "version": "0.10.5",
+  "version": "0.10.6",
   "description": "ATXP for Base Mini Apps",
   "license": "MIT",
   "repository": {
@@ -34,8 +34,8 @@
   },
   "dependencies": {
     "@account-kit/infra": "^4.81.3",
-    "@atxp/client": "0.10.5",
-    "@atxp/common": "0.10.5",
+    "@atxp/client": "0.10.6",
+    "@atxp/common": "0.10.6",
     "bignumber.js": "^9.3.0",
     "viem": "^2.34.0"
   },