@portal-hq/web 3.13.1 → 3.13.2-0

package/lib/commonjs/internal/pollLoop.test.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pollLoop_1 = require("./pollLoop");
+describe('pollLoop', () => {
+    it('returns immediately when tick returns stop', () => __awaiter(void 0, void 0, void 0, function* () {
+        const tick = jest.fn().mockResolvedValue({
+            kind: 'stop',
+            value: 42,
+        });
+        yield expect((0, pollLoop_1.pollLoop)({
+            tick,
+            intervalMs: 1000,
+            timeoutMs: 5000,
+        })).resolves.toBe(42);
+        expect(tick).toHaveBeenCalledTimes(1);
+    }));
+    it('rejects when tick returns throw', () => __awaiter(void 0, void 0, void 0, function* () {
+        const err = new Error('tick failed');
+        const tick = jest.fn().mockResolvedValue({
+            kind: 'throw',
+            error: err,
+        });
+        yield expect((0, pollLoop_1.pollLoop)({
+            tick,
+            intervalMs: 100,
+            timeoutMs: 1000,
+        })).rejects.toThrow('tick failed');
+    }));
+    it('throws PollLoopTimeoutError when tick always continues', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.useFakeTimers();
+        const tick = jest.fn().mockResolvedValue({ kind: 'continue' });
+        const p = (0, pollLoop_1.pollLoop)({
+            tick,
+            intervalMs: 10,
+            timeoutMs: 100,
+        });
+        const expectTimeout = expect(p).rejects.toBeInstanceOf(pollLoop_1.PollLoopTimeoutError);
+        yield jest.runAllTimersAsync();
+        yield expectTimeout;
+        jest.useRealTimers();
+    }));
+    it('waits initialDelayMs before first tick', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.useFakeTimers();
+        const tick = jest.fn().mockResolvedValue({
+            kind: 'stop',
+            value: true,
+        });
+        const p = (0, pollLoop_1.pollLoop)({
+            tick,
+            intervalMs: 100,
+            initialDelayMs: 300,
+            timeoutMs: 2000,
+        });
+        expect(tick).not.toHaveBeenCalled();
+        yield jest.advanceTimersByTimeAsync(299);
+        expect(tick).not.toHaveBeenCalled();
+        yield jest.advanceTimersByTimeAsync(1);
+        yield expect(p).resolves.toBe(true);
+        expect(tick).toHaveBeenCalledTimes(1);
+        jest.useRealTimers();
+    }));
+    it('increases sleep interval with backoff until maxIntervalMs', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.useFakeTimers();
+        let n = 0;
+        const tick = jest.fn().mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
+            n += 1;
+            if (n < 3) {
+                return { kind: 'continue' };
+            }
+            return { kind: 'stop', value: 'ok' };
+        }));
+        const p = (0, pollLoop_1.pollLoop)({
+            tick,
+            intervalMs: 10,
+            timeoutMs: 10000,
+            backoff: { factor: 100, maxIntervalMs: 500 },
+        });
+        const settled = p.then((v) => v);
+        yield Promise.resolve();
+        expect(tick).toHaveBeenCalledTimes(1);
+        yield jest.advanceTimersByTimeAsync(10);
+        yield Promise.resolve();
+        expect(tick).toHaveBeenCalledTimes(2);
+        yield jest.advanceTimersByTimeAsync(500);
+        yield Promise.resolve();
+        expect(tick).toHaveBeenCalledTimes(3);
+        yield settled;
+        expect(yield settled).toBe('ok');
+        jest.useRealTimers();
+    }));
+});

