@pushchain/core 6.0.19 → 6.0.21

package/src/lib/orchestrator/internals/signing.js

@@ -9,7 +9,6 @@ exports.signUniversalPayload = signUniversalPayload;
 exports.signMigrationPayload = signMigrationPayload;
 exports.encodeUniversalPayload = encodeUniversalPayload;
 exports.encodeUniversalPayloadSvm = encodeUniversalPayloadSvm;
-const tslib_1 = require("tslib");
 const viem_1 = require("viem");
 const chain_1 = require("../../constants/chain");
 const enums_1 = require("../../constants/enums");
@@ -96,95 +95,91 @@ function computeMigrationHash(ctx, { verifyingContract, migrationContractAddress
 // ============================================================================
 // Payload Signing
 // ============================================================================
-function signUniversalPayload(ctx, universalPayload, verifyingContract, version) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const chain = ctx.universalSigner.account.chain;
-        const { vm, chainId } = chain_1.CHAIN_INFO[chain];
-        switch (vm) {
-            case enums_1.VM.EVM: {
-                if (!ctx.universalSigner.signTypedData) {
-                    throw new Error('signTypedData is not defined');
-                }
-                return ctx.universalSigner.signTypedData({
-                    domain: {
-                        version: version || '0.1.0',
-                        chainId: Number(chainId),
-                        verifyingContract,
-                    },
-                    types: {
-                        UniversalPayload: [
-                            { name: 'to', type: 'address' },
-                            { name: 'value', type: 'uint256' },
-                            { name: 'data', type: 'bytes' },
-                            { name: 'gasLimit', type: 'uint256' },
-                            { name: 'maxFeePerGas', type: 'uint256' },
-                            { name: 'maxPriorityFeePerGas', type: 'uint256' },
-                            { name: 'nonce', type: 'uint256' },
-                            { name: 'deadline', type: 'uint256' },
-                            { name: 'vType', type: 'uint8' },
-                        ],
-                    },
-                    primaryType: 'UniversalPayload',
-                    message: universalPayload,
-                });
+async function signUniversalPayload(ctx, universalPayload, verifyingContract, version) {
+    const chain = ctx.universalSigner.account.chain;
+    const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+    switch (vm) {
+        case enums_1.VM.EVM: {
+            if (!ctx.universalSigner.signTypedData) {
+                throw new Error('signTypedData is not defined');
             }
-            case enums_1.VM.SVM: {
-                const digest = computeExecutionHash(ctx, {
-                    verifyingContract,
-                    payload: universalPayload,
+            return ctx.universalSigner.signTypedData({
+                domain: {
                     version: version || '0.1.0',
-                });
-                return ctx.universalSigner.signMessage((0, viem_1.stringToBytes)(digest));
-            }
-            default:
-                throw new Error(`Unsupported VM type: ${vm}`);
+                    chainId: Number(chainId),
+                    verifyingContract,
+                },
+                types: {
+                    UniversalPayload: [
+                        { name: 'to', type: 'address' },
+                        { name: 'value', type: 'uint256' },
+                        { name: 'data', type: 'bytes' },
+                        { name: 'gasLimit', type: 'uint256' },
+                        { name: 'maxFeePerGas', type: 'uint256' },
+                        { name: 'maxPriorityFeePerGas', type: 'uint256' },
+                        { name: 'nonce', type: 'uint256' },
+                        { name: 'deadline', type: 'uint256' },
+                        { name: 'vType', type: 'uint8' },
+                    ],
+                },
+                primaryType: 'UniversalPayload',
+                message: universalPayload,
+            });
+        }
+        case enums_1.VM.SVM: {
+            const digest = computeExecutionHash(ctx, {
+                verifyingContract,
+                payload: universalPayload,
+                version: version || '0.1.0',
+            });
+            return ctx.universalSigner.signMessage((0, viem_1.stringToBytes)(digest));
         }
-    });
+        default:
+            throw new Error(`Unsupported VM type: ${vm}`);
+    }
 }
-function signMigrationPayload(ctx_1, _a) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (ctx, { migrationContractAddress, nonce, deadline, ueaVersion, ueaAddress, }) {
-        const chain = ctx.universalSigner.account.chain;
-        const { vm, chainId } = chain_1.CHAIN_INFO[chain];
-        switch (vm) {
-            case enums_1.VM.EVM: {
-                if (!ctx.universalSigner.signTypedData) {
-                    throw new Error('signTypedData is not defined');
-                }
-                return ctx.universalSigner.signTypedData({
-                    domain: {
-                        version: ueaVersion,
-                        chainId: Number(chainId),
-                        verifyingContract: ueaAddress,
-                    },
-                    types: {
-                        MigrationPayload: [
-                            { name: 'migration', type: 'address' },
-                            { name: 'nonce', type: 'uint256' },
-                            { name: 'deadline', type: 'uint256' },
-                        ],
-                    },
-                    primaryType: 'MigrationPayload',
-                    message: {
-                        migration: migrationContractAddress,
-                        nonce: nonce.toString(),
-                        deadline: deadline.toString(),
-                    },
-                });
+async function signMigrationPayload(ctx, { migrationContractAddress, nonce, deadline, ueaVersion, ueaAddress, }) {
+    const chain = ctx.universalSigner.account.chain;
+    const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+    switch (vm) {
+        case enums_1.VM.EVM: {
+            if (!ctx.universalSigner.signTypedData) {
+                throw new Error('signTypedData is not defined');
             }
-            case enums_1.VM.SVM: {
-                const digest = computeMigrationHash(ctx, {
-                    verifyingContract: ueaAddress,
-                    migrationContractAddress,
-                    nonce,
-                    deadline,
+            return ctx.universalSigner.signTypedData({
+                domain: {
                     version: ueaVersion,
-                });
-                return ctx.universalSigner.signMessage((0, viem_1.stringToBytes)(digest));
-            }
-            default:
-                throw new Error(`Unsupported VM type for migration: ${vm}`);
+                    chainId: Number(chainId),
+                    verifyingContract: ueaAddress,
+                },
+                types: {
+                    MigrationPayload: [
+                        { name: 'migration', type: 'address' },
+                        { name: 'nonce', type: 'uint256' },
+                        { name: 'deadline', type: 'uint256' },
+                    ],
+                },
+                primaryType: 'MigrationPayload',
+                message: {
+                    migration: migrationContractAddress,
+                    nonce: nonce.toString(),
+                    deadline: deadline.toString(),
+                },
+            });
+        }
+        case enums_1.VM.SVM: {
+            const digest = computeMigrationHash(ctx, {
+                verifyingContract: ueaAddress,
+                migrationContractAddress,
+                nonce,
+                deadline,
+                version: ueaVersion,
+            });
+            return ctx.universalSigner.signMessage((0, viem_1.stringToBytes)(digest));
         }
-    });
+        default:
+            throw new Error(`Unsupported VM type for migration: ${vm}`);
+    }
 }
 // ============================================================================
 // Payload Encoding

package/src/lib/orchestrator/internals/svm-bridge.d.ts

@@ -5,14 +5,14 @@
  * Handles both native SOL and SPL token bridging with universal payload signing.
  */
 import type { UniversalPayload } from '../../generated/v1/tx';
-import type { ExecuteParams, UniversalTxRequest } from '../orchestrator.types';
+import type { LegacyExecuteParams, UniversalTxRequest } from '../orchestrator.types';
 import type { OrchestratorContext } from './context';
 /**
  * Sends a Solana gateway transaction for the funds+payload bridge path.
  * Handles native SOL and SPL token mechanisms.
  */
 export declare function sendSVMTxWithFunds(ctx: OrchestratorContext, params: {
-    execute: ExecuteParams;
+    execute: LegacyExecuteParams;
     mechanism: 'native' | 'approve' | 'permit2' | string;
     universalPayload: UniversalPayload;
     bridgeAmount: bigint;

package/src/lib/orchestrator/internals/svm-bridge.js

@@ -15,6 +15,7 @@ const chain_1 = require("../../constants/chain");
 const enums_1 = require("../../constants/enums");
 const svm_client_1 = require("../../vm-client/svm-client");
 const svm_helpers_1 = require("./svm-helpers");
+const svm_1 = require("./pc20/svm");
 const signing_1 = require("./signing");
 const uea_manager_1 = require("./uea-manager");
 // ============================================================================
@@ -24,99 +25,166 @@ const uea_manager_1 = require("./uea-manager");
  * Sends a Solana gateway transaction for the funds+payload bridge path.
  * Handles native SOL and SPL token mechanisms.
  */
-function sendSVMTxWithFunds(ctx, params) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const { execute, mechanism, universalPayload, bridgeAmount, nativeAmount, req } = params;
-        const svmClient = new svm_client_1.SvmClient({
-            rpcUrls: ctx.rpcUrls[enums_1.CHAIN.SOLANA_DEVNET] ||
-                chain_1.CHAIN_INFO[enums_1.CHAIN.SOLANA_DEVNET].defaultRPC,
-        });
-        const programId = new web3_js_1.PublicKey(universalGatewayV0_json_1.default.address);
-        const [configPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('config')], programId);
-        const [vaultPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('vault')], programId);
-        const userPk = new web3_js_1.PublicKey(ctx.universalSigner.account.address);
-        const priceUpdatePk = new web3_js_1.PublicKey(chain_1.SVM_PYTH_PRICE_FEED);
-        const [rateLimitConfigPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit_config')], programId);
-        if (execute.payGasWith !== undefined) {
-            throw new Error('Pay-with token is not supported on Solana');
-        }
-        if (!((_b = (_a = execute.funds) === null || _a === void 0 ? void 0 : _a.token) === null || _b === void 0 ? void 0 : _b.address)) {
-            throw new Error('Token address is required for bridge path');
-        }
-        const isNative = mechanism === 'native' || execute.funds.token.symbol === 'SOL';
-        const { feeVaultPda, protocolFeeLamports } = yield (0, svm_helpers_1.getSvmProtocolFee)(svmClient, programId);
-        const ueaAddressSvm = (0, uea_manager_1.computeUEAOffchain)(ctx);
-        const ueaVersion = yield (0, uea_manager_1.fetchUEAVersion)(ctx);
-        const svmSignature = yield (0, signing_1.signUniversalPayload)(ctx, universalPayload, ueaAddressSvm, ueaVersion);
-        if (isNative) {
-            const [tokenRateLimitPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit'), web3_js_1.PublicKey.default.toBuffer()], programId);
-            const nativeReq = (0, svm_helpers_1.buildSvmUniversalTxRequest)({
-                recipient: Array.from(Buffer.alloc(20, 0)),
-                token: web3_js_1.PublicKey.default,
-                amount: bridgeAmount,
-                payload: Uint8Array.from((0, signing_1.encodeUniversalPayloadSvm)(universalPayload)),
-                revertRecipient: userPk,
-                signatureData: svmSignature,
-            });
-            return yield svmClient.writeContract({
-                abi: universalGatewayV0_json_1.default,
-                address: programId.toBase58(),
-                functionName: 'sendUniversalTx',
-                args: [nativeReq, nativeAmount + protocolFeeLamports],
-                signer: ctx.universalSigner,
-                accounts: {
-                    config: configPda,
-                    vault: vaultPda,
-                    feeVault: feeVaultPda,
-                    userTokenAccount: vaultPda,
-                    gatewayTokenAccount: vaultPda,
-                    user: userPk,
-                    priceUpdate: priceUpdatePk,
-                    tokenProgram: new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
-                    rateLimitConfig: rateLimitConfigPda,
-                    tokenRateLimit: tokenRateLimitPda,
-                    systemProgram: web3_js_1.SystemProgram.programId,
-                },
-            });
-        }
-        else {
-            // Token address already validated above (line 67)
-            const mintPk = new web3_js_1.PublicKey(execute.funds.token.address);
-            const TOKEN_PROGRAM_ID = new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
-            const ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js_1.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
-            const userAta = web3_js_1.PublicKey.findProgramAddressSync([userPk.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mintPk.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
-            const vaultAta = web3_js_1.PublicKey.findProgramAddressSync([vaultPda.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mintPk.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
-            const [tokenRateLimitPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit'), mintPk.toBuffer()], programId);
-            const splReq = (0, svm_helpers_1.buildSvmUniversalTxRequest)({
-                recipient: Array.from(Buffer.alloc(20, 0)),
-                token: mintPk,
-                amount: bridgeAmount,
-                payload: Uint8Array.from((0, signing_1.encodeUniversalPayloadSvm)(universalPayload)),
-                revertRecipient: userPk,
-                signatureData: svmSignature,
-            });
-            return yield svmClient.writeContract({
-                abi: universalGatewayV0_json_1.default,
-                address: programId.toBase58(),
-                functionName: 'sendUniversalTx',
-                args: [splReq, nativeAmount + protocolFeeLamports],
-                signer: ctx.universalSigner,
-                accounts: {
-                    config: configPda,
-                    vault: vaultPda,
-                    feeVault: feeVaultPda,
-                    userTokenAccount: userAta,
-                    gatewayTokenAccount: vaultAta,
-                    user: userPk,
-                    priceUpdate: priceUpdatePk,
-                    tokenProgram: TOKEN_PROGRAM_ID,
-                    rateLimitConfig: rateLimitConfigPda,
-                    tokenRateLimit: tokenRateLimitPda,
-                    systemProgram: web3_js_1.SystemProgram.programId,
-                },
-            });
-        }
+async function sendSVMTxWithFunds(ctx, params) {
+    const { execute, mechanism, universalPayload, bridgeAmount, nativeAmount, req } = params;
+    const svmClient = new svm_client_1.SvmClient({
+        rpcUrls: ctx.rpcUrls[enums_1.CHAIN.SOLANA_DEVNET] ||
+            chain_1.CHAIN_INFO[enums_1.CHAIN.SOLANA_DEVNET].defaultRPC,
     });
+    const programId = new web3_js_1.PublicKey(universalGatewayV0_json_1.default.address);
+    const [configPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('config')], programId);
+    const [vaultPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('vault')], programId);
+    const userPk = new web3_js_1.PublicKey(ctx.universalSigner.account.address);
+    const priceUpdatePk = new web3_js_1.PublicKey(chain_1.SVM_PYTH_PRICE_FEED);
+    const [rateLimitConfigPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit_config')], programId);
+    if (execute.payGasWith !== undefined) {
+        throw new Error('Pay-with token is not supported on Solana');
+    }
+    if (!execute.funds?.token?.address) {
+        throw new Error('Token address is required for bridge path');
+    }
+    const isNative = mechanism === 'native' || execute.funds.token.symbol === 'SOL';
+    const { feeVaultPda, protocolFeeLamports } = await (0, svm_helpers_1.getSvmProtocolFee)(svmClient, programId);
+    const ueaAddressSvm = (0, uea_manager_1.computeUEAOffchain)(ctx);
+    const ueaVersion = await (0, uea_manager_1.fetchUEAVersion)(ctx);
+    const svmSignature = await (0, signing_1.signUniversalPayload)(ctx, universalPayload, ueaAddressSvm, ueaVersion);
+    // --- PC20 wrapper burn -------------------------------------------------
+    // route_pc20_universal_tx (deposit.rs) differs from the SPL escrow route in
+    // four program-enforced ways, each of which reverts if violated:
+    //   1. req.recipient must be the NONZERO 20-byte Push recipient — the chain
+    //      unlocks the source token directly to it (unlockPC20), unlike SPL
+    //      where zeros are fine because the UEA payload moves funds.
+    //   2. gateway_token_account must be ABSENT — the wrapper is burned via the
+    //      mint authority, never escrowed.
+    //   3. remaining_accounts must be exactly [pc20_state ro, pc20_mint w].
+    //   4. token_rate_limit is null for a pure burn; the NATIVE-SOL rate-limit
+    //      PDA when native value above the inbound fee rides along (that excess
+    //      is a rate-limited native FUNDS leg).
+    // The SDK must NOT prepend the PC20 selector — the gateway does
+    // (pc20_prefixed_payload), mirroring the EVM inbound.
+    const pc20 = execute._pc20;
+    if (pc20?.direction === 'import') {
+        const mintPk = new web3_js_1.PublicKey(execute.funds.token.address);
+        const { remainingAccounts } = (0, svm_1.buildPC20BurnAccounts)({
+            programId,
+            mint: mintPk,
+        });
+        const TOKEN_PROGRAM_ID = new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+        const ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js_1.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+        const userAta = web3_js_1.PublicKey.findProgramAddressSync([userPk.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mintPk.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
+        // A pure PC20 burn consumes no per-token rate limit — pass null. When
+        // native value rides along (nativeAmount > 0), the post-fee excess routes
+        // as a native FUNDS leg, which IS rate-limited: that leg requires the
+        // native-SOL rate-limit PDA (token_mint = Pubkey::default()) — the program
+        // rejects a mint-derived one (deposit.rs route_pc20_universal_tx).
+        const tokenRateLimit = nativeAmount > BigInt(0)
+            ? web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit'), web3_js_1.PublicKey.default.toBuffer()], programId)[0]
+            : null;
+        // The unlock recipient is ALWAYS the signer's UEA, never `execute.to`:
+        // the payload multicall transfers the canonical token FROM the UEA to
+        // `execute.to` (buildExecuteMulticall Branch 2), so the unlock must land
+        // on the UEA for that leg to have funds — EVM parity, and the exact shape
+        // the R3 drain verified live (degenerate self-transfer when to === UEA).
+        // Unlocking directly to `to` while the payload transfers from the UEA
+        // would strand the transfer leg with a zero balance.
+        const pushRecipient = ueaAddressSvm;
+        const burnReq = (0, svm_helpers_1.buildSvmUniversalTxRequest)({
+            recipient: Array.from(Buffer.from(pushRecipient.slice(2), 'hex')),
+            token: mintPk,
+            amount: bridgeAmount,
+            payload: Uint8Array.from((0, signing_1.encodeUniversalPayloadSvm)(universalPayload)),
+            revertRecipient: userPk,
+            signatureData: svmSignature,
+        });
+        return await svmClient.writeContract({
+            abi: universalGatewayV0_json_1.default,
+            address: programId.toBase58(),
+            functionName: 'sendUniversalTx',
+            args: [burnReq, nativeAmount + protocolFeeLamports],
+            signer: ctx.universalSigner,
+            accounts: {
+                config: configPda,
+                vault: vaultPda,
+                feeVault: feeVaultPda,
+                userTokenAccount: userAta,
+                gatewayTokenAccount: null,
+                user: userPk,
+                priceUpdate: priceUpdatePk,
+                tokenProgram: TOKEN_PROGRAM_ID,
+                rateLimitConfig: rateLimitConfigPda,
+                tokenRateLimit,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            },
+            remainingAccounts,
+        });
+    }
+    if (isNative) {
+        const [tokenRateLimitPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit'), web3_js_1.PublicKey.default.toBuffer()], programId);
+        const nativeReq = (0, svm_helpers_1.buildSvmUniversalTxRequest)({
+            recipient: Array.from(Buffer.alloc(20, 0)),
+            token: web3_js_1.PublicKey.default,
+            amount: bridgeAmount,
+            payload: Uint8Array.from((0, signing_1.encodeUniversalPayloadSvm)(universalPayload)),
+            revertRecipient: userPk,
+            signatureData: svmSignature,
+        });
+        return await svmClient.writeContract({
+            abi: universalGatewayV0_json_1.default,
+            address: programId.toBase58(),
+            functionName: 'sendUniversalTx',
+            args: [nativeReq, nativeAmount + protocolFeeLamports],
+            signer: ctx.universalSigner,
+            accounts: {
+                config: configPda,
+                vault: vaultPda,
+                feeVault: feeVaultPda,
+                userTokenAccount: vaultPda,
+                gatewayTokenAccount: vaultPda,
+                user: userPk,
+                priceUpdate: priceUpdatePk,
+                tokenProgram: new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
+                rateLimitConfig: rateLimitConfigPda,
+                tokenRateLimit: tokenRateLimitPda,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            },
+        });
+    }
+    else {
+        // Token address already validated above (line 67)
+        const mintPk = new web3_js_1.PublicKey(execute.funds.token.address);
+        const TOKEN_PROGRAM_ID = new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+        const ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js_1.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+        const userAta = web3_js_1.PublicKey.findProgramAddressSync([userPk.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mintPk.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
+        const vaultAta = web3_js_1.PublicKey.findProgramAddressSync([vaultPda.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mintPk.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
+        const [tokenRateLimitPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit'), mintPk.toBuffer()], programId);
+        const splReq = (0, svm_helpers_1.buildSvmUniversalTxRequest)({
+            recipient: Array.from(Buffer.alloc(20, 0)),
+            token: mintPk,
+            amount: bridgeAmount,
+            payload: Uint8Array.from((0, signing_1.encodeUniversalPayloadSvm)(universalPayload)),
+            revertRecipient: userPk,
+            signatureData: svmSignature,
+        });
+        return await svmClient.writeContract({
+            abi: universalGatewayV0_json_1.default,
+            address: programId.toBase58(),
+            functionName: 'sendUniversalTx',
+            args: [splReq, nativeAmount + protocolFeeLamports],
+            signer: ctx.universalSigner,
+            accounts: {
+                config: configPda,
+                vault: vaultPda,
+                feeVault: feeVaultPda,
+                userTokenAccount: userAta,
+                gatewayTokenAccount: vaultAta,
+                user: userPk,
+                priceUpdate: priceUpdatePk,
+                tokenProgram: TOKEN_PROGRAM_ID,
+                rateLimitConfig: rateLimitConfigPda,
+                tokenRateLimit: tokenRateLimitPda,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            },
+        });
+    }
 }
 //# sourceMappingURL=svm-bridge.js.map

package/src/lib/orchestrator/internals/svm-helpers.d.ts

@@ -32,4 +32,18 @@ export declare function getSvmProtocolFee(svmClient: {
     feeVaultPda: PublicKey;
     protocolFeeLamports: bigint;
 }>;
-export declare function getSvmGatewayLogIndexFromTx(txResp: any): number;
+/**
+ * Locate the gateway event whose UTX the caller should track.
+ *
+ * Default: the second gateway event when there are two (a gas leg followed by
+ * the funds leg), else the last one.
+ *
+ * `preferPC20` inverts that for PC20 wrapper burns. Such a transaction emits
+ * the PC20 burn event first and then, when native value rides along, a plain
+ * funds event for the gas deposit — so the default would track the deposit
+ * leg. A failure crediting that deposit (the known chain-side fee-credit bug)
+ * would then be reported as the whole transfer failing, even though the tokens
+ * arrived via the first event. Selection is by payload selector rather than
+ * position, so it survives a change in emission order.
+ */
+export declare function getSvmGatewayLogIndexFromTx(txResp: any, preferPC20?: boolean): number;

package/src/lib/orchestrator/internals/svm-helpers.js

@@ -74,30 +74,30 @@ function buildSvmUniversalTxRequestFromReq(req, revertRecipient, signatureDataOv
         amount: req.amount,
         payload: req.payload,
         revertRecipient,
-        signatureData: signatureDataOverride !== null && signatureDataOverride !== void 0 ? signatureDataOverride : req.signatureData,
+        signatureData: signatureDataOverride ?? req.signatureData,
     });
 }
 // ============================================================================
 // SVM Protocol Fee
 // ============================================================================
-function getSvmProtocolFee(svmClient, programId) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e;
-        const [feeVaultPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('fee_vault')], programId);
-        try {
-            const feeVault = yield svmClient.readContract({
-                abi: universalGatewayV0_json_1.default,
-                address: universalGatewayV0_json_1.default.address,
-                functionName: 'feeVault',
-                args: [feeVaultPda.toBase58()],
-            });
-            const protocolFeeLamports = BigInt((_e = (_d = ((_c = (_b = (_a = feeVault.inboundFeeLamports) !== null && _a !== void 0 ? _a : feeVault.inbound_fee_lamports) !== null && _b !== void 0 ? _b : feeVault.protocolFeeLamports) !== null && _c !== void 0 ? _c : feeVault.protocol_fee_lamports)) === null || _d === void 0 ? void 0 : _d.toString()) !== null && _e !== void 0 ? _e : '0');
-            return { feeVaultPda, protocolFeeLamports };
-        }
-        catch (_f) {
-            return { feeVaultPda, protocolFeeLamports: BigInt(0) };
-        }
-    });
+async function getSvmProtocolFee(svmClient, programId) {
+    const [feeVaultPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('fee_vault')], programId);
+    try {
+        const feeVault = await svmClient.readContract({
+            abi: universalGatewayV0_json_1.default,
+            address: universalGatewayV0_json_1.default.address,
+            functionName: 'feeVault',
+            args: [feeVaultPda.toBase58()],
+        });
+        const protocolFeeLamports = BigInt((feeVault.inboundFeeLamports ??
+            feeVault.inbound_fee_lamports ??
+            feeVault.protocolFeeLamports ??
+            feeVault.protocol_fee_lamports)?.toString() ?? '0');
+        return { feeVaultPda, protocolFeeLamports };
+    }
+    catch {
+        return { feeVaultPda, protocolFeeLamports: BigInt(0) };
+    }
 }
 // ============================================================================
 // SVM Log Parsing
@@ -106,14 +106,51 @@ function getSvmProtocolFee(svmClient, programId) {
 const SVM_GATEWAY_EVENT_DISCRIMINATOR = '6c9ad829b5ea1d7c';
 // ============================================================================
 // ============================================================================
-function getSvmGatewayLogIndexFromTx(txResp) {
-    var _a;
-    const logs = (((_a = txResp === null || txResp === void 0 ? void 0 : txResp.meta) === null || _a === void 0 ? void 0 : _a.logMessages) || []);
+/**
+ * Does this decoded `UniversalTx` event body carry a PC20-selector payload?
+ *
+ * Borsh layout after the 8-byte discriminator: sender(32) ++ recipient(20) ++
+ * token(32) ++ amount(8) ++ payload_len(u32 LE) ++ payload. The gateway stamps
+ * the `PC20` selector (ASCII, 0x50433230) on the front of the payload for a
+ * PC20 burn, which is what distinguishes that leg from the native funds leg
+ * emitted by the same transaction.
+ */
+function isPC20EventBody(decoded) {
+    const PAYLOAD_LEN_OFFSET = 8 + 32 + 20 + 32 + 8;
+    if (decoded.length < PAYLOAD_LEN_OFFSET + 4)
+        return false;
+    const view = new DataView(decoded.buffer, decoded.byteOffset, decoded.byteLength);
+    const payloadLen = view.getUint32(PAYLOAD_LEN_OFFSET, true);
+    const start = PAYLOAD_LEN_OFFSET + 4;
+    if (payloadLen < 4 || decoded.length < start + 4)
+        return false;
+    return (decoded[start] === 0x50 &&
+        decoded[start + 1] === 0x43 &&
+        decoded[start + 2] === 0x32 &&
+        decoded[start + 3] === 0x30);
+}
+/**
+ * Locate the gateway event whose UTX the caller should track.
+ *
+ * Default: the second gateway event when there are two (a gas leg followed by
+ * the funds leg), else the last one.
+ *
+ * `preferPC20` inverts that for PC20 wrapper burns. Such a transaction emits
+ * the PC20 burn event first and then, when native value rides along, a plain
+ * funds event for the gas deposit — so the default would track the deposit
+ * leg. A failure crediting that deposit (the known chain-side fee-credit bug)
+ * would then be reported as the whole transfer failing, even though the tokens
+ * arrived via the first event. Selection is by payload selector rather than
+ * position, so it survives a change in emission order.
+ */
+function getSvmGatewayLogIndexFromTx(txResp, preferPC20 = false) {
+    const logs = (txResp?.meta?.logMessages || []);
     if (!Array.isArray(logs) || logs.length === 0)
         return 0;
     const prefix = 'Program data: ';
     let matchCount = 0;
     let lastMatchIndex = -1;
+    let pc20MatchIndex = -1;
     for (let i = 0; i < logs.length; i++) {
         const log = logs[i] || '';
         if (!log.startsWith(prefix))
@@ -123,7 +160,7 @@ function getSvmGatewayLogIndexFromTx(txResp) {
         try {
             decoded = new Uint8Array(Buffer.from(base64Data, 'base64'));
         }
-        catch (_b) {
+        catch {
             continue;
         }
         if (!decoded || decoded.length < 8)
@@ -132,10 +169,17 @@ function getSvmGatewayLogIndexFromTx(txResp) {
         if (discriminatorHex === SVM_GATEWAY_EVENT_DISCRIMINATOR) {
             matchCount++;
             lastMatchIndex = i;
-            if (matchCount === 2)
+            if (preferPC20 && pc20MatchIndex === -1 && isPC20EventBody(decoded)) {
+                pc20MatchIndex = i;
+            }
+            // Default selection returns eagerly on the second event; when looking
+            // for the PC20 leg the scan must continue so ordering cannot matter.
+            if (!preferPC20 && matchCount === 2)
                 return i;
         }
     }
+    if (preferPC20 && pc20MatchIndex !== -1)
+        return pc20MatchIndex;
     if (lastMatchIndex !== -1)
         return lastMatchIndex;
     return 0;