@aastar/sdk 0.20.5 → 0.20.6

package/dist/tier-router-DLiMxs0h.d.ts

@@ -0,0 +1,321 @@
+interface PasskeyRegistrationParams {
+    email: string;
+    username: string;
+    password?: string;
+}
+interface PasskeyAuthenticationParams {
+    email?: string;
+}
+interface TransactionVerificationParams {
+    to: string;
+    value?: string;
+    data?: string;
+}
+interface PasskeyInfo {
+    credentialId: string;
+    publicKey: string;
+    counter: number;
+    deviceType: string;
+    createdAt: string;
+}
+interface BeginRegistrationResponse {
+    challenge: string;
+    rp: {
+        name: string;
+        id: string;
+    };
+    user: {
+        id: string;
+        name: string;
+        displayName: string;
+    };
+    pubKeyCredParams: any[];
+    timeout?: number;
+    authenticatorSelection?: any;
+    attestation?: string;
+}
+interface BeginAuthenticationResponse {
+    challenge: string;
+    timeout?: number;
+    rpId?: string;
+    allowCredentials?: any[];
+    userVerification?: string;
+}
+interface BeginTransactionVerificationResponse extends BeginAuthenticationResponse {
+    userOpHash: string;
+}
+
+declare class PasskeyManager {
+    private api;
+    constructor(baseURL: string, tokenProvider?: () => string | null);
+    /**
+     * Complete Passkey Registration Flow
+     */
+    register(params: PasskeyRegistrationParams): Promise<{
+        user: any;
+        token: string;
+        passkey: PasskeyInfo;
+    }>;
+    /**
+     * Complete Passkey Login/Authentication Flow
+     */
+    authenticate(params?: PasskeyAuthenticationParams): Promise<{
+        user: any;
+        token: string;
+    }>;
+    /**
+     * Verify a transaction (Sign UserOpHash) with Passkey
+     * Returns the verification credential needed for the transaction
+     */
+    verifyTransaction(params: TransactionVerificationParams): Promise<any>;
+    /**
+     * Add a new device (Passkey) to existing account
+     */
+    addDevice(params: {
+        email: string;
+        password?: string;
+    }): Promise<PasskeyInfo>;
+}
+
+interface BLSNode {
+    index?: number;
+    nodeId: string;
+    nodeName: string;
+    apiEndpoint: string;
+    status: "active" | "inactive";
+    publicKey?: string;
+    lastSeen?: Date;
+}
+interface BLSSignatureData {
+    nodeIds: string[];
+    signatures?: string[];
+    publicKeys?: string[];
+    signature: string;
+    messagePoint: string;
+    aaAddress: string;
+    aaSignature: string;
+    messagePointSignature: string;
+    aggregatedSignature?: string;
+}
+interface BLSConfig {
+    seedNodes: string[];
+    discoveryTimeout?: number;
+}
+/**
+ * Data for cumulative Tier 2 signature (algId 0x04): P256 + BLS.
+ */
+interface CumulativeT2SignatureData {
+    p256Signature: string;
+    nodeIds: string[];
+    blsSignature: string;
+    messagePoint: string;
+    messagePointSignature: string;
+}
+/**
+ * Data for cumulative Tier 3 signature (algId 0x05): P256 + BLS + Guardian.
+ */
+interface CumulativeT3SignatureData extends CumulativeT2SignatureData {
+    guardianSignature: string;
+}
+
+declare class BLSManager {
+    private config;
+    constructor(config: BLSConfig);
+    /**
+     * Discover available BLS nodes from seed nodes (Gossip network)
+     */
+    getAvailableNodes(): Promise<BLSNode[]>;
+    /**
+     * Helper to pack the full signature for ERC-4337 UserOp
+     * Format: [nodeIdsLength][nodeIds...][blsSignature][messagePoint][aaSignature][messagePointSignature]
+     */
+    packSignature(data: BLSSignatureData): string;
+    /**
+     * Calculate the MessagePoint G2 point for a given message (UserOpHash)
+     */
+    generateMessagePoint(message: string | Uint8Array): Promise<string>;
+    /**
+     * Encode G2 Point to bytes for EIP-2537 format
+     */
+    private encodeG2Point;
+    private hexToBytes;
+    /**
+     * Pack cumulative Tier 2 signature (algId 0x04): P256 + BLS.
+     *
+     * Format:
+     *   [algId=0x04 (1)] [P256 r (32)] [P256 s (32)]
+     *   [nodeIdsLength (32)] [nodeIds (N×32)]
+     *   [blsAggregateSig (256)] [messagePoint (256)]
+     *   [messagePointECDSA (65)]
+     */
+    packCumulativeT2Signature(data: CumulativeT2SignatureData): string;
+    /**
+     * Pack cumulative Tier 3 signature (algId 0x05): P256 + BLS + Guardian.
+     *
+     * Format:
+     *   [algId=0x05 (1)] [P256 r (32)] [P256 s (32)]
+     *   [nodeIdsLength (32)] [nodeIds (N×32)]
+     *   [blsAggregateSig (256)] [messagePoint (256)]
+     *   [messagePointECDSA (65)] [guardianECDSA (65)]
+     */
+    packCumulativeT3Signature(data: CumulativeT3SignatureData): string;
+    /**
+     * Request signature from a single node
+     */
+    requestNodeSignature(node: BLSNode, message: string): Promise<{
+        signature: string;
+        publicKey: string;
+    }>;
+    /**
+     * Request aggregation from a node
+     */
+    aggregateSignatures(node: BLSNode, signatures: string[]): Promise<string>;
+}
+
+interface YAAAConfig {
+    /** Backend API URL (e.g., https://api.yetanotheraa.com) */
+    apiURL: string;
+    /** Function to get the current auth token (JWT) */
+    tokenProvider?: () => string | null;
+    /** BLS Configuration */
+    bls: BLSConfig;
+}
+declare class YAAAClient {
+    private config;
+    readonly passkey: PasskeyManager;
+    readonly bls: BLSManager;
+    constructor(config: YAAAConfig);
+}
+
+declare class CryptoUtil {
+    private static readonly ALGORITHM;
+    private static readonly KEY_LENGTH;
+    private static readonly IV_LENGTH;
+    private static readonly TAG_LENGTH;
+    static encrypt(text: string, secretKey: string): string;
+    static decrypt(encryptedData: string, secretKey: string): string;
+    static generateSecretKey(): string;
+}
+
+interface UserOperation {
+    sender: string;
+    nonce: bigint | string;
+    initCode: string;
+    callData: string;
+    callGasLimit: bigint | string;
+    verificationGasLimit: bigint | string;
+    preVerificationGas: bigint | string;
+    maxFeePerGas: bigint | string;
+    maxPriorityFeePerGas: bigint | string;
+    paymasterAndData: string;
+    signature: string;
+}
+interface PackedUserOperation {
+    sender: string;
+    nonce: bigint | string;
+    initCode: string;
+    callData: string;
+    accountGasLimits: string;
+    preVerificationGas: bigint | string;
+    gasFees: string;
+    paymasterAndData: string;
+    signature: string;
+}
+interface GasEstimate {
+    callGasLimit: string;
+    verificationGasLimit: string;
+    preVerificationGas: string;
+}
+
+declare class ERC4337Utils {
+    static packAccountGasLimits(verificationGasLimit: bigint | string, callGasLimit: bigint | string): string;
+    static unpackAccountGasLimits(accountGasLimits: string): {
+        verificationGasLimit: bigint;
+        callGasLimit: bigint;
+    };
+    static packGasFees(maxPriorityFeePerGas: bigint | string, maxFeePerGas: bigint | string): string;
+    static unpackGasFees(gasFees: string): {
+        maxPriorityFeePerGas: bigint;
+        maxFeePerGas: bigint;
+    };
+    static packUserOperation(userOp: any): PackedUserOperation;
+    static unpackUserOperation(packedOp: PackedUserOperation): any;
+}
+
+declare class UserOpBuilder {
+    private static DEFAULT_VERIFICATION_GAS_LIMIT;
+    private static DEFAULT_PRE_VERIFICATION_GAS;
+    private static DEFAULT_MAX_FEE_PER_GAS;
+    private static DEFAULT_MAX_PRIORITY_FEE_PER_GAS;
+    constructor();
+    /**
+     * Build specific parts of a UserOperation
+     * Note: Full construction often requires chain interaction (nonce, gas price),
+     * which typically happens in the application layer or via a Provider wrapper.
+     * This builder focuses on formatting and structure.
+     */
+    buildUserOp(params: {
+        sender: string;
+        callData: string;
+        nonce?: bigint;
+        initCode?: string;
+        callGasLimit?: bigint;
+        verificationGasLimit?: bigint;
+        preVerificationGas?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        paymasterAndData?: string;
+        signature?: string;
+    }): Promise<UserOperation>;
+    /**
+     * Hash the UserOperation for signing (ERC-4337 v0.7)
+     */
+    getUserOpHash(userOp: PackedUserOperation, entryPoint: string, chainId: number): string;
+}
+
+declare const ALG_BLS = 1;
+declare const ALG_ECDSA = 2;
+declare const ALG_P256 = 3;
+declare const ALG_CUMULATIVE_T2 = 4;
+declare const ALG_CUMULATIVE_T3 = 5;
+type AlgId = typeof ALG_BLS | typeof ALG_ECDSA | typeof ALG_P256 | typeof ALG_CUMULATIVE_T2 | typeof ALG_CUMULATIVE_T3;
+type TierLevel = 1 | 2 | 3;
+interface TierConfig {
+    /** Max value for Tier 1 (single ECDSA/Passkey). 0 = no enforcement. */
+    tier1Limit: bigint;
+    /** Max value for Tier 2 (P256 + BLS). 0 = no enforcement. */
+    tier2Limit: bigint;
+}
+interface GuardStatus {
+    hasGuard: boolean;
+    guardAddress: string;
+    dailyLimit: bigint;
+    dailyRemaining: bigint;
+}
+interface PreCheckResult {
+    ok: boolean;
+    errors: string[];
+    tier: TierLevel;
+    algId: AlgId;
+}
+
+/**
+ * Determine the required tier for a given transaction value.
+ *
+ * - Tier 1: value <= tier1Limit — single ECDSA or P256 passkey
+ * - Tier 2: tier1Limit < value <= tier2Limit — P256 + BLS aggregate
+ * - Tier 3: value > tier2Limit — P256 + BLS + Guardian ECDSA
+ *
+ * If both limits are 0 (no enforcement), always returns Tier 1.
+ */
+declare function resolveTier(value: bigint, config: TierConfig): TierLevel;
+/**
+ * Get the algorithm ID to use for a given tier.
+ *
+ * - Tier 1: ALG_ECDSA (0x02) — raw 65-byte ECDSA, no prefix needed
+ * - Tier 2: ALG_CUMULATIVE_T2 (0x04) — P256 + BLS
+ * - Tier 3: ALG_CUMULATIVE_T3 (0x05) — P256 + BLS + Guardian
+ */
+declare function algIdForTier(tier: TierLevel): AlgId;
+
+export { ALG_BLS as A, type BLSConfig as B, CryptoUtil as C, ERC4337Utils as E, type GasEstimate as G, type PackedUserOperation as P, type TierConfig as T, UserOpBuilder as U, YAAAClient as Y, ALG_CUMULATIVE_T2 as a, ALG_CUMULATIVE_T3 as b, ALG_ECDSA as c, ALG_P256 as d, type AlgId as e, BLSManager as f, type BLSNode as g, type BLSSignatureData as h, type BeginAuthenticationResponse as i, type BeginRegistrationResponse as j, type BeginTransactionVerificationResponse as k, type CumulativeT2SignatureData as l, type CumulativeT3SignatureData as m, type GuardStatus as n, type PasskeyAuthenticationParams as o, type PasskeyInfo as p, PasskeyManager as q, type PasskeyRegistrationParams as r, type PreCheckResult as s, type TierLevel as t, type TransactionVerificationParams as u, type UserOperation as v, type YAAAConfig as w, algIdForTier as x, resolveTier as y };