package/lib/commonjs/internal/stripStalePlanningNonce.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Removes a stale `nonce` from EVM tx payloads planned ahead of signing so the
+ * signer can fetch a fresh nonce at broadcast time (multi-step Yield / LiFi).
+ */
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripStalePlanningNonceIfJsonObject = void 0;
+function unwrapSingleKeyTransactionObject(obj) {
+    const keys = Object.keys(obj);
+    if (keys.length !== 1) {
+        return obj;
+    }
+    const firstKey = keys[0];
+    const inner = obj[firstKey];
+    // Type guard: only unwrap if inner value is a plain object
+    if (typeof inner === 'object' &&
+        inner !== null &&
+        !Array.isArray(inner)) {
+        return inner;
+    }
+    return obj;
+}
+/**
+ * If the payload is JSON (object or JSON string), drop `nonce` from the inner tx object.
+ * Otherwise returns the input unchanged.
+ */
+function stripStalePlanningNonceIfJsonObject(unsigned) {
+    if (typeof unsigned === 'object' &&
+        unsigned !== null &&
+        !Array.isArray(unsigned)) {
+        const spread = Object.assign({}, unsigned);
+        const inner = unwrapSingleKeyTransactionObject(spread);
+        const { nonce: _staleNonce } = inner, rest = __rest(inner, ["nonce"]);
+        return rest;
+    }
+    if (typeof unsigned === 'string') {
+        try {
+            const parsed = JSON.parse(unsigned);
+            // Validate parsed result is a plain object
+            if (typeof parsed === 'object' &&
+                parsed !== null &&
+                !Array.isArray(parsed)) {
+                const inner = unwrapSingleKeyTransactionObject(parsed);
+                const { nonce: _staleNonce } = inner, rest = __rest(inner, ["nonce"]);
+                return rest;
+            }
+        }
+        catch (_a) {
+            return unsigned;
+        }
+    }
+    return unsigned;
+}
+exports.stripStalePlanningNonceIfJsonObject = stripStalePlanningNonceIfJsonObject;

package/lib/commonjs/internal/stripStalePlanningNonce.test.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @jest-environment node
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const stripStalePlanningNonce_1 = require("./stripStalePlanningNonce");
+describe('stripStalePlanningNonceIfJsonObject', () => {
+    it('removes nonce from a flat tx object', () => {
+        const tx = { from: '0xa', to: '0xb', nonce: '0x5', data: '0x' };
+        expect((0, stripStalePlanningNonce_1.stripStalePlanningNonceIfJsonObject)(tx)).toEqual({
+            from: '0xa',
+            to: '0xb',
+            data: '0x',
+        });
+    });
+    it('unwraps single-key wrapper then strips nonce', () => {
+        const wrapped = {
+            transaction: { from: '0xa', nonce: 1, value: '0x0' },
+        };
+        expect((0, stripStalePlanningNonce_1.stripStalePlanningNonceIfJsonObject)(wrapped)).toEqual({
+            from: '0xa',
+            value: '0x0',
+        });
+    });
+    it('parses JSON string and strips nonce', () => {
+        const s = JSON.stringify({ to: '0xt', nonce: '2', gas: '21000' });
+        expect((0, stripStalePlanningNonce_1.stripStalePlanningNonceIfJsonObject)(s)).toEqual({
+            to: '0xt',
+            gas: '21000',
+        });
+    });
+    it('returns opaque string on parse error', () => {
+        expect((0, stripStalePlanningNonce_1.stripStalePlanningNonceIfJsonObject)('not-json')).toBe('not-json');
+    });
+});

package/lib/commonjs/internal/waitForEvmOrUserOpConfirmation.js

