@moon-x/core 0.2.0

package/dist/lib/index.d.ts

@@ -0,0 +1,410 @@
+export { C as CachedAssertion, c as clearParentAssertCache, g as generatePasskeyUserId, a as getAssertCacheTtlMs, r as readParentAssertCache, s as setAssertCacheTtlMs, w as withClearOnFailure, b as writeParentAssertCache } from '../passkey-cache-B9PT3AWX.js';
+export { a as PasskeyFormFactor, P as PasskeyMetadata, b as PasskeyMetadataInput, f as formatPasskeyLabel, r as resolvePasskeyMetadata } from '../passkey-metadata-QqFF2SWQ.js';
+import { C as Chain } from '../chain-C9dvKXUY.js';
+import { SiweMessage } from 'siwe';
+import { Connection, PublicKey } from '@solana/web3.js';
+
+/**
+ * Tiny in-memory store for the email currently mid-OTP-flow.
+ * Singleton — the SDK creates exactly one and uses it to remember the
+ * email between `sendCode` and `loginWithCode`.
+ */
+declare class AuthenticationState {
+    private email;
+    setEmail(email: string): void;
+    getEmail(): string | null;
+    clearEmail(): void;
+    clear(): void;
+}
+declare const authState: AuthenticationState;
+
+/**
+ * Sanitize user data to only include public profile information.
+ * Removes session-related fields to match the response from verifyIdToken.
+ *
+ * @param userData - Raw user data that may contain session information
+ * @returns Public user object safe for provider state
+ */
+declare function sanitizeUserData(userData: any): any;
+
+/**
+ * Verify ID token with MoonKey API and retrieve user info.
+ */
+interface VerifyIdTokenResponse {
+    success: boolean;
+    user?: any;
+    error?: string;
+    statusCode?: number;
+}
+declare const verifyIdToken: (publishableKey: string, idToken: string) => Promise<VerifyIdTokenResponse>;
+
+declare const fromB64url: (b64url: string) => Uint8Array;
+declare const toB64url: (bytes: Uint8Array) => string;
+
+/**
+ * Chain utilities for MoonKey
+ */
+
+/**
+ * Set a custom RPC URL for a chain
+ * @param chain - The chain to configure
+ * @param rpcUrl - The custom RPC URL
+ * @returns A new chain object with the custom RPC URL
+ */
+declare function setChainRpcUrl(chain: Chain, rpcUrl: string): Chain;
+/**
+ * Get the RPC URL for a chain
+ * @param chain - The chain to get the RPC URL for
+ * @returns The HTTP RPC URL
+ */
+declare function getRpcUrl(chain: Chain): string;
+/**
+ * Call `eth_maxPriorityFeePerGas` against an EVM RPC. Returns the
+ * chain's current recommended priority-fee (tip) as a bigint (wei).
+ *
+ * Asking the chain itself sidesteps per-chain network-enforced tip
+ * floors — Polygon, for example, rejects txs below 25 gwei with
+ * `gas tip cap below minimum`.
+ *
+ * Not all RPCs expose this method; callers should treat a thrown
+ * error as "use a fallback".
+ */
+declare function getEvmMaxPriorityFeePerGas(rpcUrl: string): Promise<bigint>;
+/**
+ * Call `eth_gasPrice` against an EVM RPC. Returns the chain's current
+ * legacy gas price as a bigint (wei). Used by useSendTransaction to
+ * size sensible EIP-1559 maxFeePerGas / maxPriorityFeePerGas values
+ * per chain — without this, hardcoded mainnet defaults (22 gwei) blow
+ * past the balance check on L2s where real prices are sub-gwei.
+ */
+declare function getEvmGasPrice(rpcUrl: string): Promise<bigint>;
+/**
+ * Call `eth_estimateGas` against an EVM RPC for the given tx. Used by
+ * useSendTransaction to fill in `gas` when the caller doesn't provide
+ * it. Throws on RPC error / would-revert; the caller is expected to
+ * fall back to a generous default.
+ */
+declare function estimateEvmGas(rpcUrl: string, tx: {
+    from: string;
+    to?: string;
+    data?: string;
+    value?: string | number | bigint;
+}): Promise<bigint>;
+/**
+ * Call `eth_getTransactionCount` with `pending` block tag against an
+ * EVM RPC. Returns the next nonce a wallet should use, including any
+ * txs the user has already broadcast but that haven't been mined yet.
+ *
+ * Used by useSendTransaction to fill `nonce` when the caller doesn't
+ * supply one. Critical for back-to-back sends (approve → swap, etc.)
+ * — without this the downstream serializer leaves nonce undefined and
+ * viem defaults it to 0, so any tx after the wallet's first lands as
+ * `nonce too low: next nonce N, tx nonce 0` at the RPC.
+ *
+ * Reading from the same `rpcUrl` we'll later broadcast against keeps
+ * the read and write internally consistent — separate viem public
+ * clients elsewhere can hit different load-balanced nodes and return
+ * a count that's a block stale relative to the broadcast endpoint.
+ */
+declare function getEvmNonce(rpcUrl: string, address: string): Promise<number>;
+/**
+ * Estimate the user's pre-flight native-fee reserve for a swap on
+ * this chain: `gas units × eth_gasPrice × bufferBps / 10000`, returned
+ * in human units (ETH / POL / BNB — all 18-decimal natives).
+ *
+ * The default 1.5x cushion mirrors the SDK's max-fee auto-fill so the
+ * reserve covers `balance >= value + gas × maxFeePerGas` even when
+ * gas drifts between estimation and inclusion. Reads `eth_gasPrice`
+ * from the same RPC the SDK broadcasts to.
+ */
+declare function estimateEvmGasReserve(rpcUrl: string, chainId: number, opts?: {
+    gasUnits?: bigint;
+    bufferBps?: number;
+}): Promise<number>;
+/**
+ * Find a chain by its ID
+ * @param chains - Array of chains to search
+ * @param chainId - The chain ID to find
+ * @returns The matching chain or undefined
+ */
+declare function getChainById(chains: Chain[], chainId: number): Chain | undefined;
+/**
+ * Check if a chain is supported
+ * @param chains - Array of supported chains
+ * @param chainId - The chain ID to check
+ * @returns True if the chain is supported
+ */
+declare function isChainSupported(chains: Chain[], chainId: number): boolean;
+/**
+ * Validate chain configuration
+ * Throws an error if configuration is invalid
+ */
+declare function validateChainConfig(config: {
+    defaultChain?: Chain;
+    supportedChains?: Chain[];
+}): void;
+/**
+ * Get the default chain from config
+ * If no defaultChain is set but supportedChains is set, returns the first supported chain
+ */
+declare function getDefaultChain(config: {
+    defaultChain?: Chain;
+    supportedChains?: Chain[];
+}): Chain | undefined;
+
+interface EthereumSiweMessageProps {
+    nonce: string;
+    domain: string;
+    address: string;
+    uri?: string;
+    version?: string;
+    chainId?: number;
+    statement?: string;
+    issuedAt?: string;
+    expirationTime?: string;
+    notBefore?: string;
+    requestId?: string;
+    resources?: string[];
+}
+interface ManualSiweMessageProps {
+    nonce: string;
+    domain: string;
+    address: string;
+    uri?: string;
+    version?: string;
+    chainId?: number;
+    statement?: string;
+    issuedAt?: string;
+    walletName?: string;
+}
+declare class EthereumSiweMessage {
+    private siweMessage;
+    constructor({ nonce, domain, address, uri, version, chainId, statement, issuedAt, expirationTime, notBefore, requestId, resources }: EthereumSiweMessageProps);
+    prepareMessage(): string;
+    getMessage(): SiweMessage;
+}
+declare function createManualSiweMessage({ nonce, domain, address, uri, version, chainId, statement, issuedAt, walletName }: ManualSiweMessageProps): string;
+
+/** Loose input transaction — accepts every shape callers throw at it. */
+interface EvmTransactionInput {
+    to?: string;
+    value?: string | number | bigint;
+    nonce?: string | number | bigint;
+    gasLimit?: string | number | bigint;
+    gas?: string | number | bigint;
+    gasPrice?: string | number | bigint;
+    data?: string;
+    chainId?: number;
+    type?: number | "legacy" | "eip2930" | "eip1559";
+    maxPriorityFeePerGas?: string | number | bigint;
+    maxFeePerGas?: string | number | bigint;
+}
+/** Minimal wallet shape `tx-prep` needs (avoids reaching for full PublicWallet). */
+interface EvmTxPrepWallet {
+    public_address: string;
+    chainId?: number;
+}
+interface ChainResolutionInput {
+    /** Pull from the input transaction's `chainId` if the caller was explicit. */
+    requestedChainId?: number;
+    /** Wallet's bound chain, if any. */
+    walletChainId?: number;
+    supportedChains?: Chain[];
+    defaultChain?: Chain;
+    /**
+     * When true, reject if requestedChainId is not in supportedChains.
+     * Sign-only paths leave this false (best-effort fallback to default).
+     * Send paths set it true so a Base tx never silently broadcasts to mainnet.
+     */
+    strict?: boolean;
+}
+/**
+ * Resolve which chain to use for the operation.
+ *
+ * Priority:
+ *   1. `requestedChainId` from the transaction (caller is explicit).
+ *   2. `walletChainId` from the wallet's bound chain.
+ *   3. `defaultChain` from provider config.
+ *
+ * Under `strict: true`, an explicit `requestedChainId` outside the
+ * configured `supportedChains` throws — sending a Base tx through a
+ * mainnet RPC would otherwise silently land on the wrong chain. Sign-
+ * only flows (where there's no broadcast) leave strict off so the
+ * fallback to defaultChain is allowed.
+ */
+declare function resolveEvmChain({ requestedChainId, walletChainId, supportedChains, defaultChain, strict, }: ChainResolutionInput): Chain;
+/**
+ * Sign-path prep. Converts an input transaction (string or object) into
+ * the serialized RLP string the iframe-side signer expects. Handles
+ * value/fee parsing (bigint, hex, decimal-ether) and gas-type branching.
+ *
+ * No RPC calls — caller can sign now and broadcast later. Returns the
+ * resolved chain too so the hook can stash it if needed.
+ */
+declare function prepareEvmSignTransaction({ transaction, wallet, supportedChains, defaultChain, }: {
+    transaction: string | EvmTransactionInput;
+    wallet: EvmTxPrepWallet;
+    supportedChains?: Chain[];
+    defaultChain?: Chain;
+}): Promise<{
+    serializedTransaction: string;
+    chain: Chain | undefined;
+}>;
+/**
+ * Send-path prep. Resolves the broadcast chain + RPC URL, then
+ * auto-fills missing nonce, gas, and EIP-1559 fee fields from the
+ * chain itself. Returns the prepared transaction object (NOT
+ * serialized — the iframe-side signer re-serializes after signing)
+ * along with the chain and RPC URL.
+ *
+ * Auto-fill behavior:
+ *   - nonce: `eth_getTransactionCount(addr, "pending")`. Critical for
+ *     back-to-back sends; without it viem defaults to nonce=0 and the
+ *     second tx of any session is rejected as "nonce too low."
+ *   - gas: `eth_estimateGas` with a 20% safety buffer; falls back to
+ *     800k if estimation fails (would-revert tx, RPC hiccup) so the
+ *     user gets a real on-chain failure rather than "intrinsic gas too
+ *     low" at the mempool.
+ *   - EIP-1559 fees: `eth_gasPrice` + `eth_maxPriorityFeePerGas`. Tip
+ *     gets a 20% bump for inclusion safety; maxFee floors at tip + 1
+ *     wei so the chain doesn't reject `maxFee < tip`. Emits hex (wei)
+ *     because the downstream serializer treats plain decimal strings
+ *     as gwei.
+ *
+ * RPC hiccups are swallowed deliberately: leave the field unset and
+ * let the downstream serializer handle it. The caller gets a clearer
+ * error from the chain than a silent stuck tx.
+ */
+declare function prepareEvmSendTransaction({ transaction, wallet, supportedChains, defaultChain, }: {
+    transaction: EvmTransactionInput;
+    wallet: EvmTxPrepWallet;
+    supportedChains?: Chain[];
+    defaultChain?: Chain;
+}): Promise<{
+    transaction: EvmTransactionInput;
+    rpcUrl: string;
+    chain: Chain;
+}>;
+
+interface SiwsMessageProps {
+    nonce: string;
+    domain: string;
+    address: string;
+    uri?: string;
+    version?: string;
+    chainId?: string;
+    statement?: string;
+    issuedAt?: string;
+    expirationTime?: string;
+    notBefore?: string;
+    requestId?: string;
+    resources?: string[];
+    message?: string;
+    signature?: string;
+}
+declare class SiwsMessage {
+    nonce: string;
+    domain: string;
+    address: string;
+    uri?: string;
+    version?: string;
+    chainId?: string;
+    statement?: string;
+    issuedAt?: string;
+    expirationTime?: string;
+    notBefore?: string;
+    requestId?: string;
+    resources?: string[];
+    message?: string;
+    signature?: string;
+    constructor({ nonce, domain, address, uri, version, chainId, statement, issuedAt, expirationTime, notBefore, requestId, resources, message, signature }: SiwsMessageProps);
+    prepareBasic(): Uint8Array;
+    prepareAdvanced(): Uint8Array;
+    token(signature: Uint8Array): Promise<string>;
+    decode(token: string): SiwsMessage;
+    validate(): Promise<boolean>;
+}
+
+interface DetailedInstruction {
+    type: string;
+    details: Record<string, any>;
+}
+declare class SolanaTransactionParser {
+    private logs;
+    private transaction?;
+    private instructions;
+    private connection?;
+    private userPublicKey?;
+    constructor(logs: string[], base64Transaction?: string, connection?: Connection, userPublicKey?: PublicKey);
+    parse(): Promise<DetailedInstruction[]>;
+    private parseInstruction;
+    private parseGenericInstruction;
+    private parseComputeBudget;
+    private parseAssociatedToken;
+    private parseSystemProgram;
+    private parseTokenProgram;
+    private parseJupiterBasic;
+    private parseTokenAccountData;
+    private formatTokenAmount;
+    private formatSOL;
+    private truncate;
+    getInstructions(): DetailedInstruction[];
+    getInstructionsByType(type: string): DetailedInstruction[];
+}
+declare function getInstructionsForHTML(base64Transaction: string, logs: string[], connection?: Connection, userPublicKey?: PublicKey): Promise<Array<{
+    id: string;
+    type: string;
+    title: string;
+    details: Array<{
+        label: string;
+        value: string;
+    }>;
+}>>;
+declare function getTransferInfoFromInstructions(base64Transaction: string, logs: string[], solPriceUsd?: string): Promise<Array<{
+    amount: string;
+    destination: string;
+    type: 'SOL' | 'Token';
+    usdValue?: string;
+}>>;
+declare function getSOLTransfersFromInstructions(base64Transaction: string, logs: string[], solPriceUsd?: string): Promise<Array<{
+    amount: string;
+    destination: string;
+    lamports: string;
+    usdValue?: string;
+}>>;
+
+interface BuildUrlConfig {
+    publishableKey: string;
+    config?: {
+        appearance?: {
+            hideClose?: boolean;
+        };
+    };
+}
+declare const buildUrl: (baseUrl: string, sdkConfig: BuildUrlConfig, enableCaptcha?: boolean, captchaSitekey?: string) => string;
+
+declare const DEFAULT_AUTH_URL = "https://iframe.moonx-dev.com";
+
+declare const serializeEthereumTransaction: (transaction: any) => Promise<string>;
+declare const broadcastEthereumRaw: (rpcUrl: string, signedSerialized: string) => Promise<string>;
+declare const broadcastSolanaSigned: (rpcUrl: string, signedBase58: string) => Promise<string>;
+
+/**
+ * Convert any wire representation of a byte array back into Uint8Array.
+ * Pass-through for actual `Uint8Array` and regular `number[]`. Used
+ * defensively at every transport boundary that may have stripped typed
+ * arrays.
+ */
+declare const arrayLikeToBytes: (value: unknown) => Uint8Array;
+/**
+ * Decode a base58 string (or pass-through bytes) into Uint8Array.
+ * Solana sign-transaction handlers return base58-encoded signed bytes;
+ * sign-message handlers return raw Uint8Array. This helper handles
+ * both shapes so callers don't have to branch.
+ *
+ * `bs58` is an optional peer of `@moon-x/core`; we lazy-import to keep
+ * the cold-start lean for consumers who don't use Solana flows.
+ */
+declare const bs58ToBytes: (value: unknown) => Promise<Uint8Array>;
+
+export { type BuildUrlConfig, DEFAULT_AUTH_URL, EthereumSiweMessage, type EthereumSiweMessageProps, type EvmTransactionInput, type EvmTxPrepWallet, type ManualSiweMessageProps, SiwsMessage, SolanaTransactionParser, type VerifyIdTokenResponse, arrayLikeToBytes, authState, broadcastEthereumRaw, broadcastSolanaSigned, bs58ToBytes, buildUrl, createManualSiweMessage, estimateEvmGas, estimateEvmGasReserve, fromB64url, getChainById, getDefaultChain, getEvmGasPrice, getEvmMaxPriorityFeePerGas, getEvmNonce, getInstructionsForHTML, getRpcUrl, getSOLTransfersFromInstructions, getTransferInfoFromInstructions, isChainSupported, prepareEvmSendTransaction, prepareEvmSignTransaction, resolveEvmChain, sanitizeUserData, serializeEthereumTransaction, setChainRpcUrl, toB64url, validateChainConfig, verifyIdToken };