package/dist/tokens.d.ts

@@ -1 +1,64 @@
-export * from '@aastar/tokens';
+import { Address, Hash } from 'viem';
+import { P as PublicClient, W as WalletClient } from './doc-types-471vSmPO.js';
+
+declare class FinanceClient {
+    private publicClient;
+    private walletClient;
+    /**
+     * Initialize FinanceClient
+     * @param publicClient The public client for queries
+     * @param walletClient The wallet client for transactions
+     */
+    constructor(publicClient: PublicClient, walletClient: WalletClient);
+    /** @deprecated Use instance methods instead */
+    static depositToPaymaster(wallet: WalletClient, paymaster: Address, amount: bigint): Promise<`0x${string}`>;
+    /** @deprecated Use instance methods instead */
+    static depositViaTransferAndCall(wallet: WalletClient, token: Address, paymaster: Address, amount: bigint): Promise<`0x${string}`>;
+    /** @deprecated Use instance methods instead */
+    static stakeGToken(wallet: WalletClient, stakingAddr: Address, amount: bigint): Promise<`0x${string}`>;
+    /** @deprecated Use instance methods instead */
+    static withdrawProtocolRevenue(wallet: WalletClient, paymaster: Address, to: Address, amount: bigint): Promise<`0x${string}`>;
+    /** @deprecated Use instance methods instead */
+    static depositToEntryPoint(wallet: WalletClient, entryPoint: Address, paymaster: Address, amount: bigint): Promise<`0x${string}`>;
+    /** @deprecated Use instance methods instead */
+    static getEntryPointBalance(client: any, entryPoint: Address, account: Address): Promise<bigint>;
+    /** @deprecated Use instance methods instead */
+    static operatorDeposit(wallet: WalletClient, paymaster: Address, amount: bigint): Promise<`0x${string}`>;
+    /** @deprecated Use instance methods instead */
+    static operatorNotifyDeposit(wallet: WalletClient, paymaster: Address, amount: bigint): Promise<`0x${string}`>;
+    /**
+     * Get GToken balance
+     */
+    getGTokenBalance(address: Address): Promise<bigint>;
+    /**
+     * Get aPNTs balance
+     */
+    getAPNTsBalance(address: Address): Promise<bigint>;
+    /**
+     * One-step stake: Approve (if needed) + Stake
+     *
+     * @param amount Amount of GToken to stake
+     * @returns Transaction hash of the stake action
+     */
+    approveAndStake(amount: bigint): Promise<Hash>;
+    /**
+     * Get circulating supply (total - locked)
+     */
+    getCirculatingSupply(): Promise<{
+        total: bigint;
+        locked: bigint;
+        circulating: bigint;
+    }>;
+    /**
+     * Get comprehensive tokenomics data
+     */
+    getTokenomicsOverview(): Promise<{
+        totalSupply: bigint;
+        totalStaked: bigint;
+        totalBurned: bigint;
+        circulatingSupply: bigint;
+        stakingRatio: number;
+    }>;
+}
+
+export { FinanceClient };

package/dist/tokens.js

@@ -1,6 +1,6 @@
-export { FinanceClient } from './chunk-QJT4IOIS.js';
-import './chunk-TIH7D4FQ.js';
-import './chunk-NRH56SAJ.js';
+export { FinanceClient } from './chunk-KDH3UPKD.js';
+import './chunk-6QYXGMCR.js';
+import './chunk-G3UJC4EL.js';
 import './chunk-PZ5AY32C.js';
 //# sourceMappingURL=tokens.js.map
 //# sourceMappingURL=tokens.js.map