@@ -0,0 +1,155 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForEvmOrUserOpConfirmation = void 0;
+const logger_1 = require("../logger");
+const pollLoop_1 = require("./pollLoop");
+const LOG_PREFIX = '[Portal.waitForConfirmation]';
+function parseStatusToOutcome(status) {
+    if (typeof status === 'boolean')
+        return status ? 'success' : 'failed';
+    if (typeof status === 'number')
+        return status === 1 ? 'success' : 'failed';
+    if (typeof status === 'string') {
+        const normalized = status.trim().toLowerCase();
+        if (normalized === '0x1' || normalized === '1')
+            return 'success';
+        if (normalized === '0x0' || normalized === '0')
+            return 'failed';
+    }
+    return 'unknown';
+}
+function parseTxReceiptState(raw) {
+    if (raw == null || typeof raw !== 'object')
+        return 'not_found';
+    const receipt = raw;
+    if (receipt.blockNumber == null)
+        return 'pending';
+    const outcome = parseStatusToOutcome(receipt.status);
+    if (outcome === 'success')
+        return 'success';
+    if (outcome === 'failed')
+        return 'failed';
+    return 'pending';
+}
+function parseUserOpReceiptState(raw) {
+    if (raw == null || typeof raw !== 'object')
+        return 'not_found';
+    const receipt = raw;
+    if (typeof receipt.success === 'boolean') {
+        return receipt.success ? 'success' : 'failed';
+    }
+    const nested = receipt.receipt;
+    if (nested == null)
+        return 'pending';
+    if (nested.blockNumber == null)
+        return 'pending';
+    const outcome = parseStatusToOutcome(nested.status);
+    if (outcome === 'success')
+        return 'success';
+    if (outcome === 'failed')
+        return 'failed';
+    return 'pending';
+}
+function isMethodNotSupportedError(error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    return (message.includes('method not found') ||
+        message.includes('does not exist/is not available') ||
+        message.includes('-32601') ||
+        message.includes('eth_getuseroperationreceipt'));
+}
+function waitForEvmOrUserOpConfirmation(hash, network, request, options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { pollIntervalMs = 4000, timeoutMs = 300000, onTimeout = 'resolve_false', lockModeAfterDetection = true, } = options;
+        let mode = 'auto';
+        let userOpMethodSupported = true;
+        logger_1.sdkLogger.debug(`${LOG_PREFIX} waiting for tx/userOp confirmation`, {
+            hash,
+            network,
+            pollIntervalMs,
+            timeoutMs,
+            mode,
+        });
+        const tick = () => __awaiter(this, void 0, void 0, function* () {
+            if (mode !== 'userOp') {
+                try {
+                    const txRaw = yield request('eth_getTransactionReceipt', [hash], network);
+                    const txState = parseTxReceiptState(txRaw);
+                    if (txState === 'success')
+                        return { kind: 'stop', value: true };
+                    if (txState === 'failed')
+                        return { kind: 'stop', value: false };
+                    if (lockModeAfterDetection && mode === 'auto' && txState === 'pending') {
+                        mode = 'tx';
+                        logger_1.sdkLogger.debug(`${LOG_PREFIX} mode locked`, { hash, network, mode });
+                    }
+                }
+                catch (error) {
+                    logger_1.sdkLogger.warn(`${LOG_PREFIX} tx receipt poll transient error`, {
+                        hash,
+                        network,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            if (mode !== 'tx' && userOpMethodSupported) {
+                try {
+                    const userOpRaw = yield request('eth_getUserOperationReceipt', [hash], network);
+                    const userOpState = parseUserOpReceiptState(userOpRaw);
+                    if (userOpState === 'success')
+                        return { kind: 'stop', value: true };
+                    if (userOpState === 'failed')
+                        return { kind: 'stop', value: false };
+                    if (lockModeAfterDetection &&
+                        mode === 'auto' &&
+                        userOpState === 'pending') {
+                        mode = 'userOp';
+                        logger_1.sdkLogger.debug(`${LOG_PREFIX} mode locked`, { hash, network, mode });
+                    }
+                }
+                catch (error) {
+                    if (isMethodNotSupportedError(error)) {
+                        userOpMethodSupported = false;
+                        logger_1.sdkLogger.debug(`${LOG_PREFIX} eth_getUserOperationReceipt unsupported; disabling userOp polling`, { hash, network });
+                    }
+                    else {
+                        logger_1.sdkLogger.warn(`${LOG_PREFIX} userOp receipt poll transient error`, {
+                            hash,
+                            network,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
+            }
+            return { kind: 'continue' };
+        });
+        try {
+            return yield (0, pollLoop_1.pollLoop)({
+                tick,
+                intervalMs: pollIntervalMs,
+                initialDelayMs: 0,
+                timeoutMs,
+            });
+        }
+        catch (error) {
+            if (error instanceof pollLoop_1.PollLoopTimeoutError) {
+                const msg = `${LOG_PREFIX} timeout after ${timeoutMs}ms waiting for confirmation on ${hash} (${network}).`;
+                if (onTimeout === 'throw') {
+                    throw new Error(`${msg} Confirmation not reached.`);
+                }
+                logger_1.sdkLogger.warn(`${msg} Returning false (resolve_false).`);
+                return false;
+            }
+            throw error;
+        }
+    });
+}
+exports.waitForEvmOrUserOpConfirmation = waitForEvmOrUserOpConfirmation;

package/lib/commonjs/internal/waitForEvmOrUserOpConfirmation.test.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @jest-environment node
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const waitForEvmOrUserOpConfirmation_1 = require("./waitForEvmOrUserOpConfirmation");
+describe('waitForEvmOrUserOpConfirmation', () => {
+    beforeEach(() => {
+        jest.useFakeTimers();
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    it('returns false on timeout when receipt never appears', () => __awaiter(void 0, void 0, void 0, function* () {
+        const request = jest.fn().mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return null; }));
+        const done = (0, waitForEvmOrUserOpConfirmation_1.waitForEvmOrUserOpConfirmation)('0x1', 'eip155:1', request, {
+            pollIntervalMs: 1000,
+            timeoutMs: 2500,
+        });
+        yield jest.advanceTimersByTimeAsync(3100);
+        yield expect(done).resolves.toBe(false);
+        expect(request.mock.calls.some((c) => c[0] === 'eth_getTransactionReceipt')).toBe(true);
+    }));
+});

package/lib/commonjs/internal/waitForEvmTxConfirmation.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Shared EVM transaction confirmation via `eth_getTransactionReceipt` + {@link pollLoop}.
+ *
+ * **Use in each domain:**
+ * - **Yield** (multi-step): Prefer {@link Portal.waitForConfirmation} (returns `false` on soft timeout)
+ *   or standalone `pollForEvmReceipt` (same engine).
+ * - **LiFi** (`tradeAsset`): Use `onTimeout: 'throw'` with the same RPC `request` as Portal's
+ *   gateway so a stuck tx fails before bridge status polling.
+ * - **Legacy swaps** (`@portal-hq/swaps`): Call `portal.waitForConfirmation(txHash, caip2)` after
+ *   `eth_sendTransaction` so "submitted" reflects chain inclusion when the network is known.
+ *
+ * Domain-specific orchestration (LiFi status, Yield multi-tx, route steps) stays outside this module.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForEvmTxConfirmation = void 0;
+const logger_1 = require("../logger");
+const pollLoop_1 = require("./pollLoop");
+const LOG_PREFIX = '[Portal.evmReceipt]';
+function evmReceiptPollTick(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { txHash, network, request, pollIntervalMs } = ctx;
+        try {
+            const raw = yield request('eth_getTransactionReceipt', [txHash], network);
+            const receipt = raw;
+            if ((receipt === null || receipt === void 0 ? void 0 : receipt.blockNumber) != null) {
+                if (receipt.status === '0x0') {
+                    return {
+                        kind: 'throw',
+                        error: new Error(`${LOG_PREFIX} Transaction ${txHash} was reverted on-chain (status 0x0). ` +
+                            'The transaction did not succeed.'),
+                    };
+                }
+                logger_1.sdkLogger.debug(`${LOG_PREFIX} receipt confirmed`, {
+                    txHash,
+                    network,
+                    blockNumber: receipt.blockNumber,
+                    status: receipt.status,
+                });
+                return { kind: 'stop', value: true };
+            }
+            logger_1.sdkLogger.debug(`${LOG_PREFIX} not yet mined, retrying`, { txHash, network });
+            return { kind: 'continue' };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('reverted')) {
+                return { kind: 'throw', error };
+            }
+            logger_1.sdkLogger.warn(`${LOG_PREFIX} transient error polling receipt for ${txHash} (${network}), will retry in ${pollIntervalMs}ms:`, error);
+            return { kind: 'continue' };
+        }
+    });
+}
+/**
+ * Poll until the tx is mined with success (`0x1`), reverted (`0x0` → throw), or timeout.
+ * Pending receipts and transient RPC errors retry with warn logs; logs always include `txHash` / `network` where relevant.
+ */
+function waitForEvmTxConfirmation(txHash, network, request, options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { pollIntervalMs = 4000, timeoutMs = 900000, onTimeout = 'resolve_false', } = options;
+        logger_1.sdkLogger.debug(`${LOG_PREFIX} waiting for receipt`, {
+            txHash,
+            network,
+            pollIntervalMs,
+            timeoutMs,
+            onTimeout,
+        });
+        const tickCtx = {
+            txHash,
+            network,
+            request,
+            pollIntervalMs,
+        };
+        try {
+            return yield (0, pollLoop_1.pollLoop)({
+                tick: () => evmReceiptPollTick(tickCtx),
+                intervalMs: pollIntervalMs,
+                initialDelayMs: 0,
+                timeoutMs,
+            });
+        }
+        catch (error) {
+            if (error instanceof pollLoop_1.PollLoopTimeoutError) {
+                const msg = `${LOG_PREFIX} timeout after ${timeoutMs}ms waiting for receipt on ${txHash} (${network}).`;
+                if (onTimeout === 'throw') {
+                    throw new Error(`${msg} Transaction may still confirm; aborting this wait.`);
+                }
+                logger_1.sdkLogger.warn(`${msg} Transaction may still confirm. Proceeding optimistically.`);
+                return false;
+            }
+            throw error;
+        }
+    });
+}
+exports.waitForEvmTxConfirmation = waitForEvmTxConfirmation;

