@ic-pay/icpay-sdk 1.4.84 → 1.4.99

package/dist/index.js

@@ -319,12 +319,15 @@ class Icpay {
     async notifyPayment(params) {
         this.emitMethodStart('notifyPayment', { paymentIntentId: params.paymentIntentId });
         try {
-            const resp = await this.publicApiClient.post('/sdk/public/payments/notify', {
+            const body = {
                 paymentIntentId: params.paymentIntentId,
                 canisterTxId: params.canisterTxId,
                 transactionId: params.transactionId,
                 orderId: params.orderId,
-            });
+            };
+            if (params.icpayPaymentLink && typeof params.icpayPaymentLink === 'object')
+                body.icpayPaymentLink = params.icpayPaymentLink;
+            const resp = await this.publicApiClient.post('/sdk/public/payments/notify', body);
             this.emitMethodSuccess('notifyPayment', { status: resp?.status, paymentIntentId: resp?.paymentIntentId });
             return resp;
         }
@@ -765,6 +768,7 @@ class Icpay {
                     paymentIntentId: paymentIntentId,
                     maxAttempts: 120,
                     delayMs: 1000,
+                    icpayPaymentLink: request?.metadata?.icpayPaymentLink,
                 });
                 // Derive status from API response
                 let statusString = 'pending';
@@ -1007,12 +1011,11 @@ class Icpay {
                         }
                         if (!signedTxB64 && !signerSigBase58)
                             throw new Error('Wallet did not return a signed transaction');
-                        // Relay via API (facilitatorPaysFee: true for x402 so facilitator pays network fee)
+                        // Relay via API. Standard flow prebuilt tx has payer as fee payer (no facilitatorPaysFee).
                         if (signedTxB64) {
                             relay = await this.publicApiClient.post('/sdk/public/payments/solana/relay', {
                                 signedTransactionBase64: signedTxB64,
                                 paymentIntentId: params.paymentIntentId,
-                                facilitatorPaysFee: true,
                             });
                         }
                         else {
@@ -1100,7 +1103,7 @@ class Icpay {
                 return out;
             }
             try {
-                await this.performNotifyPaymentIntent({ paymentIntentId: params.paymentIntentId, transactionId: signature, maxAttempts: 1 });
+                await this.performNotifyPaymentIntent({ paymentIntentId: params.paymentIntentId, transactionId: signature, maxAttempts: 1, icpayPaymentLink: params.metadata?.icpayPaymentLink });
             }
             catch { }
             const finalQuick = await this.awaitIntentTerminal({
@@ -1290,7 +1293,7 @@ class Icpay {
         catch { }
         // Inform API immediately with tx hash so it can start indexing
         try {
-            await this.performNotifyPaymentIntent({ paymentIntentId: params.paymentIntentId, transactionId: txHash, maxAttempts: 1 });
+            await this.performNotifyPaymentIntent({ paymentIntentId: params.paymentIntentId, transactionId: txHash, maxAttempts: 1, icpayPaymentLink: params.metadata?.icpayPaymentLink });
         }
         catch { }
         const finalResponse = await this.awaitIntentTerminal({
@@ -1426,6 +1429,40 @@ class Icpay {
         }
         return new Uint8Array(out);
     }
+    /**
+     * Resolve payment intent from config or request: use full intent if provided, else fetch by id via API.
+     * Returns null when no pre-provided intent (caller should create via POST).
+     */
+    async getOrResolvePaymentIntent(request) {
+        const isFullIntent = (o) => o && typeof o === 'object' && o.id && typeof (o.amount === 'string' ? o.amount : String(o.amount ?? '')) === 'string' &&
+            (o.chainType != null || o.chainId != null || (o.ledgerCanisterId != null && o.ledgerCanisterId !== ''));
+        const fromRequest = request?.paymentIntent;
+        const fromConfig = this.config?.paymentIntent;
+        if (fromRequest && isFullIntent(fromRequest)) {
+            (0, utils_1.debugLog)(this.config.debug || false, 'using payment intent from request');
+            return { paymentIntent: fromRequest, onramp: null };
+        }
+        if (fromConfig && isFullIntent(fromConfig)) {
+            (0, utils_1.debugLog)(this.config.debug || false, 'using payment intent from config');
+            return { paymentIntent: fromConfig, onramp: null };
+        }
+        const intentId = (fromRequest && typeof fromRequest.id === 'string' && fromRequest.id) ||
+            (fromConfig && typeof fromConfig.id === 'string' && fromConfig.id) ||
+            (typeof this.config?.paymentIntentId === 'string' && this.config.paymentIntentId) || null;
+        if (intentId && this.publicApiClient) {
+            try {
+                (0, utils_1.debugLog)(this.config.debug || false, 'fetching payment intent by id', { intentId });
+                const resp = await this.publicApiClient.get(`/sdk/public/payments/intents/${encodeURIComponent(intentId)}`);
+                if (resp?.paymentIntent) {
+                    return { paymentIntent: resp.paymentIntent, onramp: resp.onramp ?? null };
+                }
+            }
+            catch (e) {
+                (0, utils_1.debugLog)(this.config.debug || false, 'fetch payment intent failed', e);
+            }
+        }
+        return null;
+    }
     /**
      * Create a payment to a specific canister/ledger (public method)
      * This is now a real transaction
@@ -1438,17 +1475,18 @@ class Icpay {
             let ledgerCanisterId = request.ledgerCanisterId;
             const tokenShortcode = request?.tokenShortcode;
             const isOnrampFlow = (request?.onrampPayment === true) || (this?.config?.onrampPayment === true);
-            if (!ledgerCanisterId && !tokenShortcode && !request.symbol && !isOnrampFlow) {
+            const hasPaymentIntent = request?.paymentIntent != null || this.config?.paymentIntent != null || (typeof this.config?.paymentIntentId === 'string' && this.config.paymentIntentId);
+            if (!ledgerCanisterId && !tokenShortcode && !request.symbol && !isOnrampFlow && !hasPaymentIntent) {
                 const err = new errors_1.IcpayError({
                     code: errors_1.ICPAY_ERROR_CODES.INVALID_CONFIG,
-                    message: 'Provide either tokenShortcode or ledgerCanisterId (symbol is deprecated).',
+                    message: 'Provide either tokenShortcode or ledgerCanisterId (symbol is deprecated), or pass paymentIntent.',
                     details: { request }
                 });
                 this.emitMethodError('createPayment', err);
                 throw err;
             }
             let memo = undefined;
-            // 1) Create payment intent via API (backend will finalize amount/price)
+            // 1) Resolve or create payment intent: use pre-provided (config/request) or fetch by id, else create via API
             let paymentIntentId = null;
             let paymentIntentCode = null;
             let intentChainType;
@@ -1456,111 +1494,162 @@ class Icpay {
             let accountCanisterId;
             let resolvedAmountStr = typeof request.amount === 'string' ? request.amount : (request.amount != null ? String(request.amount) : undefined);
             let intentResp;
+            let expectedSenderPrincipal;
             try {
-                (0, utils_1.debugLog)(this.config.debug || false, 'creating payment intent');
-                // Resolve expected sender principal:
-                // Start with any value explicitly provided on the request or via connectedWallet.
-                let expectedSenderPrincipal = request.expectedSenderPrincipal ||
-                    this.connectedWallet?.owner ||
-                    this.connectedWallet?.principal?.toString();
-                // If none yet and a Solana provider is present (e.g., Phantom), prefer its publicKey (base58).
-                try {
-                    const solProv = this.config?.solanaProvider || globalThis?.solana;
-                    const solPk = solProv?.publicKey ? String(solProv.publicKey) : undefined;
-                    if (!expectedSenderPrincipal && solPk) {
-                        expectedSenderPrincipal = String(solPk);
-                    }
-                }
-                catch { }
-                // Only if still missing, fall back to EVM accounts.
-                if (!expectedSenderPrincipal) {
-                    const evm = this.config?.evmProvider || globalThis?.ethereum;
-                    if (evm?.request) {
-                        try {
-                            const accounts = await evm.request({ method: 'eth_accounts' });
-                            if (Array.isArray(accounts) && accounts[0]) {
-                                const lowerAccounts = accounts.map((a) => String(a).toLowerCase());
-                                const providedRaw = request?.expectedSenderPrincipal;
-                                if (providedRaw) {
-                                    const provided = String(providedRaw).toLowerCase();
-                                    expectedSenderPrincipal = lowerAccounts.includes(provided) ? accounts[lowerAccounts.indexOf(provided)] : accounts[0];
+                const meta = request?.metadata || {};
+                const isAtxp = Boolean(meta?.icpay_atxp_request) && typeof (meta?.atxp_request_id) === 'string';
+                const onramp = (request.onrampPayment === true || this.config.onrampPayment === true) && this.config.onrampDisabled !== true ? true : false;
+                // If we have a pre-provided intent or an id to fetch, resolve first (skip create for non-ATXP/non-onramp create flows)
+                if (!isAtxp && !onramp) {
+                    const resolved = await this.getOrResolvePaymentIntent(request);
+                    if (resolved) {
+                        let pi = resolved.paymentIntent;
+                        const intentHasToken = (pi?.ledgerId != null) || (pi?.ledgerCanisterId && String(pi.ledgerCanisterId).trim() !== '');
+                        if (!intentHasToken) {
+                            const tokenToSet = request?.tokenShortcode;
+                            if (tokenToSet && typeof tokenToSet === 'string' && this.publicApiClient) {
+                                try {
+                                    await this.publicApiClient.patch(`/sdk/public/payments/intents/${encodeURIComponent(pi.id)}/set-token`, { tokenShortcode: tokenToSet.trim() });
+                                    const refetched = await this.publicApiClient.get(`/sdk/public/payments/intents/${encodeURIComponent(pi.id)}`);
+                                    if (refetched?.paymentIntent)
+                                        pi = refetched.paymentIntent;
                                 }
-                                else {
-                                    expectedSenderPrincipal = accounts[0];
+                                catch (e) {
+                                    (0, utils_1.debugLog)(this.config.debug || false, 'set-token failed', e);
+                                    throw new errors_1.IcpayError({
+                                        code: errors_1.ICPAY_ERROR_CODES.API_ERROR,
+                                        message: 'Payment intent requires a token to be selected. Setting token failed.',
+                                        details: e,
+                                        retryable: true,
+                                        userAction: 'Ensure tokenShortcode is valid and try again',
+                                    });
                                 }
                             }
+                            else {
+                                throw new errors_1.IcpayError({
+                                    code: errors_1.ICPAY_ERROR_CODES.INVALID_CONFIG,
+                                    message: 'Payment intent requires a token to be selected before payment. Provide tokenShortcode in the request.',
+                                    details: { paymentIntentId: pi?.id },
+                                    retryable: false,
+                                    userAction: 'Select a token (e.g. pass tokenShortcode) and try again',
+                                });
+                            }
                         }
-                        catch { }
+                        intentResp = { paymentIntent: pi, onramp: resolved.onramp };
+                        expectedSenderPrincipal = request.expectedSenderPrincipal ||
+                            this.connectedWallet?.owner || this.connectedWallet?.principal?.toString();
                     }
                 }
-                if (!expectedSenderPrincipal && !((request?.onrampPayment === true) || (this?.config?.onrampPayment === true))) {
-                    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 onramp = (request.onrampPayment === true || this.config.onrampPayment === true) && this.config.onrampDisabled !== true ? true : false;
-                const meta = request?.metadata || {};
-                const isAtxp = Boolean(meta?.icpay_atxp_request) && typeof (meta?.atxp_request_id) === 'string';
-                // Resolve recipientAddress only for non-onramp flows
-                const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-                const reqAny = request;
-                const addrObj = (reqAny?.recipientAddresses) || {};
-                const candidateEvm = addrObj.evm ? addrObj.evm : undefined;
-                const candidateIC = addrObj.ic ? addrObj.ic : undefined;
-                const candidateSol = addrObj.sol ? addrObj.sol : undefined;
-                let recipientAddress = undefined;
-                if (!onramp) {
-                    // Choose a default to persist on the intent; EVM will override to ZERO if non-hex when building tx
-                    recipientAddress = (reqAny?.recipientAddress) || candidateEvm || candidateIC || candidateSol || ZERO_ADDRESS;
-                    (0, utils_1.debugLog)(this.config.debug || false, 'recipientAddress resolved for intent', { recipientAddress });
-                }
-                if (isAtxp) {
-                    // Route ATXP intents to the ATXP endpoint so they link to the request
-                    const atxpRequestId = String(meta.atxp_request_id);
-                    const endpoint = `/sdk/public/atxp/requests/${encodeURIComponent(atxpRequestId)}/payment-intents`;
-                    intentResp = await this.publicApiClient.post(endpoint, {
-                        tokenShortcode: tokenShortcode || undefined,
-                        description: request.description,
-                        recipientAddress,
-                        recipientAddresses: request?.recipientAddresses || undefined,
-                        externalCostAmount: request?.externalCostAmount ?? request?.metadata?.externalCostAmount ?? undefined,
-                    });
-                }
-                else {
-                    if (onramp) {
-                        // Route onramp flows to the dedicated onramp endpoint without requiring token/ledger
-                        intentResp = await this.publicApiClient.post('/sdk/public/onramp/intents', {
-                            usdAmount: request.amountUsd,
-                            description: request.description,
-                            metadata: normalizeSdkMetadata(request.metadata || {}),
-                            widgetParams: request.widgetParams || undefined,
-                            recipientAddresses: request?.recipientAddresses || undefined,
+                if (!intentResp) {
+                    (0, utils_1.debugLog)(this.config.debug || false, 'creating payment intent via API');
+                    // Resolve expected sender principal:
+                    // Start with any value explicitly provided on the request or via connectedWallet.
+                    expectedSenderPrincipal =
+                        request.expectedSenderPrincipal ||
+                            this.connectedWallet?.owner ||
+                            this.connectedWallet?.principal?.toString();
+                    // If none yet and a Solana provider is present (e.g., Phantom), prefer its publicKey (base58).
+                    try {
+                        const solProv = this.config?.solanaProvider || globalThis?.solana;
+                        const solPk = solProv?.publicKey ? String(solProv.publicKey) : undefined;
+                        if (!expectedSenderPrincipal && solPk) {
+                            expectedSenderPrincipal = String(solPk);
+                        }
+                    }
+                    catch { }
+                    // Only if still missing, fall back to EVM accounts.
+                    if (!expectedSenderPrincipal) {
+                        const evm = this.config?.evmProvider || globalThis?.ethereum;
+                        if (evm?.request) {
+                            try {
+                                const accounts = await evm.request({ method: 'eth_accounts' });
+                                if (Array.isArray(accounts) && accounts[0]) {
+                                    const lowerAccounts = accounts.map((a) => String(a).toLowerCase());
+                                    const providedRaw = request?.expectedSenderPrincipal;
+                                    if (providedRaw) {
+                                        const provided = String(providedRaw).toLowerCase();
+                                        expectedSenderPrincipal = lowerAccounts.includes(provided) ? accounts[lowerAccounts.indexOf(provided)] : accounts[0];
+                                    }
+                                    else {
+                                        expectedSenderPrincipal = accounts[0];
+                                    }
+                                }
+                            }
+                            catch { }
+                        }
+                    }
+                    if (!expectedSenderPrincipal && !((request?.onrampPayment === true) || (this?.config?.onrampPayment === true))) {
+                        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'
                         });
                     }
-                    else {
-                        intentResp = await this.publicApiClient.post('/sdk/public/payments/intents', {
-                            amount: (typeof request.amount === 'string' ? request.amount : (request.amount != null ? String(request.amount) : undefined)),
-                            // Prefer tokenShortcode if provided
+                    const onramp = (request.onrampPayment === true || this.config.onrampPayment === true) && this.config.onrampDisabled !== true ? true : false;
+                    const meta = request?.metadata || {};
+                    const isAtxp = Boolean(meta?.icpay_atxp_request) && typeof (meta?.atxp_request_id) === 'string';
+                    // Resolve recipientAddress only for non-onramp flows
+                    const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+                    const reqAny = request;
+                    const addrObj = (reqAny?.recipientAddresses) || {};
+                    const candidateEvm = addrObj.evm ? addrObj.evm : undefined;
+                    const candidateIC = addrObj.ic ? addrObj.ic : undefined;
+                    const candidateSol = addrObj.sol ? addrObj.sol : undefined;
+                    let recipientAddress = undefined;
+                    if (!onramp) {
+                        // Choose a default to persist on the intent; EVM will override to ZERO if non-hex when building tx
+                        recipientAddress = (reqAny?.recipientAddress) || candidateEvm || candidateIC || candidateSol || ZERO_ADDRESS;
+                        (0, utils_1.debugLog)(this.config.debug || false, 'recipientAddress resolved for intent', { recipientAddress });
+                    }
+                    if (isAtxp) {
+                        // Route ATXP intents to the ATXP endpoint so they link to the request
+                        const atxpRequestId = String(meta.atxp_request_id);
+                        const endpoint = `/sdk/public/atxp/requests/${encodeURIComponent(atxpRequestId)}/payment-intents`;
+                        intentResp = await this.publicApiClient.post(endpoint, {
                             tokenShortcode: tokenShortcode || undefined,
-                            // Legacy fields for backwards compatibility
-                            symbol: tokenShortcode ? undefined : request.symbol,
-                            ledgerCanisterId: tokenShortcode ? undefined : ledgerCanisterId,
                             description: request.description,
-                            expectedSenderPrincipal,
-                            metadata: normalizeSdkMetadata(request.metadata || {}),
-                            amountUsd: request.amountUsd,
-                            // With tokenShortcode, backend derives chain. Keep legacy chainId for old flows.
-                            chainId: tokenShortcode ? undefined : request.chainId,
-                            widgetParams: request.widgetParams || undefined,
                             recipientAddress,
                             recipientAddresses: request?.recipientAddresses || undefined,
                             externalCostAmount: request?.externalCostAmount ?? request?.metadata?.externalCostAmount ?? undefined,
+                            fiat_currency: request?.fiat_currency,
                         });
                     }
+                    else {
+                        if (onramp) {
+                            // Route onramp flows to the dedicated onramp endpoint without requiring token/ledger
+                            intentResp = await this.publicApiClient.post('/sdk/public/onramp/intents', {
+                                usdAmount: request.amountUsd,
+                                description: request.description,
+                                metadata: normalizeSdkMetadata(request.metadata || {}),
+                                widgetParams: request.widgetParams || undefined,
+                                recipientAddresses: request?.recipientAddresses || undefined,
+                                fiat_currency: request?.fiat_currency,
+                            });
+                        }
+                        else {
+                            intentResp = await this.publicApiClient.post('/sdk/public/payments/intents', {
+                                amount: (typeof request.amount === 'string' ? request.amount : (request.amount != null ? String(request.amount) : undefined)),
+                                // Prefer tokenShortcode if provided
+                                tokenShortcode: tokenShortcode || undefined,
+                                // Legacy fields for backwards compatibility
+                                symbol: tokenShortcode ? undefined : request.symbol,
+                                ledgerCanisterId: tokenShortcode ? undefined : ledgerCanisterId,
+                                description: request.description,
+                                expectedSenderPrincipal,
+                                metadata: normalizeSdkMetadata(request.metadata || {}),
+                                amountUsd: request.amountUsd,
+                                // With tokenShortcode, backend derives chain. Keep legacy chainId for old flows.
+                                chainId: tokenShortcode ? undefined : request.chainId,
+                                widgetParams: request.widgetParams || undefined,
+                                recipientAddress,
+                                recipientAddresses: request?.recipientAddresses || undefined,
+                                externalCostAmount: request?.externalCostAmount ?? request?.metadata?.externalCostAmount ?? undefined,
+                                fiat_currency: request?.fiat_currency,
+                            });
+                        }
+                    }
                 }
                 paymentIntentId = intentResp?.paymentIntent?.id || null;
                 paymentIntentCode = intentResp?.paymentIntent?.intentCode ?? null;
@@ -1974,6 +2063,8 @@ class Icpay {
                 search.set('amountUsd', String(params.amountUsd));
             if (typeof params.amount === 'string' && params.amount)
                 search.set('amount', params.amount);
+            if (typeof params.fiatCurrency === 'string' && params.fiatCurrency.trim())
+                search.set('fiatCurrency', params.fiatCurrency.trim());
             if (Array.isArray(params.chainShortcodes) && params.chainShortcodes.length > 0)
                 search.set('chainShortcodes', params.chainShortcodes.join(','));
             if (Array.isArray(params.tokenShortcodes) && params.tokenShortcodes.length > 0)
@@ -2215,6 +2306,7 @@ class Icpay {
                 chainId: tokenShortcode ? undefined : request.chainId,
                 recipientAddress: request?.recipientAddress || '0x0000000000000000000000000000000000000000',
                 recipientAddresses: request?.recipientAddresses,
+                fiat_currency: request?.fiat_currency ?? request?.fiatCurrency ?? this.config?.fiat_currency,
             };
             const res = await this.createPayment(createTransactionRequest);
             this.emitMethodSuccess('createPaymentUsd', res);
@@ -2246,6 +2338,12 @@ class Icpay {
             // We forward both amountUsd and amount (if provided), and do not resolve canister here.
             const ledgerCanisterId = request.ledgerCanisterId || '';
             const tokenShortcode = request?.tokenShortcode;
+            // Resolve existing payment intent id so API reuses it instead of creating a second intent (e.g. pay link page)
+            const existingIntentId = (typeof request?.paymentIntentId === 'string' && request.paymentIntentId) ||
+                (typeof request?.paymentIntent?.id === 'string' && request.paymentIntent.id) ||
+                (typeof this.config?.paymentIntentId === 'string' && this.config.paymentIntentId) ||
+                (typeof this.config?.paymentIntent?.id === 'string' && this.config.paymentIntent.id) ||
+                null;
             // Hit X402 endpoint
             const body = {
                 amount: request.amount,
@@ -2259,7 +2357,14 @@ class Icpay {
                 chainId: tokenShortcode ? undefined : request.chainId,
                 x402: true,
                 recipientAddress: request?.recipientAddress || '0x0000000000000000000000000000000000000000',
+                fiat_currency: request?.fiat_currency ?? request?.fiatCurrency ?? this.config?.fiat_currency,
             };
+            if (existingIntentId) {
+                body.paymentIntentId = existingIntentId;
+            }
+            if (body.fiat_currency === undefined || body.fiat_currency === '') {
+                delete body.fiat_currency;
+            }
             // Include Solana payerPublicKey so server can build unsigned tx (standard x402 flow)
             try {
                 const w = globalThis?.window || globalThis;
@@ -2580,7 +2685,7 @@ class Icpay {
                                             catch { }
                                             if (sig) {
                                                 try {
-                                                    await this.performNotifyPaymentIntent({ paymentIntentId, transactionId: sig, maxAttempts: 1 });
+                                                    await this.performNotifyPaymentIntent({ paymentIntentId, transactionId: sig, maxAttempts: 1, icpayPaymentLink: request.metadata?.icpayPaymentLink });
                                                 }
                                                 catch { }
                                             }
@@ -3848,6 +3953,8 @@ class Icpay {
                     body.externalCostAmount = params.externalCostAmount;
                 if (typeof params.recipientPrincipal === 'string')
                     body.recipientPrincipal = params.recipientPrincipal;
+                if (params.icpayPaymentLink && typeof params.icpayPaymentLink === 'object')
+                    body.icpayPaymentLink = params.icpayPaymentLink;
                 const resp = await notifyClient.post(notifyPath, body);
                 // If this is the last attempt, return whatever we got
                 if (attempt === maxAttempts) {
@@ -3899,6 +4006,7 @@ class Icpay {
                     accountCanisterId: params.accountCanisterId,
                     externalCostAmount: params.externalCostAmount,
                     recipientPrincipal: params.recipientPrincipal,
+                    icpayPaymentLink: params.metadata?.icpayPaymentLink,
                 });
                 const status = resp?.paymentIntent?.status || resp?.payment?.status || resp?.status || '';
                 const norm = typeof status === 'string' ? status.toLowerCase() : '';