@atxp/base 0.2.22 → 0.4.0

package/dist/index.d.ts

@@ -1,6 +1,157 @@
-export { BaseAppAccount } from './baseAppAccount.js';
-export { BaseAppPaymentMaker } from './baseAppPaymentMaker.js';
-export { MainWalletPaymentMaker, type MainWalletProvider } from './mainWalletPaymentMaker.js';
-export type { SpendPermission } from './types.js';
-export { type IStorage, type Intermediary as StoredPermissionData, IntermediaryStorage as PermissionStorage, BrowserStorage, MemoryStorage } from './storage.js';
-//# sourceMappingURL=index.d.ts.map
+import { PaymentMaker, Hex, Account as Account$1 } from '@atxp/client';
+import BigNumber$1 from 'bignumber.js';
+import { Logger, Currency } from '@atxp/common';
+import { Address, Account } from 'viem';
+import { BundlerClient, SmartAccount } from 'viem/account-abstraction';
+
+type MainWalletProvider = {
+    request: (params: {
+        method: string;
+        params?: any[];
+    }) => Promise<any>;
+};
+declare class MainWalletPaymentMaker implements PaymentMaker {
+    private walletAddress;
+    private provider;
+    private logger;
+    constructor(walletAddress: string, provider: MainWalletProvider, logger?: Logger);
+    generateJWT(payload: {
+        paymentRequestId: string;
+        codeChallenge: string;
+    }): Promise<string>;
+    makePayment(amount: BigNumber$1, currency: Currency, receiver: string, _reason: string): Promise<string>;
+    private waitForTransactionConfirmations;
+}
+
+/**
+ * Represents a spending permission with limits
+ */
+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;
+    };
+};
+
+/**
+ * Stored permission data structure
+ */
+interface Intermediary {
+    /** Ephemeral wallet private key */
+    privateKey: Hex;
+    /** Spend permission from Base */
+    permission: SpendPermission;
+}
+/**
+ * Storage interface for abstracting storage mechanisms
+ * This allows for easy mocking in tests and potential future
+ * support for different storage backends (e.g., React Native AsyncStorage)
+ */
+interface IStorage<T = string> {
+    get(key: string): T | null;
+    set(key: string, value: T): void;
+    delete(key: string): void;
+}
+/**
+ * Type-safe storage wrapper for permission data
+ */
+declare class IntermediaryStorage {
+    private storage;
+    constructor(storage: IStorage<string>);
+    get(key: string): Intermediary | null;
+    set(key: string, data: Intermediary): void;
+    delete(key: string): void;
+}
+/**
+ * Browser localStorage implementation
+ */
+declare class BrowserStorage implements IStorage<string> {
+    private isAvailable;
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    delete(key: string): void;
+}
+/**
+ * In-memory storage implementation for testing
+ */
+declare class MemoryStorage implements IStorage<string> {
+    private store;
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    delete(key: string): void;
+    clear(): void;
+}
+
+interface EphemeralSmartWallet {
+    address: Address;
+    client: BundlerClient;
+    account: SmartAccount;
+    signer: Account;
+}
+
+declare class BaseAppAccount implements Account$1 {
+    accountId: string;
+    paymentMakers: {
+        [key: string]: PaymentMaker;
+    };
+    private static toStorageKey;
+    static initialize(config: {
+        walletAddress: string;
+        apiKey: string;
+        appName: string;
+        useEphemeralWallet?: boolean;
+        allowance?: bigint;
+        periodInDays?: number;
+        storage?: IStorage<string>;
+        logger?: Logger;
+    }): Promise<BaseAppAccount>;
+    private static loadSavedWalletAndPermission;
+    private static deploySmartWallet;
+    constructor(spendPermission: SpendPermission | null, ephemeralSmartWallet: EphemeralSmartWallet | null, logger?: Logger, mainWalletAddress?: string, provider?: MainWalletProvider);
+    /**
+     * Dynamically import the appropriate spend-permission module based on environment.
+     * Uses browser version as requestSpendPermission only exists there.
+     * Throws error if used in server-side environment.
+     */
+    static clearAllStoredData(userWalletAddress: string, storage?: IStorage<string>): void;
+}
+
+declare class BaseAppPaymentMaker implements PaymentMaker {
+    private logger;
+    private spendPermission;
+    private smartWallet;
+    constructor(spendPermission: SpendPermission, smartWallet: EphemeralSmartWallet, logger?: Logger);
+    generateJWT({ paymentRequestId, codeChallenge }: {
+        paymentRequestId: string;
+        codeChallenge: string;
+    }): Promise<string>;
+    makePayment(amount: BigNumber, currency: Currency, receiver: string, memo: string): Promise<string>;
+}
+
+export { BaseAppAccount, BaseAppPaymentMaker, BrowserStorage, MainWalletPaymentMaker, MemoryStorage, IntermediaryStorage as PermissionStorage };
+export type { IStorage, MainWalletProvider, SpendPermission, Intermediary as StoredPermissionData };