package/lib/commonjs/internal/waitForSolanaTxConfirmation.js

@@ -0,0 +1,106 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForSolanaTxConfirmation = void 0;
+const logger_1 = require("../logger");
+const LOG_PREFIX = '[Portal.waitForConfirmation]';
+const COMMITMENT_ORDER = {
+    processed: 0,
+    confirmed: 1,
+    finalized: 2,
+};
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function statusMeetsCommitment(confirmationStatus, required) {
+    if (!confirmationStatus)
+        return false;
+    const level = COMMITMENT_ORDER[confirmationStatus];
+    const need = COMMITMENT_ORDER[required];
+    if (level === undefined || need === undefined)
+        return false;
+    return level >= need;
+}
+function parseSignatureStatusesResult(raw) {
+    var _a;
+    if (raw == null || typeof raw !== 'object')
+        return null;
+    const outer = raw;
+    const arr = (_a = outer.value) !== null && _a !== void 0 ? _a : outer.result;
+    if (!Array.isArray(arr) || arr.length === 0)
+        return null;
+    const first = arr[0];
+    if (first == null || typeof first !== 'object')
+        return null;
+    return first;
+}
+/**
+ * Polls Solana `getSignatureStatuses` via {@link request} (routed through the
+ * iframe RPC proxy) until the signature reaches the requested commitment,
+ * fails on-chain, or times out.
+ */
+function waitForSolanaTxConfirmation(signature, network, request, options) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const { pollIntervalMs, timeoutMs, commitment } = options;
+        logger_1.sdkLogger.debug(`${LOG_PREFIX} waiting for Solana confirmation`, {
+            signature,
+            network,
+            pollIntervalMs,
+            timeoutMs,
+            commitment,
+        });
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            try {
+                const raw = yield request('getSignatureStatuses', [[signature], { searchTransactionHistory: true }], network);
+                const rpcResponse = raw;
+                if (rpcResponse.error) {
+                    throw new Error(`${LOG_PREFIX} RPC error for getSignatureStatuses: ${JSON.stringify(rpcResponse.error)}`);
+                }
+                const statusRow = parseSignatureStatusesResult((_a = rpcResponse.result) !== null && _a !== void 0 ? _a : raw);
+                if (statusRow != null) {
+                    if (statusRow.err != null) {
+                        logger_1.sdkLogger.debug(`${LOG_PREFIX} Solana tx error on-chain`, {
+                            signature,
+                            network,
+                            err: statusRow.err,
+                        });
+                        return false;
+                    }
+                    if (statusMeetsCommitment(statusRow.confirmationStatus, commitment)) {
+                        logger_1.sdkLogger.debug(`${LOG_PREFIX} Solana commitment met`, {
+                            signature,
+                            network,
+                            confirmationStatus: statusRow.confirmationStatus,
+                            commitment,
+                        });
+                        return true;
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.sdkLogger.warn(`${LOG_PREFIX} Solana poll transient error`, {
+                    signature,
+                    network,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                break;
+            yield sleep(Math.min(pollIntervalMs, Math.max(0, remaining)));
+        }
+        logger_1.sdkLogger.warn(`${LOG_PREFIX} timeout after ${timeoutMs}ms waiting for Solana confirmation on ${signature} (${network}). Returning false.`);
+        return false;
+    });
+}
+exports.waitForSolanaTxConfirmation = waitForSolanaTxConfirmation;

package/lib/commonjs/internal/yieldEvmNetwork.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Yield / Portal-style EVM network slugs → EIP-155 CAIP-2.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isYieldEvmNetwork = exports.resolveYieldNetworkToCaip2 = void 0;
+const YIELD_EVM_SLUG_TO_CAIP2 = {
+    // Common friendly names (subset of typical integrations)
+    ethereum: 'eip155:1',
+    eth: 'eip155:1',
+    mainnet: 'eip155:1',
+    polygon: 'eip155:137',
+    matic: 'eip155:137',
+    arbitrum: 'eip155:42161',
+    optimism: 'eip155:10',
+    base: 'eip155:8453',
+    blast: 'eip155:81457',
+    scroll: 'eip155:534352',
+    mantle: 'eip155:5000',
+    mode: 'eip155:34443',
+    opbnb: 'eip155:204',
+    // Testnets and alternate slugs (e.g. *-sepolia) mapped to EIP-155 CAIP-2
+    'ethereum-sepolia': 'eip155:11155111',
+    'ethereum-goerli': 'eip155:5',
+    'ethereum-holesky': 'eip155:17000',
+    'ethereum-hoodi': 'eip155:560048',
+    binance: 'eip155:56',
+    bsc: 'eip155:56',
+    'avalanche-c': 'eip155:43114',
+    'avalanche-c-atomic': 'eip155:43114',
+    gnosis: 'eip155:100',
+    zksync: 'eip155:324',
+    linea: 'eip155:59144',
+    celo: 'eip155:42220',
+    fantom: 'eip155:250',
+    harmony: 'eip155:1666600000',
+    moonriver: 'eip155:1285',
+    okc: 'eip155:66',
+    viction: 'eip155:88',
+    core: 'eip155:1116',
+    cronos: 'eip155:25',
+    evmos: 'eip155:9001',
+    unichain: 'eip155:130',
+    sonic: 'eip155:146',
+};
+/** Resolve a Yield transaction `network` string to EIP-155 CAIP-2 when known. */
+function resolveYieldNetworkToCaip2(network) {
+    if (typeof network !== 'string' || network === '')
+        return undefined;
+    if (network.startsWith('eip155:'))
+        return network;
+    if (network.toLowerCase().startsWith('solana'))
+        return undefined;
+    return YIELD_EVM_SLUG_TO_CAIP2[network.toLowerCase()];
+}
+exports.resolveYieldNetworkToCaip2 = resolveYieldNetworkToCaip2;
+function isYieldEvmNetwork(network) {
+    return resolveYieldNetworkToCaip2(network) !== undefined;
+}
+exports.isYieldEvmNetwork = isYieldEvmNetwork;