@pushchain/core 5.1.3 → 5.1.4-alpha.1

package/src/lib/orchestrator/internals/signing.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Signing and payload encoding functions extracted from Orchestrator.
+ */
+import type { UniversalPayload } from '../../generated/v1/tx';
+import type { OrchestratorContext } from './context';
+export declare function computeExecutionHash(ctx: OrchestratorContext, { verifyingContract, payload, version, }: {
+    verifyingContract: `0x${string}`;
+    version?: string;
+    payload: UniversalPayload;
+}): `0x${string}`;
+export declare function computeMigrationHash(ctx: OrchestratorContext, { verifyingContract, migrationContractAddress, nonce, deadline, version, }: {
+    verifyingContract: `0x${string}`;
+    migrationContractAddress: `0x${string}`;
+    nonce: bigint;
+    deadline: bigint;
+    version?: string;
+}): `0x${string}`;
+export declare function signUniversalPayload(ctx: OrchestratorContext, universalPayload: UniversalPayload, verifyingContract: `0x${string}`, version?: string): Promise<Uint8Array>;
+export declare function signMigrationPayload(ctx: OrchestratorContext, { migrationContractAddress, nonce, deadline, ueaVersion, ueaAddress, }: {
+    migrationContractAddress: `0x${string}`;
+    nonce: bigint;
+    deadline: bigint;
+    ueaVersion: string;
+    ueaAddress: `0x${string}`;
+}): Promise<Uint8Array>;
+export declare function encodeUniversalPayload(payload: UniversalPayload): `0x${string}`;
+export declare function encodeUniversalPayloadSvm(payload: UniversalPayload): Buffer;

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

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Signing and payload encoding functions extracted from Orchestrator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeExecutionHash = computeExecutionHash;
+exports.computeMigrationHash = computeMigrationHash;
+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");
+// ============================================================================
+// EIP-712 Domain Separator (shared by execution & migration hashes)
+// ============================================================================
+function buildDomainSeparator(vm, chainId, version, verifyingContract) {
+    const domainTypeHash = (0, viem_1.keccak256)((0, viem_1.toBytes)(vm === enums_1.VM.EVM
+        ? 'EIP712Domain(string version,uint256 chainId,address verifyingContract)'
+        : 'EIP712Domain_SVM(string version,string chainId,address verifyingContract)'));
+    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        { name: 'typeHash', type: 'bytes32' },
+        { name: 'version', type: 'bytes32' },
+        { name: 'chainId', type: vm === enums_1.VM.EVM ? 'uint256' : 'string' },
+        { name: 'verifyingContract', type: 'address' },
+    ], [
+        domainTypeHash,
+        (0, viem_1.keccak256)((0, viem_1.toBytes)(version)),
+        vm === enums_1.VM.EVM ? BigInt(chainId) : chainId,
+        verifyingContract,
+    ]));
+}
+// ============================================================================
+// EIP-712 Hash Computation
+// ============================================================================
+function computeExecutionHash(ctx, { verifyingContract, payload, version = '0.1.0', }) {
+    const chain = ctx.universalSigner.account.chain;
+    const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+    const typeHash = (0, viem_1.keccak256)((0, viem_1.toBytes)('UniversalPayload(address to,uint256 value,bytes data,uint256 gasLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,uint256 nonce,uint256 deadline,uint8 vType)'));
+    const domainSeparator = buildDomainSeparator(vm, chainId, version, verifyingContract);
+    const structHash = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        { name: 'typeHash', type: 'bytes32' },
+        { name: 'to', type: 'address' },
+        { name: 'value', type: 'uint256' },
+        { name: 'data', type: 'bytes32' },
+        { name: 'gasLimit', type: 'uint256' },
+        { name: 'maxFeePerGas', type: 'uint256' },
+        { name: 'maxPriorityFeePerGas', type: 'uint256' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'deadline', type: 'uint256' },
+        { name: 'vType', type: 'uint8' },
+    ], [
+        typeHash,
+        payload.to,
+        BigInt(payload.value),
+        (0, viem_1.keccak256)(payload.data),
+        BigInt(payload.gasLimit),
+        BigInt(payload.maxFeePerGas),
+        BigInt(payload.maxPriorityFeePerGas),
+        BigInt(payload.nonce),
+        BigInt(payload.deadline),
+        payload.vType,
+    ]));
+    return (0, viem_1.keccak256)((0, viem_1.encodePacked)(['string', 'bytes32', 'bytes32'], ['\x19\x01', domainSeparator, structHash]));
+}
+function computeMigrationHash(ctx, { verifyingContract, migrationContractAddress, nonce, deadline, version = '0.1.0', }) {
+    const chain = ctx.universalSigner.account.chain;
+    const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+    const typeHash = (0, viem_1.keccak256)((0, viem_1.toBytes)('MigrationPayload(address migration,uint256 nonce,uint256 deadline)'));
+    const domainSeparator = buildDomainSeparator(vm, chainId, version, verifyingContract);
+    const structHash = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        { name: 'typeHash', type: 'bytes32' },
+        { name: 'migration', type: 'address' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'deadline', type: 'uint256' },
+    ], [typeHash, migrationContractAddress, nonce, deadline]));
+    return (0, viem_1.keccak256)((0, viem_1.encodePacked)(['string', 'bytes32', 'bytes32'], ['\x19\x01', domainSeparator, structHash]));
+}
+// ============================================================================
+// 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,
+                });
+            }
+            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(),
+                    },
+                });
+            }
+            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
+// ============================================================================
+function encodeUniversalPayload(payload) {
+    return (0, viem_1.encodeAbiParameters)([
+        { 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' },
+    ], [
+        payload.to,
+        BigInt(payload.value),
+        payload.data,
+        BigInt(payload.gasLimit),
+        BigInt(payload.maxFeePerGas),
+        BigInt(payload.maxPriorityFeePerGas),
+        BigInt(payload.nonce),
+        BigInt(payload.deadline),
+        Number(payload.vType),
+    ]);
+}
+function encodeUniversalPayloadSvm(payload) {
+    const writeU64 = (val) => {
+        const b = Buffer.alloc(8);
+        b.writeBigUInt64LE(BigInt(val), 0);
+        return b;
+    };
+    const writeI64 = (val) => {
+        const b = Buffer.alloc(8);
+        b.writeBigInt64LE(BigInt(val), 0);
+        return b;
+    };
+    const writeVecU8 = (val) => {
+        const bytes = Buffer.isBuffer(val)
+            ? val
+            : Buffer.from(val);
+        const len = Buffer.alloc(4);
+        len.writeUInt32LE(bytes.length, 0);
+        return Buffer.concat([len, bytes]);
+    };
+    const writeU8 = (val) => Buffer.from([val]);
+    const toAddrBytes = (() => {
+        const to = payload.to;
+        const hex = to.slice(2).padStart(40, '0');
+        return Buffer.from(hex, 'hex');
+    })();
+    const valueBytes = writeU64(payload.value);
+    const dataBytes = (() => {
+        const data = payload.data;
+        const hex = data.slice(2);
+        const buf = hex.length ? Buffer.from(hex, 'hex') : Buffer.alloc(0);
+        return writeVecU8(buf);
+    })();
+    const gasLimitBytes = writeU64(payload.gasLimit);
+    const maxFeePerGasBytes = writeU64(payload.maxFeePerGas);
+    const maxPriorityFeePerGasBytes = writeU64(payload.maxPriorityFeePerGas);
+    const nonceBytes = writeU64(payload.nonce);
+    const deadlineBytes = writeI64(payload.deadline);
+    const vTypeVal = (() => {
+        const v = payload.vType;
+        if (typeof v === 'number')
+            return v;
+        if (typeof v === 'string')
+            return Number(v);
+        return 0;
+    })();
+    const vTypeBytes = writeU8(vTypeVal);
+    return Buffer.concat([
+        toAddrBytes,
+        valueBytes,
+        dataBytes,
+        gasLimitBytes,
+        maxFeePerGasBytes,
+        maxPriorityFeePerGasBytes,
+        nonceBytes,
+        deadlineBytes,
+        vTypeBytes,
+    ]);
+}
+//# sourceMappingURL=signing.js.map

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

@@ -0,0 +1,21 @@
+/**
+ * SVM (Solana) bridge transaction for funds+payload flow —
+ * extracted from Orchestrator._sendSVMTxWithFunds.
+ *
+ * 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 { 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;
+    mechanism: 'native' | 'approve' | 'permit2' | string;
+    universalPayload: UniversalPayload;
+    bridgeAmount: bigint;
+    nativeAmount: bigint;
+    req: UniversalTxRequest;
+}): Promise<string>;

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

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * SVM (Solana) bridge transaction for funds+payload flow —
+ * extracted from Orchestrator._sendSVMTxWithFunds.
+ *
+ * Handles both native SOL and SPL token bridging with universal payload signing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendSVMTxWithFunds = sendSVMTxWithFunds;
+const tslib_1 = require("tslib");
+const web3_js_1 = require("@solana/web3.js");
+const viem_1 = require("viem");
+const universalGatewayV0_json_1 = tslib_1.__importDefault(require("../../constants/abi/universalGatewayV0.json"));
+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 signing_1 = require("./signing");
+const uea_manager_1 = require("./uea-manager");
+// ============================================================================
+// sendSVMTxWithFunds
+// ============================================================================
+/**
+ * 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,
+                },
+            });
+        }
+    });
+}
+//# sourceMappingURL=svm-bridge.js.map

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

@@ -0,0 +1,35 @@
+/**
+ * SVM (Solana) specific helper functions extracted from Orchestrator.
+ */
+import { PublicKey } from '@solana/web3.js';
+import type { UniversalTxRequest } from '../orchestrator.types';
+export declare function buildSvmUniversalTxRequest({ recipient, token, amount, payload, revertRecipient, signatureData, }: {
+    recipient: number[];
+    token: PublicKey;
+    amount: bigint;
+    payload: `0x${string}` | Uint8Array;
+    revertRecipient: PublicKey;
+    signatureData?: Uint8Array | `0x${string}`;
+}): {
+    recipient: number[];
+    token: PublicKey;
+    amount: bigint;
+    payload: Buffer;
+    revertRecipient: PublicKey;
+    signatureData: Buffer;
+};
+export declare function buildSvmUniversalTxRequestFromReq(req: UniversalTxRequest, revertRecipient: PublicKey, signatureDataOverride?: Uint8Array | `0x${string}`): {
+    recipient: number[];
+    token: PublicKey;
+    amount: bigint;
+    payload: Buffer;
+    revertRecipient: PublicKey;
+    signatureData: Buffer;
+};
+export declare function getSvmProtocolFee(svmClient: {
+    readContract: (args: any) => Promise<any>;
+}, programId: PublicKey): Promise<{
+    feeVaultPda: PublicKey;
+    protocolFeeLamports: bigint;
+}>;
+export declare function getSvmGatewayLogIndexFromTx(txResp: any): number;

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

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * SVM (Solana) specific helper functions extracted from Orchestrator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSvmUniversalTxRequest = buildSvmUniversalTxRequest;
+exports.buildSvmUniversalTxRequestFromReq = buildSvmUniversalTxRequestFromReq;
+exports.getSvmProtocolFee = getSvmProtocolFee;
+exports.getSvmGatewayLogIndexFromTx = getSvmGatewayLogIndexFromTx;
+const tslib_1 = require("tslib");
+const web3_js_1 = require("@solana/web3.js");
+const viem_1 = require("viem");
+const universalGatewayV0_json_1 = tslib_1.__importDefault(require("../../constants/abi/universalGatewayV0.json"));
+// ============================================================================
+// SVM Request Builders
+// ============================================================================
+function buildSvmUniversalTxRequest({ recipient, token, amount, payload, revertRecipient, signatureData, }) {
+    const payloadBuf = typeof payload === 'string' && payload.startsWith('0x')
+        ? (() => {
+            const hex = payload.slice(2);
+            if (!hex.length)
+                return Buffer.alloc(0);
+            const normalized = hex.length % 2 === 1 ? `0${hex}` : hex;
+            return Buffer.from(normalized, 'hex');
+        })()
+        : Buffer.from(payload);
+    let signatureBuf;
+    if (!signatureData) {
+        signatureBuf = Buffer.alloc(0);
+    }
+    else if (typeof signatureData === 'string' &&
+        signatureData.startsWith('0x')) {
+        const hex = signatureData.slice(2);
+        if (!hex.length) {
+            signatureBuf = Buffer.alloc(0);
+        }
+        else {
+            const normalized = hex.length % 2 === 1 ? `0${hex}` : hex;
+            signatureBuf = Buffer.from(normalized, 'hex');
+        }
+    }
+    else {
+        signatureBuf = Buffer.from(signatureData);
+    }
+    return {
+        recipient,
+        token,
+        amount,
+        payload: payloadBuf,
+        revertRecipient,
+        signatureData: signatureBuf,
+    };
+}
+function buildSvmUniversalTxRequestFromReq(req, revertRecipient, signatureDataOverride) {
+    const recipientBytes = (0, viem_1.hexToBytes)(req.recipient);
+    const recipient = Array.from(recipientBytes.subarray(0, 20));
+    const tokenAddress = req.token;
+    let token;
+    if (tokenAddress === viem_1.zeroAddress || tokenAddress === 'solana-native') {
+        token = web3_js_1.PublicKey.default;
+    }
+    else {
+        if (!tokenAddress.startsWith('0x')) {
+            throw new Error('Unsupported token format for SVM UniversalTxRequest: ' + tokenAddress);
+        }
+        const token20 = (0, viem_1.hexToBytes)(tokenAddress);
+        const token32 = new Uint8Array(32);
+        token32.set(token20, 12);
+        token = new web3_js_1.PublicKey(token32);
+    }
+    return buildSvmUniversalTxRequest({
+        recipient,
+        token,
+        amount: req.amount,
+        payload: req.payload,
+        revertRecipient,
+        signatureData: signatureDataOverride !== null && signatureDataOverride !== void 0 ? signatureDataOverride : req.signatureData,
+    });
+}
+// ============================================================================
+// SVM Protocol Fee
+// ============================================================================
+function getSvmProtocolFee(svmClient, programId) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        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((_c = (_b = ((_a = feeVault.protocolFeeLamports) !== null && _a !== void 0 ? _a : feeVault.protocol_fee_lamports)) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : '0');
+            return { feeVaultPda, protocolFeeLamports };
+        }
+        catch (_d) {
+            return { feeVaultPda, protocolFeeLamports: BigInt(0) };
+        }
+    });
+}
+// ============================================================================
+// SVM Log Parsing
+// ============================================================================
+/** Anchor event discriminator for the SVM gateway's UniversalTxSent event */
+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) || []);
+    if (!Array.isArray(logs) || logs.length === 0)
+        return 0;
+    const prefix = 'Program data: ';
+    let matchCount = 0;
+    let lastMatchIndex = -1;
+    for (let i = 0; i < logs.length; i++) {
+        const log = logs[i] || '';
+        if (!log.startsWith(prefix))
+            continue;
+        const base64Data = log.slice(prefix.length).trim();
+        let decoded = null;
+        try {
+            decoded = new Uint8Array(Buffer.from(base64Data, 'base64'));
+        }
+        catch (_b) {
+            continue;
+        }
+        if (!decoded || decoded.length < 8)
+            continue;
+        const discriminatorHex = (0, viem_1.bytesToHex)(decoded.slice(0, 8)).slice(2);
+        if (discriminatorHex === SVM_GATEWAY_EVENT_DISCRIMINATOR) {
+            matchCount++;
+            lastMatchIndex = i;
+            if (matchCount === 2)
+                return i;
+        }
+    }
+    if (lastMatchIndex !== -1)
+        return lastMatchIndex;
+    return 0;
+}
+//# sourceMappingURL=svm-helpers.js.map

package/src/lib/orchestrator/internals/tx-transformer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Transaction response/receipt transformation and progress reconstruction,
+ * extracted from Orchestrator.
+ */
+import { TransactionReceipt } from 'viem';
+import type { UniversalTxV2 } from '../../generated/uexecutor/v2/types';
+import { ProgressEvent } from '../../progress-hook/progress-hook.types';
+import { TransactionRoute } from '../route-detector';
+import type { UniversalTxReceipt, UniversalTxResponse } from '../orchestrator.types';
+export declare function transformToUniversalTxReceipt(receipt: TransactionReceipt, originalTxResponse: UniversalTxResponse): UniversalTxReceipt;
+export declare function reconstructProgressEvents(universalTxResponse: UniversalTxResponse, universalTxData?: UniversalTxV2): ProgressEvent[];
+export declare function detectRouteFromUniversalTxData(universalTxData: UniversalTxV2 | undefined): TransactionRoute | undefined;