@ic-pay/icpay-sdk 1.3.61

package/dist/index.js

@@ -0,0 +1,1211 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IcpayWallet = exports.IcpayError = exports.Icpay = void 0;
+const errors_1 = require("./errors");
+const events_1 = require("./events");
+const wallet_1 = require("./wallet");
+const axios_1 = __importDefault(require("axios"));
+const agent_1 = require("@dfinity/agent");
+const icpay_canister_backend_did_js_1 = require("./declarations/icpay_canister_backend/icpay_canister_backend.did.js");
+const ledger_did_js_1 = require("./declarations/icrc-ledger/ledger.did.js");
+const principal_1 = require("@dfinity/principal");
+const utils_1 = require("./utils");
+const protected_1 = require("./protected");
+class Icpay {
+    constructor(config) {
+        this.privateApiClient = null;
+        this.connectedWallet = null;
+        this.icpayCanisterId = null;
+        this.accountInfoCache = null;
+        this.verifiedLedgersCache = { data: null, timestamp: 0 };
+        this.config = {
+            environment: 'production',
+            apiUrl: 'https://api.icpay.org',
+            debug: false,
+            enableEvents: false,
+            awaitServerNotification: false,
+            ...config
+        };
+        (0, utils_1.debugLog)(this.config.debug || false, 'constructor', { config: this.config });
+        // Validate authentication configuration
+        if (!this.config.publishableKey && !this.config.secretKey) {
+            throw new Error('Either publishableKey or secretKey must be provided');
+        }
+        this.icHost = config.icHost || 'https://ic0.app';
+        this.connectedWallet = config.connectedWallet || null;
+        this.actorProvider = config.actorProvider;
+        (0, utils_1.debugLog)(this.config.debug || false, 'constructor', { connectedWallet: this.connectedWallet, actorProvider: this.actorProvider });
+        // Initialize wallet with connected wallet if provided
+        this.wallet = new wallet_1.IcpayWallet({ connectedWallet: this.connectedWallet });
+        // Initialize event center
+        this.events = new events_1.IcpayEventCenter();
+        (0, utils_1.debugLog)(this.config.debug || false, 'constructor', { connectedWallet: this.connectedWallet });
+        // Create public API client (always available)
+        this.publicApiClient = axios_1.default.create({
+            baseURL: this.config.apiUrl,
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.config.publishableKey || this.config.secretKey}`
+            }
+        });
+        (0, utils_1.debugLog)(this.config.debug || false, 'publicApiClient created', this.publicApiClient);
+        // Create private API client (only if secret key is provided)
+        if (this.config.secretKey) {
+            const privateHeaders = {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.config.secretKey}`
+            };
+            this.privateApiClient = axios_1.default.create({
+                baseURL: this.config.apiUrl,
+                headers: privateHeaders
+            });
+        }
+        (0, utils_1.debugLog)(this.config.debug || false, 'privateApiClient created', this.privateApiClient);
+        // Initialize protected API
+        this.protected = (0, protected_1.createProtectedApi)({
+            privateApiClient: this.privateApiClient,
+            emitStart: (name, args) => this.emitMethodStart(name, args),
+            emitSuccess: (name, result) => this.emitMethodSuccess(name, result),
+            emitError: (name, error) => this.emitMethodError(name, error),
+        });
+    }
+    // ===== Event API (no Lit required) =====
+    on(type, listener) {
+        return this.events.on(type, listener);
+    }
+    off(type, listener) {
+        this.events.off(type, listener);
+    }
+    emit(type, detail) {
+        if (this.config.enableEvents) {
+            this.events.emit(type, detail);
+        }
+    }
+    addEventListener(type, listener) {
+        this.events.addEventListener(type, listener);
+    }
+    removeEventListener(type, listener) {
+        this.events.removeEventListener(type, listener);
+    }
+    dispatchEvent(event) {
+        return this.events.dispatchEvent(event);
+    }
+    emitError(error) {
+        const err = error instanceof errors_1.IcpayError
+            ? error
+            : new errors_1.IcpayError({
+                code: errors_1.ICPAY_ERROR_CODES.UNKNOWN_ERROR,
+                message: (error && (error.message || error.toString())) || 'Unknown error',
+                details: error
+            });
+        if (this.config.enableEvents) {
+            this.events.emit('icpay-sdk-error', err);
+        }
+    }
+    emitMethodStart(name, args) {
+        if (this.config.enableEvents) {
+            this.events.emit('icpay-sdk-method-start', { name, args });
+        }
+    }
+    emitMethodSuccess(name, result) {
+        if (this.config.enableEvents) {
+            this.events.emit('icpay-sdk-method-success', { name, result });
+        }
+    }
+    emitMethodError(name, error) {
+        if (this.config.enableEvents) {
+            this.events.emit('icpay-sdk-method-error', { name, error });
+        }
+        this.emitError(error);
+    }
+    /**
+     * Check if SDK has secret key for private operations
+     */
+    hasSecretKey() {
+        return !!this.config.secretKey && !!this.privateApiClient;
+    }
+    /**
+     * Require secret key for private operations
+     */
+    requireSecretKey(methodName) {
+        if (!this.hasSecretKey()) {
+            throw new errors_1.IcpayError({
+                code: 'SECRET_KEY_REQUIRED',
+                message: `${methodName} requires secret key authentication. Please provide secretKey and accountId in configuration.`
+            });
+        }
+    }
+    /**
+     * Get account information (public method - limited data)
+     */
+    async getAccountInfo() {
+        this.emitMethodStart('getAccountInfo');
+        try {
+            const response = await this.publicApiClient.get('/sdk/public/account');
+            const account = response.data;
+            const result = {
+                id: account.id,
+                name: account.name,
+                isActive: account.isActive,
+                isLive: account.isLive,
+                accountCanisterId: account.accountCanisterId,
+                icpayCanisterId: account.icpayCanisterId,
+            };
+            this.emitMethodSuccess('getAccountInfo', result);
+            return result;
+        }
+        catch (error) {
+            const err = new errors_1.IcpayError({
+                code: 'ACCOUNT_INFO_FETCH_FAILED',
+                message: 'Failed to fetch account information',
+                details: error
+            });
+            this.emitMethodError('getAccountInfo', err);
+            throw err;
+        }
+    }
+    /**
+     * Get verified ledgers (public method)
+     */
+    async getVerifiedLedgers() {
+        this.emitMethodStart('getVerifiedLedgers');
+        const now = Date.now();
+        const cacheAge = 60 * 60 * 1000; // 60 minutes cache
+        // Return cached data if it's still fresh
+        if (this.verifiedLedgersCache.data && (now - this.verifiedLedgersCache.timestamp) < cacheAge) {
+            return this.verifiedLedgersCache.data;
+        }
+        try {
+            const response = await this.publicApiClient.get('/sdk/public/ledgers/verified');
+            const ledgers = response.data.map((ledger) => ({
+                id: ledger.id,
+                name: ledger.name,
+                symbol: ledger.symbol,
+                canisterId: ledger.canisterId,
+                decimals: ledger.decimals,
+                logoUrl: ledger.logoUrl,
+                verified: ledger.verified,
+                fee: ledger.fee,
+                currentPrice: ledger.currentPrice ?? null,
+                lastPriceUpdate: ledger.lastPriceUpdate ?? null,
+            }));
+            // Update cache
+            this.verifiedLedgersCache = {
+                data: ledgers,
+                timestamp: now
+            };
+            this.emitMethodSuccess('getVerifiedLedgers', { count: ledgers.length });
+            return ledgers;
+        }
+        catch (error) {
+            const err = new errors_1.IcpayError({
+                code: 'VERIFIED_LEDGERS_FETCH_FAILED',
+                message: 'Failed to fetch verified ledgers',
+                details: error
+            });
+            this.emitMethodError('getVerifiedLedgers', err);
+            throw err;
+        }
+    }
+    /**
+     * Get a verified ledger's canister ID by its symbol (public helper)
+     */
+    async getLedgerCanisterIdBySymbol(symbol) {
+        this.emitMethodStart('getLedgerCanisterIdBySymbol', { symbol });
+        if (!symbol || typeof symbol !== 'string') {
+            throw new errors_1.IcpayError({
+                code: 'INVALID_LEDGER_SYMBOL',
+                message: 'Symbol must be a non-empty string'
+            });
+        }
+        const ledgers = await this.getVerifiedLedgers();
+        const match = ledgers.find(l => l.symbol.toLowerCase() === symbol.toLowerCase());
+        if (!match) {
+            throw new errors_1.IcpayError({
+                code: 'LEDGER_SYMBOL_NOT_FOUND',
+                message: `Verified ledger with symbol ${symbol} not found`
+            });
+        }
+        const result = match.canisterId;
+        this.emitMethodSuccess('getLedgerCanisterIdBySymbol', { symbol, canisterId: result });
+        return result;
+    }
+    /**
+     * Trigger transaction sync from canister (public method)
+     *
+     * This method attempts to sync a transaction directly from the canister to the API database
+     * and returns the result immediately. This is useful when you know a transaction exists
+     * in the canister but it's not showing up in the API database yet.
+     */
+    async triggerTransactionSync(canisterTransactionId) {
+        this.emitMethodStart('triggerTransactionSync', { canisterTransactionId });
+        try {
+            const response = await this.publicApiClient.get(`/sdk/public/transactions/${canisterTransactionId}/sync`);
+            this.emitMethodSuccess('triggerTransactionSync', response.data);
+            return response.data;
+        }
+        catch (error) {
+            const err = new errors_1.IcpayError({
+                code: 'TRANSACTION_SYNC_TRIGGER_FAILED',
+                message: 'Failed to trigger transaction sync from canister',
+                details: error
+            });
+            this.emitMethodError('triggerTransactionSync', err);
+            throw err;
+        }
+    }
+    /**
+     * Fetch and cache account info, including icpayCanisterId (public method)
+     */
+    async fetchAccountInfo() {
+        if (this.accountInfoCache) {
+            this.icpayCanisterId = this.accountInfoCache.icpayCanisterId.toString();
+            return this.accountInfoCache;
+        }
+        try {
+            // Use public endpoint to get account info
+            const response = await this.publicApiClient.get('/sdk/public/account');
+            this.accountInfoCache = response.data;
+            if (response.data && response.data.icpayCanisterId) {
+                this.icpayCanisterId = response.data.icpayCanisterId.toString();
+            }
+            return this.accountInfoCache;
+        }
+        catch (error) {
+            throw new errors_1.IcpayError({
+                code: 'ACCOUNT_INFO_FETCH_FAILED',
+                message: 'Failed to fetch account information',
+                details: error
+            });
+        }
+    }
+    /**
+     * Show wallet connection modal
+     */
+    async showWalletModal() {
+        this.emitMethodStart('showWalletModal');
+        try {
+            const res = await this.wallet.showConnectionModal();
+            this.emitMethodSuccess('showWalletModal', res);
+            return res;
+        }
+        catch (error) {
+            this.emitMethodError('showWalletModal', error);
+            throw error;
+        }
+    }
+    /**
+     * Connect to a specific wallet provider
+     */
+    async connectWallet(providerId) {
+        this.emitMethodStart('connectWallet', { providerId });
+        try {
+            const res = await this.wallet.connectToProvider(providerId);
+            this.emitMethodSuccess('connectWallet', res);
+            return res;
+        }
+        catch (error) {
+            this.emitMethodError('connectWallet', error);
+            throw error;
+        }
+    }
+    /**
+     * Get available wallet providers
+     */
+    getWalletProviders() {
+        this.emitMethodStart('getWalletProviders');
+        const res = this.wallet.getProviders();
+        this.emitMethodSuccess('getWalletProviders', { count: Array.isArray(res) ? res.length : undefined });
+        return res;
+    }
+    /**
+     * Check if a wallet provider is available
+     */
+    isWalletProviderAvailable(providerId) {
+        this.emitMethodStart('isWalletProviderAvailable', { providerId });
+        const res = this.wallet.isProviderAvailable(providerId);
+        this.emitMethodSuccess('isWalletProviderAvailable', { providerId, available: res });
+        return res;
+    }
+    /**
+     * Get the connected wallet's account address
+     */
+    getAccountAddress() {
+        this.emitMethodStart('getAccountAddress');
+        const res = this.wallet.getAccountAddress();
+        this.emitMethodSuccess('getAccountAddress', { accountAddress: res });
+        return res;
+    }
+    /**
+     * Get balance for a specific ledger canister
+     */
+    async getLedgerBalance(ledgerCanisterId) {
+        this.emitMethodStart('getLedgerBalance', { ledgerCanisterId });
+        try {
+            // Extract principal from connected wallet
+            let principal = null;
+            if (this.connectedWallet) {
+                if (this.connectedWallet.owner) {
+                    principal = this.connectedWallet.owner;
+                }
+                else if (this.connectedWallet.principal) {
+                    principal = this.connectedWallet.principal;
+                }
+            }
+            if (!principal) {
+                throw new Error('No principal available for balance check');
+            }
+            // Convert string principal to Principal object
+            const principalObj = principal_1.Principal.fromText(principal);
+            // Create anonymous actor for balance queries (no signing required)
+            const agent = new agent_1.HttpAgent({ host: this.icHost });
+            const actor = agent_1.Actor.createActor(ledger_did_js_1.idlFactory, { agent, canisterId: ledgerCanisterId });
+            // Get the balance of the user's account
+            const result = await actor.icrc1_balance_of({
+                owner: principalObj,
+                subaccount: []
+            });
+            const out = BigInt(result);
+            this.emitMethodSuccess('getLedgerBalance', { ledgerCanisterId, balance: out.toString() });
+            return out;
+        }
+        catch (error) {
+            this.emitMethodError('getLedgerBalance', error);
+            throw error;
+        }
+    }
+    /**
+     * Create a simple memo with account canister ID as bytes
+     * Example: 1 => Uint8Array([1]), 2 => Uint8Array([2])
+     */
+    createMemoWithAccountCanisterId(accountCanisterId) {
+        // Convert number to bytes (simple approach)
+        const bytes = [];
+        let num = accountCanisterId;
+        // Handle 0 case
+        if (num === 0) {
+            return new Uint8Array([0]);
+        }
+        // Convert to bytes (little-endian)
+        while (num > 0) {
+            bytes.push(num & 0xff);
+            num = Math.floor(num / 256);
+        }
+        return new Uint8Array(bytes);
+    }
+    createPackedMemo(accountCanisterId, intentCode) {
+        let memo = (BigInt(accountCanisterId >>> 0) << BigInt(32)) | BigInt(intentCode >>> 0);
+        if (memo === BigInt(0))
+            return new Uint8Array([0]);
+        const out = [];
+        while (memo > BigInt(0)) {
+            out.push(Number(memo & BigInt(0xff)));
+            memo >>= BigInt(8);
+        }
+        return new Uint8Array(out);
+    }
+    /**
+     * Send funds to a specific canister/ledger (public method)
+     * This is now a real transaction
+     */
+    async sendFunds(request) {
+        this.emitMethodStart('sendFunds', { request: { ...request, amount: typeof request.amount === 'string' ? request.amount : String(request.amount) } });
+        try {
+            (0, utils_1.debugLog)(this.config.debug || false, 'sendFunds start', { request });
+            // Fetch account info to get accountCanisterId if not provided
+            let accountCanisterId = request.accountCanisterId;
+            if (!accountCanisterId) {
+                (0, utils_1.debugLog)(this.config.debug || false, 'fetching account info for accountCanisterId');
+                const accountInfo = await this.getAccountInfo();
+                accountCanisterId = accountInfo.accountCanisterId.toString();
+                (0, utils_1.debugLog)(this.config.debug || false, 'accountCanisterId resolved', { accountCanisterId });
+            }
+            // Always use icpayCanisterId as toPrincipal
+            if (!this.icpayCanisterId) {
+                await this.fetchAccountInfo();
+            }
+            const ledgerCanisterId = request.ledgerCanisterId;
+            let toPrincipal = this.icpayCanisterId;
+            const amount = typeof request.amount === 'string' ? BigInt(request.amount) : BigInt(request.amount);
+            const host = this.icHost;
+            let memo = undefined;
+            // Check balance before sending
+            const requiredAmount = amount;
+            (0, utils_1.debugLog)(this.config.debug || false, 'checking balance', { ledgerCanisterId, requiredAmount: requiredAmount.toString() });
+            // Helper function to make amounts human-readable
+            const formatAmount = (amount, decimals = 8, symbol = '') => {
+                const divisor = BigInt(10 ** decimals);
+                const whole = amount / divisor;
+                const fraction = amount % divisor;
+                const fractionStr = fraction.toString().padStart(decimals, '0').replace(/0+$/, '');
+                return `${whole}${fractionStr ? '.' + fractionStr : ''} ${symbol}`.trim();
+            };
+            // Check if user has sufficient balance based on ledger type
+            try {
+                // Get the actual balance from the specific ledger (works for all ICRC ledgers including ICP)
+                const actualBalance = await this.getLedgerBalance(ledgerCanisterId);
+                if (actualBalance < requiredAmount) {
+                    const requiredFormatted = formatAmount(requiredAmount, 8, 'tokens');
+                    const availableFormatted = formatAmount(actualBalance, 8, 'tokens');
+                    throw (0, errors_1.createBalanceError)(requiredFormatted, availableFormatted, {
+                        required: requiredAmount,
+                        available: actualBalance,
+                        ledgerCanisterId
+                    });
+                }
+                (0, utils_1.debugLog)(this.config.debug || false, 'balance ok', { actualBalance: actualBalance.toString() });
+            }
+            catch (balanceError) {
+                // If we can't fetch the specific ledger balance, fall back to the old logic
+                throw new errors_1.IcpayError({
+                    code: 'INSUFFICIENT_BALANCE',
+                    message: 'Insufficient balance',
+                    details: { required: requiredAmount, available: 0 }
+                });
+            }
+            // 1) Create payment intent via API
+            let paymentIntentId = null;
+            let paymentIntentCode = null;
+            try {
+                (0, utils_1.debugLog)(this.config.debug || false, 'creating payment intent');
+                // Get the expected sender principal from connected wallet
+                const expectedSenderPrincipal = this.connectedWallet?.owner || this.connectedWallet?.principal?.toString();
+                if (!expectedSenderPrincipal) {
+                    throw new errors_1.IcpayError({
+                        code: errors_1.ICPAY_ERROR_CODES.WALLET_NOT_CONNECTED,
+                        message: 'Wallet must be connected to create payment intent',
+                        details: { connectedWallet: this.connectedWallet },
+                        retryable: false,
+                        userAction: 'Connect your wallet first'
+                    });
+                }
+                const intentResp = await this.publicApiClient.post('/sdk/public/payments/intents', {
+                    amount: request.amount,
+                    ledgerCanisterId,
+                    expectedSenderPrincipal,
+                    metadata: request.metadata || {},
+                });
+                paymentIntentId = intentResp.data?.paymentIntent?.id || null;
+                paymentIntentCode = intentResp.data?.paymentIntent?.intentCode ?? null;
+                (0, utils_1.debugLog)(this.config.debug || false, 'payment intent created', { paymentIntentId, paymentIntentCode, expectedSenderPrincipal });
+                // Emit transaction created event
+                if (paymentIntentId) {
+                    this.emit('icpay-sdk-transaction-created', {
+                        paymentIntentId,
+                        amount: request.amount,
+                        ledgerCanisterId,
+                        expectedSenderPrincipal
+                    });
+                }
+            }
+            catch (e) {
+                // Do not proceed without a payment intent
+                // Throw a standardized error so integrators can handle it consistently
+                const err = new errors_1.IcpayError({
+                    code: errors_1.ICPAY_ERROR_CODES.API_ERROR,
+                    message: 'Failed to create payment intent. Please try again.',
+                    details: e,
+                    retryable: true,
+                    userAction: 'Try again'
+                });
+                this.emitError(err);
+                throw err;
+            }
+            // Build packed memo if possible
+            try {
+                const acctIdNum = parseInt(accountCanisterId);
+                if (!isNaN(acctIdNum) && paymentIntentCode != null) {
+                    memo = this.createPackedMemo(acctIdNum, Number(paymentIntentCode));
+                    (0, utils_1.debugLog)(this.config.debug || false, 'built packed memo', { accountCanisterId: acctIdNum, paymentIntentCode });
+                }
+                else if (!isNaN(acctIdNum)) {
+                    memo = this.createMemoWithAccountCanisterId(acctIdNum);
+                    (0, utils_1.debugLog)(this.config.debug || false, 'built legacy memo', { accountCanisterId: acctIdNum });
+                }
+                (0, utils_1.debugLog)(this.config.debug || false, 'memo', { memo });
+            }
+            catch { }
+            let transferResult;
+            if (ledgerCanisterId === 'ryjl3-tyaaa-aaaaa-aaaba-cai') {
+                // ICP Ledger: use ICRC-1 transfer (ICP ledger supports ICRC-1)
+                (0, utils_1.debugLog)(this.config.debug || false, 'sending ICRC-1 transfer (ICP)');
+                transferResult = await this.sendFundsToLedger(ledgerCanisterId, toPrincipal, amount, memo, host);
+            }
+            else {
+                // ICRC-1 ledgers: use principal directly
+                (0, utils_1.debugLog)(this.config.debug || false, 'sending ICRC-1 transfer');
+                transferResult = await this.sendFundsToLedger(ledgerCanisterId, toPrincipal, amount, memo, host);
+            }
+            // Assume transferResult returns a block index or transaction id
+            const blockIndex = transferResult?.Ok?.toString() || transferResult?.blockIndex?.toString() || `temp-${Date.now()}`;
+            (0, utils_1.debugLog)(this.config.debug || false, 'transfer result', { blockIndex });
+            // First, notify the canister about the ledger transaction
+            let canisterTransactionId;
+            let notifyStatus = null;
+            try {
+                (0, utils_1.debugLog)(this.config.debug || false, 'notifying canister about ledger tx');
+                const notifyRes = await this.notifyLedgerTransaction(this.icpayCanisterId, ledgerCanisterId, BigInt(blockIndex));
+                // notify returns { id, status, amount }
+                if (typeof notifyRes === 'string') {
+                    canisterTransactionId = parseInt(notifyRes, 10);
+                }
+                else {
+                    canisterTransactionId = parseInt(notifyRes.id, 10);
+                    notifyStatus = notifyRes;
+                }
+                (0, utils_1.debugLog)(this.config.debug || false, 'canister notified', { canisterTransactionId });
+            }
+            catch (notifyError) {
+                canisterTransactionId = parseInt(blockIndex, 10);
+                (0, utils_1.debugLog)(this.config.debug || false, 'notify failed, using blockIndex as tx id', { canisterTransactionId });
+            }
+            // Poll for transaction status until completed
+            // Use the transaction ID returned by the notification, not the block index
+            let status = null;
+            if (notifyStatus && notifyStatus.status) {
+                status = { status: notifyStatus.status };
+            }
+            else {
+                try {
+                    (0, utils_1.debugLog)(this.config.debug || false, 'polling transaction status (public)', { canisterTransactionId });
+                    status = await this.pollTransactionStatus(this.icpayCanisterId, canisterTransactionId, accountCanisterId, Number(blockIndex), 2000, 30);
+                    (0, utils_1.debugLog)(this.config.debug || false, 'poll done', { status });
+                }
+                catch (e) {
+                    status = { status: 'pending' };
+                    (0, utils_1.debugLog)(this.config.debug || false, 'poll failed, falling back to pending');
+                }
+            }
+            // Extract the status string from the transaction object
+            let statusString = 'pending';
+            if (status) {
+                if (typeof status === 'object' && status.status) {
+                    // Handle variant status like {Completed: null}
+                    if (typeof status.status === 'object') {
+                        const statusKeys = Object.keys(status.status);
+                        if (statusKeys.length > 0) {
+                            const rawStatus = statusKeys[0].toLowerCase();
+                            if (rawStatus === 'completed' || rawStatus === 'failed') {
+                                statusString = rawStatus;
+                            }
+                        }
+                    }
+                    else {
+                        const rawStatus = status.status;
+                        if (rawStatus === 'completed' || rawStatus === 'failed') {
+                            statusString = rawStatus;
+                        }
+                    }
+                }
+            }
+            // 5) Notify API about completion with intent and transaction id
+            // Optionally await based on config.awaitServerNotification
+            let publicNotify = undefined;
+            const notifyApi = async () => {
+                const notifyClient = this.publicApiClient;
+                const notifyPath = '/sdk/public/payments/notify';
+                const maxNotifyAttempts = 5;
+                const notifyDelayMs = 1000;
+                for (let attempt = 1; attempt <= maxNotifyAttempts; attempt++) {
+                    try {
+                        (0, utils_1.debugLog)(this.config.debug || false, 'notifying API about completion', { attempt, notifyPath, paymentIntentId, canisterTransactionId });
+                        const resp = await notifyClient.post(notifyPath, {
+                            paymentIntentId,
+                            canisterTxId: canisterTransactionId,
+                        });
+                        return resp.data;
+                    }
+                    catch (e) {
+                        const status = e?.response?.status;
+                        const data = e?.response?.data;
+                        (0, utils_1.debugLog)(this.config.debug || false, 'API notify attempt failed', { attempt, status, data });
+                        // Proactively trigger a transaction sync if we get not found
+                        try {
+                            await this.triggerTransactionSync(canisterTransactionId);
+                        }
+                        catch { }
+                        if (attempt < maxNotifyAttempts) {
+                            await new Promise(r => setTimeout(r, notifyDelayMs));
+                        }
+                    }
+                }
+                (0, utils_1.debugLog)(this.config.debug || false, 'API notify failed after retries (non-fatal)');
+                return undefined;
+            };
+            if (this.config.awaitServerNotification) {
+                publicNotify = await notifyApi();
+            }
+            else {
+                // fire-and-forget
+                notifyApi()
+                    .then((data) => {
+                    // Optionally emit a success for the async notify step
+                    this.emitMethodSuccess('sendFunds.notifyApi', { paymentIntentId, canisterTransactionId, data });
+                })
+                    .catch((err) => {
+                    this.emitMethodError('sendFunds.notifyApi', err);
+                });
+            }
+            const response = {
+                transactionId: canisterTransactionId,
+                status: statusString,
+                amount: amount.toString(),
+                recipientCanister: ledgerCanisterId,
+                timestamp: new Date(),
+                description: 'Fund transfer',
+                metadata: request.metadata,
+                payment: publicNotify
+            };
+            (0, utils_1.debugLog)(this.config.debug || false, 'sendFunds done', response);
+            if (statusString === 'completed') {
+                this.emit('icpay-sdk-transaction-completed', response);
+            }
+            else if (statusString === 'failed') {
+                this.emit('icpay-sdk-transaction-failed', response);
+            }
+            else {
+                this.emit('icpay-sdk-transaction-updated', response);
+            }
+            this.emitMethodSuccess('sendFunds', response);
+            return response;
+        }
+        catch (error) {
+            if (error instanceof errors_1.IcpayError) {
+                this.emitMethodError('sendFunds', error);
+                throw error;
+            }
+            const err = new errors_1.IcpayError({
+                code: 'TRANSACTION_FAILED',
+                message: 'Failed to send funds',
+                details: error
+            });
+            this.emitMethodError('sendFunds', err);
+            throw err;
+        }
+    }
+    /**
+     * Disconnect from wallet
+     */
+    async disconnectWallet() {
+        return await this.wallet.disconnect();
+    }
+    /**
+     * Check if wallet is connected
+     */
+    isWalletConnected() {
+        return this.wallet.isConnected();
+    }
+    /**
+     * Get the connected wallet provider
+     */
+    getConnectedWalletProvider() {
+        return this.wallet.getConnectedProvider();
+    }
+    /**
+     * Poll for transaction status using anonymous actor (no signature required)
+     */
+    async pollTransactionStatus(canisterId, transactionId, accountCanisterId, indexReceived, intervalMs = 2000, maxAttempts = 30) {
+        this.emitMethodStart('pollTransactionStatus', { canisterId, transactionId, accountCanisterId, indexReceived, intervalMs, maxAttempts });
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                // Use public-only method
+                let status = await this.getTransactionStatusPublic(canisterId, transactionId, indexReceived, accountCanisterId);
+                // If we get an array (unexpected), try the alternative method
+                if (Array.isArray(status) && status.length > 0) {
+                    const transaction = status[0];
+                    if (transaction && typeof transaction === 'object') {
+                        // Check if we have a valid status
+                        if (transaction.status) {
+                            // Check if transaction is completed
+                            const transactionStatus = transaction.status;
+                            if (this.isTransactionCompleted(transactionStatus)) {
+                                return transaction; // Return immediately when completed
+                            }
+                            // If not completed, continue polling
+                        }
+                    }
+                }
+                // If we get null or no valid result, try the alternative method
+                // No secondary fallback to controller-only methods
+                if (status && status.status) {
+                    if (this.isTransactionCompleted(status.status)) {
+                        this.emitMethodSuccess('pollTransactionStatus', { attempt, status });
+                        return status; // Return immediately when completed
+                    }
+                    // If not completed, continue polling
+                }
+                // Check if status is an object with Ok/Err pattern
+                if (status && typeof status === 'object' && (status.Ok || status.Err)) {
+                    this.emitMethodSuccess('pollTransactionStatus', { attempt, status });
+                    return status; // Return immediately when we find a valid status
+                }
+                // Wait before next attempt (unless this is the last attempt)
+                if (attempt < maxAttempts - 1) {
+                    await new Promise(resolve => setTimeout(resolve, intervalMs));
+                }
+            }
+            catch (error) {
+                if (attempt === maxAttempts - 1) {
+                    this.emitMethodError('pollTransactionStatus', error);
+                }
+                // Wait before next attempt
+                if (attempt < maxAttempts - 1) {
+                    await new Promise(resolve => setTimeout(resolve, intervalMs));
+                }
+            }
+        }
+        const err = new Error('Transaction status polling timed out');
+        this.emitMethodError('pollTransactionStatus', err);
+        throw err;
+    }
+    /**
+     * Check if transaction status indicates completion
+     */
+    isTransactionCompleted(status) {
+        if (!status)
+            return false;
+        // Handle variant status like {Completed: null}
+        if (typeof status === 'object') {
+            const statusKeys = Object.keys(status);
+            if (statusKeys.length > 0) {
+                const rawStatus = statusKeys[0].toLowerCase();
+                return rawStatus === 'completed';
+            }
+        }
+        // Handle string status
+        if (typeof status === 'string') {
+            return status.toLowerCase() === 'completed';
+        }
+        return false;
+    }
+    /**
+     * Notify canister about ledger transaction using anonymous actor (no signature required)
+     */
+    async notifyLedgerTransaction(canisterId, ledgerCanisterId, blockIndex) {
+        this.emitMethodStart('notifyLedgerTransaction', { canisterId, ledgerCanisterId, blockIndex: blockIndex.toString() });
+        // Create anonymous actor for canister notifications (no signature required)
+        const agent = new agent_1.HttpAgent({ host: this.icHost });
+        const actor = agent_1.Actor.createActor(icpay_canister_backend_did_js_1.idlFactory, { agent, canisterId });
+        const result = await actor.notify_ledger_transaction({
+            ledger_canister_id: ledgerCanisterId,
+            block_index: blockIndex
+        });
+        if (result && result.Ok) {
+            this.emitMethodSuccess('notifyLedgerTransaction', { result: result.Ok });
+            return result.Ok;
+        }
+        else if (result && result.Err) {
+            const err = new Error(result.Err);
+            this.emitMethodError('notifyLedgerTransaction', err);
+            throw err;
+        }
+        else {
+            const err = new Error('Unexpected canister notify result');
+            this.emitMethodError('notifyLedgerTransaction', err);
+            throw err;
+        }
+    }
+    async getTransactionStatusPublic(canisterId, canisterTransactionId, indexReceived, accountCanisterId) {
+        this.emitMethodStart('getTransactionStatusPublic', { canisterId, canisterTransactionId, indexReceived, accountCanisterId });
+        const agent = new agent_1.HttpAgent({ host: this.icHost });
+        const actor = agent_1.Actor.createActor(icpay_canister_backend_did_js_1.idlFactory, { agent, canisterId });
+        const acctIdNum = parseInt(accountCanisterId);
+        const res = await actor.get_transaction_status_public(acctIdNum, BigInt(canisterTransactionId), [indexReceived]);
+        const result = res || { status: 'pending' };
+        this.emitMethodSuccess('getTransactionStatusPublic', result);
+        return result;
+    }
+    /**
+     * Send funds to a ledger canister using agent-js
+     * Now uses host from config
+     */
+    async sendFundsToLedger(ledgerCanisterId, toPrincipal, amount, memo, host) {
+        this.emitMethodStart('sendFundsToLedger', { ledgerCanisterId, toPrincipal, amount: amount.toString(), hasMemo: !!memo });
+        let actor;
+        if (this.actorProvider) {
+            actor = this.actorProvider(ledgerCanisterId, ledger_did_js_1.idlFactory);
+        }
+        else {
+            const err = new Error('actorProvider is required for sending funds');
+            this.emitMethodError('sendFundsToLedger', err);
+            throw err;
+        }
+        // ICRC-1 transfer
+        const res = await actor.icrc1_transfer({
+            to: { owner: principal_1.Principal.fromText(toPrincipal), subaccount: [] },
+            amount,
+            fee: [], // Always include fee, even if empty
+            memo: memo ? [memo] : [],
+            from_subaccount: [],
+            created_at_time: [],
+        });
+        this.emitMethodSuccess('sendFundsToLedger', res);
+        return res;
+    }
+    /**
+     * Get transaction by ID using get_transactions filter (alternative to get_transaction)
+     */
+    async getTransactionByFilter(transactionId) {
+        this.emitMethodStart('getTransactionByFilter', { transactionId });
+        try {
+            if (!this.icpayCanisterId) {
+                await this.fetchAccountInfo();
+            }
+            // Create anonymous actor for canister queries
+            const agent = new agent_1.HttpAgent({ host: this.icHost });
+            const actor = agent_1.Actor.createActor(icpay_canister_backend_did_js_1.idlFactory, { agent, canisterId: this.icpayCanisterId });
+            // Convert string transaction ID to Nat
+            const transactionIdNat = BigInt(transactionId);
+            // Get all transactions and filter by ID
+            const result = await actor.get_transactions({
+                account_canister_id: [], // Use empty array instead of null
+                ledger_canister_id: [], // Use empty array instead of null
+                from_timestamp: [], // Use empty array instead of null
+                to_timestamp: [], // Use empty array instead of null
+                from_id: [], // Use empty array instead of null
+                status: [], // Use empty array instead of null
+                limit: [], // Use empty array instead of 100 for optional nat32
+                offset: [] // Use empty array instead of 0 for optional nat32
+            });
+            if (result && result.transactions) {
+                const transaction = result.transactions.find((tx) => tx.id.toString() === transactionId.toString());
+                this.emitMethodSuccess('getTransactionByFilter', { found: !!transaction });
+                return transaction;
+            }
+            this.emitMethodSuccess('getTransactionByFilter', { found: false });
+            return null;
+        }
+        catch (error) {
+            this.emitMethodError('getTransactionByFilter', error);
+            throw error;
+        }
+    }
+    // ===== NEW ENHANCED SDK FUNCTIONS =====
+    /**
+     * Get balance for all verified ledgers for the connected wallet (public method)
+     */
+    async getAllLedgerBalances() {
+        this.emitMethodStart('getAllLedgerBalances');
+        try {
+            if (!this.isWalletConnected()) {
+                throw new errors_1.IcpayError({
+                    code: 'WALLET_NOT_CONNECTED',
+                    message: 'Wallet must be connected to fetch balances'
+                });
+            }
+            const verifiedLedgers = await this.getVerifiedLedgers();
+            const balances = [];
+            let totalBalancesUSD = 0;
+            for (const ledger of verifiedLedgers) {
+                try {
+                    const rawBalance = await this.getLedgerBalance(ledger.canisterId);
+                    const formattedBalance = this.formatBalance(rawBalance.toString(), ledger.decimals);
+                    const balance = {
+                        ledgerId: ledger.id,
+                        ledgerName: ledger.name,
+                        ledgerSymbol: ledger.symbol,
+                        canisterId: ledger.canisterId,
+                        balance: rawBalance.toString(),
+                        formattedBalance,
+                        decimals: ledger.decimals,
+                        currentPrice: ledger.currentPrice || undefined,
+                        lastPriceUpdate: ledger.lastPriceUpdate ? new Date(ledger.lastPriceUpdate) : undefined,
+                        lastUpdated: new Date()
+                    };
+                    balances.push(balance);
+                    // Calculate USD value if price is available
+                    if (ledger.currentPrice && rawBalance > 0) {
+                        const humanReadableBalance = parseFloat(formattedBalance);
+                        totalBalancesUSD += humanReadableBalance * ledger.currentPrice;
+                    }
+                }
+                catch (error) {
+                    this.emit('icpay-sdk-method-error', {
+                        name: 'getAllLedgerBalances.getLedgerBalance',
+                        error,
+                        ledgerSymbol: ledger.symbol,
+                        ledgerCanisterId: ledger.canisterId
+                    });
+                    // Continue with other ledgers even if one fails
+                }
+            }
+            const result = {
+                balances,
+                totalBalancesUSD: totalBalancesUSD > 0 ? totalBalancesUSD : undefined,
+                lastUpdated: new Date()
+            };
+            this.emitMethodSuccess('getAllLedgerBalances', { count: balances.length, totalUSD: result.totalBalancesUSD });
+            return result;
+        }
+        catch (error) {
+            const err = new errors_1.IcpayError({
+                code: 'BALANCES_FETCH_FAILED',
+                message: 'Failed to fetch all ledger balances',
+                details: error
+            });
+            this.emitMethodError('getAllLedgerBalances', err);
+            throw err;
+        }
+    }
+    /**
+     * Get balance for a specific ledger by canister ID (public method)
+     */
+    async getSingleLedgerBalance(ledgerCanisterId) {
+        this.emitMethodStart('getSingleLedgerBalance', { ledgerCanisterId });
+        try {
+            if (!this.isWalletConnected()) {
+                throw new errors_1.IcpayError({
+                    code: 'WALLET_NOT_CONNECTED',
+                    message: 'Wallet must be connected to fetch balance'
+                });
+            }
+            // Get ledger info to include price data
+            const verifiedLedgers = await this.getVerifiedLedgers();
+            const ledger = verifiedLedgers.find(l => l.canisterId === ledgerCanisterId);
+            if (!ledger) {
+                throw new errors_1.IcpayError({
+                    code: 'LEDGER_NOT_FOUND',
+                    message: `Ledger with canister ID ${ledgerCanisterId} not found or not verified`
+                });
+            }
+            const rawBalance = await this.getLedgerBalance(ledgerCanisterId);
+            const formattedBalance = this.formatBalance(rawBalance.toString(), ledger.decimals);
+            const result = {
+                ledgerId: ledger.id,
+                ledgerName: ledger.name,
+                ledgerSymbol: ledger.symbol,
+                canisterId: ledger.canisterId,
+                balance: rawBalance.toString(),
+                formattedBalance,
+                decimals: ledger.decimals,
+                currentPrice: ledger.currentPrice || undefined,
+                lastPriceUpdate: ledger.lastPriceUpdate ? new Date(ledger.lastPriceUpdate) : undefined,
+                lastUpdated: new Date()
+            };
+            this.emitMethodSuccess('getSingleLedgerBalance', { ledgerCanisterId, balance: result.balance });
+            return result;
+        }
+        catch (error) {
+            const err = new errors_1.IcpayError({
+                code: 'SINGLE_BALANCE_FETCH_FAILED',
+                message: `Failed to fetch balance for ledger ${ledgerCanisterId}`,
+                details: error
+            });
+            this.emitMethodError('getSingleLedgerBalance', err);
+            throw err;
+        }
+    }
+    /**
+     * Calculate token amount from USD price for a specific ledger (public method)
+     */
+    async calculateTokenAmountFromUSD(request) {
+        this.emitMethodStart('calculateTokenAmountFromUSD', { usdAmount: request.usdAmount, ledgerCanisterId: request.ledgerCanisterId, ledgerSymbol: request.ledgerSymbol });
+        try {
+            const { usdAmount, ledgerCanisterId, ledgerSymbol } = request;
+            if (usdAmount <= 0) {
+                throw new errors_1.IcpayError({
+                    code: 'INVALID_USD_AMOUNT',
+                    message: 'USD amount must be greater than 0'
+                });
+            }
+            // Get ledger info
+            const verifiedLedgers = await this.getVerifiedLedgers();
+            const ledger = verifiedLedgers.find(l => l.canisterId === ledgerCanisterId ||
+                (ledgerSymbol && l.symbol === ledgerSymbol));
+            if (!ledger) {
+                throw new errors_1.IcpayError({
+                    code: 'LEDGER_NOT_FOUND',
+                    message: `Ledger not found for canister ID ${ledgerCanisterId} or symbol ${ledgerSymbol}`
+                });
+            }
+            if (!ledger.currentPrice || ledger.currentPrice <= 0) {
+                throw new errors_1.IcpayError({
+                    code: 'PRICE_NOT_AVAILABLE',
+                    message: `Current price not available for ledger ${ledger.symbol}`
+                });
+            }
+            // Calculate token amount
+            const tokenAmountHuman = usdAmount / ledger.currentPrice;
+            // Convert to smallest unit and truncate decimals to get whole number for blockchain
+            const tokenAmountDecimals = Math.floor(tokenAmountHuman * Math.pow(10, ledger.decimals)).toString();
+            const result = {
+                usdAmount,
+                ledgerCanisterId: ledger.canisterId,
+                ledgerSymbol: ledger.symbol,
+                ledgerName: ledger.name,
+                currentPrice: ledger.currentPrice,
+                priceTimestamp: ledger.lastPriceUpdate ? new Date(ledger.lastPriceUpdate) : new Date(),
+                tokenAmountHuman: tokenAmountHuman.toFixed(ledger.decimals),
+                tokenAmountDecimals,
+                decimals: ledger.decimals
+            };
+            this.emitMethodSuccess('calculateTokenAmountFromUSD', { ledgerCanisterId: result.ledgerCanisterId, tokenAmountDecimals });
+            return result;
+        }
+        catch (error) {
+            const err = new errors_1.IcpayError({
+                code: 'PRICE_CALCULATION_FAILED',
+                message: 'Failed to calculate token amount from USD',
+                details: error
+            });
+            this.emitMethodError('calculateTokenAmountFromUSD', err);
+            throw err;
+        }
+    }
+    /**
+     * Get detailed ledger information including price data (public method)
+     */
+    async getLedgerInfo(ledgerCanisterId) {
+        this.emitMethodStart('getLedgerInfo', { ledgerCanisterId });
+        try {
+            const response = await this.publicApiClient.get(`/sdk/public/ledgers/${ledgerCanisterId}`);
+            const ledger = response.data;
+            const result = {
+                id: ledger.id,
+                name: ledger.name,
+                symbol: ledger.symbol,
+                canisterId: ledger.canisterId,
+                standard: ledger.standard,
+                decimals: ledger.decimals,
+                logoUrl: ledger.logoUrl ?? null,
+                verified: ledger.verified,
+                fee: ledger.fee ?? null,
+                network: ledger.network,
+                description: ledger.description ?? null,
+                lastBlockIndex: ledger.lastBlockIndex ?? null,
+                coingeckoId: ledger.coingeckoId ?? null,
+                currentPrice: ledger.currentPrice ?? null,
+                priceFetchMethod: ledger.priceFetchMethod ?? null,
+                lastPriceUpdate: ledger.lastPriceUpdate ?? null,
+                createdAt: ledger.createdAt,
+                updatedAt: ledger.updatedAt,
+            };
+            this.emitMethodSuccess('getLedgerInfo', { ledgerCanisterId });
+            return result;
+        }
+        catch (error) {
+            const err = new errors_1.IcpayError({
+                code: 'LEDGER_INFO_FETCH_FAILED',
+                message: `Failed to fetch ledger info for ${ledgerCanisterId}`,
+                details: error
+            });
+            this.emitMethodError('getLedgerInfo', err);
+            throw err;
+        }
+    }
+    /**
+     * Send funds from USD to a specific ledger (public method)
+     */
+    async sendFundsUsd(request) {
+        this.emitMethodStart('sendFundsUsd', { request });
+        try {
+            // Convert usdAmount to number if it's a string
+            const usdAmount = typeof request.usdAmount === 'string' ? parseFloat(request.usdAmount) : request.usdAmount;
+            const priceCalculationResult = await this.calculateTokenAmountFromUSD({
+                usdAmount: usdAmount,
+                ledgerCanisterId: request.ledgerCanisterId
+            });
+            const createTransactionRequest = {
+                ledgerCanisterId: request.ledgerCanisterId,
+                amount: priceCalculationResult.tokenAmountDecimals,
+                accountCanisterId: request.accountCanisterId,
+                metadata: request.metadata
+            };
+            const res = await this.sendFunds(createTransactionRequest);
+            this.emitMethodSuccess('sendFundsUsd', res);
+            return res;
+        }
+        catch (error) {
+            if (error instanceof errors_1.IcpayError) {
+                this.emitMethodError('sendFundsUsd', error);
+                throw error;
+            }
+            const err = new errors_1.IcpayError({
+                code: 'SEND_FUNDS_USD_FAILED',
+                message: 'Failed to send funds from USD',
+                details: error
+            });
+            this.emitMethodError('sendFundsUsd', err);
+            throw err;
+        }
+    }
+    /**
+   * Get all ledgers with price information (public method)
+   */
+    async getAllLedgersWithPrices() {
+        this.emitMethodStart('getAllLedgersWithPrices');
+        try {
+            const response = await this.publicApiClient.get('/sdk/public/ledgers/all-with-prices');
+            const result = response.data.map((ledger) => ({
+                id: ledger.id,
+                name: ledger.name,
+                symbol: ledger.symbol,
+                canisterId: ledger.canisterId,
+                standard: ledger.standard,
+                decimals: ledger.decimals,
+                logoUrl: ledger.logoUrl ?? null,
+                verified: ledger.verified,
+                fee: ledger.fee ?? null,
+                network: ledger.network,
+                description: ledger.description ?? null,
+                lastBlockIndex: ledger.lastBlockIndex ?? null,
+                coingeckoId: ledger.coingeckoId ?? null,
+                currentPrice: ledger.currentPrice ?? null,
+                priceFetchMethod: ledger.priceFetchMethod ?? null,
+                lastPriceUpdate: ledger.lastPriceUpdate ?? null,
+                createdAt: ledger.createdAt,
+                updatedAt: ledger.updatedAt,
+            }));
+            this.emitMethodSuccess('getAllLedgersWithPrices', { count: result.length });
+            return result;
+        }
+        catch (error) {
+            const err = new errors_1.IcpayError({
+                code: 'LEDGERS_WITH_PRICES_FETCH_FAILED',
+                message: 'Failed to fetch ledgers with price information',
+                details: error
+            });
+            this.emitMethodError('getAllLedgersWithPrices', err);
+            throw err;
+        }
+    }
+    /**
+     * Utility function to format balance from smallest unit to human readable
+     */
+    formatBalance(balance, decimals) {
+        const balanceNum = parseFloat(balance);
+        const divisor = Math.pow(10, decimals);
+        const whole = Math.floor(balanceNum / divisor);
+        const fraction = balanceNum % divisor;
+        const fractionStr = fraction.toString().padStart(decimals, '0').replace(/0+$/, '');
+        return `${whole}${fractionStr ? '.' + fractionStr : ''}`;
+    }
+}
+exports.Icpay = Icpay;
+// Export types and classes
+__exportStar(require("./types"), exports);
+var errors_2 = require("./errors");
+Object.defineProperty(exports, "IcpayError", { enumerable: true, get: function () { return errors_2.IcpayError; } });
+var wallet_2 = require("./wallet");
+Object.defineProperty(exports, "IcpayWallet", { enumerable: true, get: function () { return wallet_2.IcpayWallet; } });
+__exportStar(require("./events"), exports);
+// Default export
+exports.default = Icpay;
+//# sourceMappingURL=index.js.map