@sidhujag/sysweb3-keyring 1.0.627 → 1.0.628

package/cjs/transactions/syscoin-core.js

@@ -0,0 +1,651 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyscoinTransactionsCore = exports.createHardwareSignerUnavailableError = void 0;
+const sysweb3_utils_1 = require("@sidhujag/sysweb3-utils");
+const syscoinjs = __importStar(require("syscoinjs-lib"));
+// import { BIP_84, ONE_HUNDRED_MILLION, SYSCOIN_BASIC_FEE } from 'utils';
+const ethers_v6_1 = require("../ethers-v6");
+const types_1 = require("../types");
+const blockbook_cache_1 = require("../utils/blockbook-cache");
+const excluded_utxos_1 = require("../utils/excluded-utxos");
+const psbt_1 = require("../utils/psbt");
+const psbt_account_scope_1 = require("../utils/psbt-account-scope");
+const createHardwareSignerUnavailableError = (hardware) => Object.assign(new Error(`${hardware} signer is unavailable in this host`), {
+    code: 'HARDWARE_SIGNER_UNAVAILABLE',
+});
+exports.createHardwareSignerUnavailableError = createHardwareSignerUnavailableError;
+// Recommended fee changes slowly; cache per explorer to avoid hammering
+// Blockbook while the user edits amounts on the send screen
+const FEE_CACHE_TTL_MS = 60000;
+const sweepError = (code, message) => ({
+    error: true,
+    code,
+    message,
+});
+const sweepAtomicValue = (value) => {
+    const text = typeof value === 'number'
+        ? Number.isSafeInteger(value)
+            ? String(value)
+            : ''
+        : typeof value === 'string' ||
+            typeof value === 'bigint' ||
+            syscoinjs.utils.BN.isBN(value)
+            ? value.toString()
+            : '';
+    if (!/^\d+$/.test(text))
+        throw sweepError('INVALID_NATIVE_SWEEP_UTXOS', 'Invalid native sweep atomic value.');
+    return new syscoinjs.utils.BN(text);
+};
+class SyscoinTransactionsCore {
+    constructor(getSyscoinSigner, getReadOnlySigner, getState, getAddress, hardwareSigners = {}, captureSigningContext) {
+        this.getTransactionPSBT = async ({ txOptions, outputs, changeAddress, feeRateBN, xpub, fundingUtxos, }, main) => {
+            try {
+                // Use syscoinjs-lib directly for transaction creation
+                const result = await main.createTransaction(txOptions, changeAddress, outputs, feeRateBN, xpub, // sysFromXpubOrAddress
+                ...(fundingUtxos ? [fundingUtxos] : []));
+                if (result && result.psbt) {
+                    return { psbt: result.psbt, fee: result.fee };
+                }
+                throw new Error('psbt not found');
+            }
+            catch (error) {
+                // Propagate structured error from syscoinjs-lib
+                if (error.error && error.code) {
+                    throw error;
+                }
+                // Wrap non-structured errors
+                throw {
+                    error: true,
+                    code: 'TRANSACTION_CREATION_FAILED',
+                    message: error.message || 'Failed to create transaction',
+                    details: error,
+                };
+            }
+        };
+        this.decodeRawTransaction = (psbtOrHex, isRawHex = false) => {
+            const { main } = this.getReadOnlySigner();
+            if (isRawHex) {
+                // Handle raw transaction hex
+                const bitcoinTx = syscoinjs.utils.bitcoinjs.Transaction.fromHex(psbtOrHex);
+                return main.decodeRawTransaction(bitcoinTx);
+            }
+            else {
+                // Handle PSBT format (existing behavior)
+                const psbtObj = psbt_1.PsbtUtils.fromPali(psbtOrHex, this.getState().activeNetwork);
+                return main.decodeRawTransaction(psbtObj);
+            }
+        };
+        this.feeCache = new Map();
+        this.getRecommendedFee = async (explorerUrl) => {
+            const cached = this.feeCache.get(explorerUrl);
+            if (cached && Date.now() - cached.timestamp < FEE_CACHE_TTL_MS) {
+                return cached.fee;
+            }
+            const fee = (await syscoinjs.utils.fetchEstimateFee(explorerUrl, 1)) / 1024;
+            this.feeCache.set(explorerUrl, { fee, timestamp: Date.now() });
+            return fee;
+        };
+        this.txUtilsFunctions = () => {
+            const { getRawTransaction } = (0, sysweb3_utils_1.txUtils)();
+            return {
+                getRawTransaction,
+            };
+        };
+        // Internal method for signing with the HD signer
+        this.signPSBTWithSigner = async ({ psbt, signer, }) => await signer.sign(psbt);
+        this.createNativeSweepPSBT = async ({ txOptions, changeAddress, receivingAddress, feeRateBN, source, excluded, }, main) => {
+            const raw = await syscoinjs.utils.fetchBackendUTXOS(main.blockbookURL, source);
+            const rows = excluded.size
+                ? (0, excluded_utxos_1.filterExcludedUtxos)(raw, excluded).utxos
+                : Array.isArray(raw)
+                    ? raw
+                    : raw?.utxos;
+            if (!Array.isArray(rows))
+                throw sweepError('INVALID_NATIVE_SWEEP_UTXOS', 'Invalid native sweep UTXO response.');
+            const seen = new Set();
+            const expected = new Set();
+            let gross = new syscoinjs.utils.BN(0);
+            const utxos = [];
+            for (const row of rows) {
+                const txid = row?.txId ?? row?.txid;
+                if (typeof txid !== 'string' ||
+                    !/^[0-9a-fA-F]{64}$/.test(txid) ||
+                    !Number.isSafeInteger(row.vout) ||
+                    row.vout < 0 ||
+                    row.vout > 0xffffffff ||
+                    (row.txId !== undefined &&
+                        row.txid !== undefined &&
+                        row.txId !== row.txid) ||
+                    (row.assetInfo != null &&
+                        (typeof row.assetInfo !== 'object' || Array.isArray(row.assetInfo))))
+                    throw sweepError('INVALID_NATIVE_SWEEP_UTXOS', 'Invalid native sweep outpoint.');
+                const outpoint = `${txid.toLowerCase()}:${row.vout}`;
+                if (seen.has(outpoint))
+                    throw sweepError('INVALID_NATIVE_SWEEP_UTXOS', 'Duplicate native sweep outpoint.');
+                seen.add(outpoint);
+                const value = sweepAtomicValue(row.value);
+                // Native MAX must leave asset carriers and their allocations untouched.
+                if (row.assetInfo != null)
+                    continue;
+                expected.add(outpoint);
+                gross = gross.add(value);
+                utxos.push({ ...row, value });
+            }
+            if (gross.isZero())
+                throw sweepError('INSUFFICIENT_FUNDS', 'No native UTXOs are available to sweep.');
+            // The library sanitizes this snapshot once; its optional UTXO argument
+            // prevents a second funding lookup between resolving MAX and building it.
+            const result = await main.createTransaction(txOptions, changeAddress, [{ address: receivingAddress, value: gross, subtractFeeFrom: true }], feeRateBN, source, { utxos, assets: new Map() });
+            const inputs = result.psbt?.txInputs;
+            const outputs = result.psbt?.txOutputs;
+            const selected = Array.isArray(inputs)
+                ? inputs.map((input) => `${Buffer.from(input.hash).reverse().toString('hex')}:${input.index}`)
+                : [];
+            if (selected.length !== expected.size ||
+                new Set(selected).size !== expected.size ||
+                selected.some((outpoint) => !expected.has(outpoint)) ||
+                !Array.isArray(outputs) ||
+                outputs.length !== 1)
+                throw sweepError('INCOMPLETE_NATIVE_SWEEP', 'The builder did not preserve the complete native sweep.');
+            const script = syscoinjs.utils.bitcoinjs.address.toOutputScript(receivingAddress, main.network);
+            const recipient = sweepAtomicValue(outputs[0].value);
+            const fee = sweepAtomicValue(result.fee);
+            if (!Buffer.from(outputs[0].script).equals(Buffer.from(script)) ||
+                recipient.isZero() ||
+                !recipient.add(fee).eq(gross))
+                throw sweepError('INCOMPLETE_NATIVE_SWEEP', 'The native sweep amounts do not match its PSBT.');
+            return {
+                psbt: result.psbt,
+                fee: result.fee,
+                grossAmount: (0, ethers_v6_1.formatUnits)(gross.toString(), 8).replace(/\.0$/, ''),
+                recipientAmount: (0, ethers_v6_1.formatUnits)(recipient.toString(), 8).replace(/\.0$/, ''),
+            };
+        };
+        // Create unsigned PSBT for any transaction type
+        this.createUnsignedPSBT = async ({ txOptions = {}, isMax = false, nativeSweep = false, amount, receivingAddress, feeRateBN, token = null, excludedOutpoints = [], }) => {
+            // Ensure RBF is enabled by default if not explicitly set
+            const finalTxOptions = { rbf: true, ...txOptions };
+            const { activeAccountId, accounts, activeAccountType } = this.getState();
+            // Use read-only signer since we're just creating an unsigned PSBT
+            const { main } = this.getReadOnlySigner();
+            const account = accounts[activeAccountType]?.[activeAccountId];
+            if (!account) {
+                throw new Error('Active account not found');
+            }
+            const xpub = account.xpub;
+            const isSingleAddressImported = activeAccountType === types_1.KeyringAccountType.Imported &&
+                xpub === account.address;
+            // For imported extended-key accounts we store BIP84 xpubs (zpub/vpub).
+            // Blockbook derives different address branches depending on version bytes, so preserve xpub as-is.
+            const sourceForUtxoLookup = isSingleAddressImported
+                ? account.address
+                : xpub;
+            // Convert amount to satoshis (1 SYS = 1e8 satoshis)
+            // Using BigNumber to prevent precision loss
+            const amountStr = amount.toString();
+            // Safe conversion without parseFloat to avoid precision loss
+            // Split the string to handle decimal values properly
+            const parts = amountStr.split('.');
+            const integerPart = parts[0] || '0';
+            const decimalPart = parts[1] || '';
+            // Pad or truncate decimal part to 8 places (satoshi precision)
+            const paddedDecimal = decimalPart.padEnd(8, '0').substring(0, 8);
+            // Combine to get satoshis (integer + decimal as one number)
+            const satoshiStr = integerPart + paddedDecimal;
+            // Remove leading zeros but keep at least one digit
+            const trimmedSatoshis = satoshiStr.replace(/^0+/, '') || '0';
+            const value = new syscoinjs.utils.BN(trimmedSatoshis);
+            // If this is a single-address imported account (WIF import), use the account.address for both from and change
+            const changeAddress = isSingleAddressImported
+                ? account.address
+                : await this.getAddress(xpub, true);
+            try {
+                const excluded = (0, excluded_utxos_1.excludedOutpointIds)(excludedOutpoints);
+                if (nativeSweep) {
+                    return await this.createNativeSweepPSBT({
+                        txOptions: finalTxOptions,
+                        changeAddress,
+                        receivingAddress,
+                        feeRateBN,
+                        source: sourceForUtxoLookup,
+                        excluded,
+                    }, main);
+                }
+                const fundingUtxos = excluded.size
+                    ? (0, excluded_utxos_1.filterExcludedUtxos)(await syscoinjs.utils.fetchBackendUTXOS(main.blockbookURL, sourceForUtxoLookup), excluded)
+                    : undefined;
+                if (token && token.guid) {
+                    // Token transaction: use assetAllocationSend
+                    // Create a Map for the asset allocation
+                    const assetMap = new Map();
+                    assetMap.set(token.guid, {
+                        changeAddress,
+                        outputs: [
+                            {
+                                value: value,
+                                address: receivingAddress,
+                            },
+                        ],
+                    });
+                    // Pass xpub to get back just the PSBT without signing and sending
+                    // syscoinjs-lib will validate asset existence and sufficient balance
+                    const result = await main.assetAllocationSend(finalTxOptions, assetMap, changeAddress, feeRateBN, sourceForUtxoLookup, // Pass source (address for WIF imports, zpub/vpub for HD)
+                    ...(fundingUtxos ? [fundingUtxos] : []));
+                    if (excluded.size)
+                        (0, excluded_utxos_1.assertNoExcludedInputs)(result.psbt, excluded);
+                    // Return PSBT and fee
+                    return { psbt: result.psbt, fee: result.fee };
+                }
+                else {
+                    // Native transaction: use getTransactionPSBT to create unsigned PSBT
+                    const outputs = [
+                        {
+                            address: receivingAddress,
+                            value: value, // Pass BN object directly
+                            ...(isMax && { subtractFeeFrom: true }), // Only add subtractFeeFrom if isMax is true
+                        },
+                    ];
+                    const result = await this.getTransactionPSBT({
+                        txOptions: finalTxOptions,
+                        outputs,
+                        changeAddress,
+                        feeRateBN,
+                        xpub: sourceForUtxoLookup,
+                        fundingUtxos,
+                    }, main);
+                    if (excluded.size)
+                        (0, excluded_utxos_1.assertNoExcludedInputs)(result.psbt, excluded);
+                    return result;
+                }
+            }
+            catch (error) {
+                // Re-throw structured errors from syscoinjs-lib
+                if (error.error && error.code) {
+                    throw error;
+                }
+                // Wrap other errors in structured format
+                throw {
+                    error: true,
+                    code: 'TRANSACTION_CREATION_FAILED',
+                    message: error.message || 'Failed to create unsigned PSBT',
+                    details: error,
+                };
+            }
+        };
+        // Sign PSBT with appropriate method - separated for better error handling
+        this.signPSBTWithMethod = async (psbt, isTrezor, isLedger = false) => {
+            const { activeNetwork, activeAccountId, activeAccountType, accounts } = this.getState();
+            const account = accounts[activeAccountType]?.[activeAccountId];
+            if (!account)
+                throw new Error('Active account not found');
+            // Device choice belongs to the selected account, never to PSBT/caller flags.
+            isTrezor =
+                activeAccountType === types_1.KeyringAccountType.Trezor ||
+                    account.isTrezorWallet === true;
+            isLedger =
+                activeAccountType === types_1.KeyringAccountType.Ledger ||
+                    account.isLedgerWallet === true;
+            const assertSession = this.captureSigningContext?.() || (() => undefined);
+            // The adapter gets a detached, immutable public context. It must not be
+            // able to mutate the wallet state or the baseline used by assertCurrent.
+            const scope = Object.freeze({
+                account: Object.freeze({ address: account.address, xpub: account.xpub }),
+                accountId: activeAccountId,
+                accountType: activeAccountType,
+                network: Object.freeze({ ...activeNetwork }),
+            });
+            const assertCurrent = () => {
+                assertSession();
+                const current = this.getState();
+                const selected = current.accounts[current.activeAccountType]?.[current.activeAccountId];
+                if (current.activeAccountId !== activeAccountId ||
+                    current.activeAccountType !== activeAccountType ||
+                    selected?.address !== scope.account.address ||
+                    selected?.xpub !== scope.account.xpub ||
+                    current.activeNetwork.kind !== scope.network.kind ||
+                    current.activeNetwork.chainId !== scope.network.chainId ||
+                    current.activeNetwork.slip44 !== scope.network.slip44 ||
+                    current.activeNetwork.url !== scope.network.url) {
+                    throw new Error('Wallet signing context changed');
+                }
+            };
+            assertCurrent();
+            const sign = isLedger
+                ? this.hardwareSigners.ledger
+                : isTrezor
+                    ? this.hardwareSigners.trezor
+                    : undefined;
+            if ((isLedger || isTrezor) && typeof sign !== 'function')
+                throw (0, exports.createHardwareSignerUnavailableError)(isLedger ? 'Ledger' : 'Trezor');
+            if (isTrezor || isLedger)
+                (0, psbt_account_scope_1.assertPsbtAccountScope)(psbt, scope);
+            if (isLedger || isTrezor) {
+                const signed = await sign({
+                    psbt,
+                    account: Object.freeze({ id: account.id, xpub: account.xpub }),
+                    network: scope.network,
+                    scope,
+                    assertCurrent,
+                    ...(isLedger && {
+                        getRawTransaction: this.txUtilsFunctions().getRawTransaction,
+                    }),
+                });
+                assertCurrent();
+                return signed;
+            }
+            else {
+                // HD signing (seed-based HDAccount or imported BIP84 zprv/vprv account).
+                // Some Blockbook deployments return UTXOs without per-input derivation `path`,
+                // which causes bitcoinjs-lib to throw "Need derivation path to sign with HD".
+                //
+                // We can recover by enriching PSBT inputs with a proprietary `path` field using
+                // Blockbook's xpub token list (address -> path mapping), which reliably includes paths.
+                try {
+                    const account = accounts[activeAccountType]?.[activeAccountId];
+                    const accountXpub = account?.xpub;
+                    const accountAddress = account?.address;
+                    const isSingleAddressImported = activeAccountType === types_1.KeyringAccountType.Imported &&
+                        Boolean(accountXpub) &&
+                        Boolean(accountAddress) &&
+                        accountXpub === accountAddress;
+                    const isImportedExtended = activeAccountType === types_1.KeyringAccountType.Imported &&
+                        Boolean(accountXpub) &&
+                        !isSingleAddressImported;
+                    // IMPORTANT: Imported extended keys (zprv/vprv) are typically *account-level* keys.
+                    // syscoinjs-lib signs using the imported key as the BIP32 root, so PSBT `path` must be
+                    // relative (change/index), not the full `m/84'/.../change/index`. If we keep full paths,
+                    // bip32.derivePath can throw, leaving no derivations and causing "Need derivation path".
+                    if (isImportedExtended) {
+                        const inputs = psbt?.data?.inputs || [];
+                        for (const input of inputs) {
+                            const unknowns = input?.unknownKeyVals || [];
+                            const pathKv = unknowns.find((kv) => kv?.key?.toString?.() === 'path');
+                            if (!pathKv?.value)
+                                continue;
+                            const fullPath = String(Buffer.from(pathKv.value).toString());
+                            const parts = fullPath.split('/').filter(Boolean);
+                            // Expected: m/84'/slip44'/account'/change/index
+                            if (parts.length >= 2) {
+                                const change = parts[parts.length - 2];
+                                const index = parts[parts.length - 1];
+                                const rel = `${change}/${index}`;
+                                pathKv.value = Buffer.from(rel);
+                            }
+                        }
+                    }
+                    const needsAnyPath = psbt?.data?.inputs?.some((input) => {
+                        const unknowns = input?.unknownKeyVals || [];
+                        return (!input.bip32Derivation?.length &&
+                            !input.tapBip32Derivation?.length &&
+                            !unknowns.some((kv) => kv?.key?.toString?.() === 'path'));
+                    });
+                    if (needsAnyPath &&
+                        accountXpub &&
+                        !isSingleAddressImported &&
+                        typeof psbt.addUnknownKeyValToInput === 'function') {
+                        // Fetch address->path mapping from Blockbook xpub endpoint
+                        // (in-flight deduplicated with the keyring's getAddress lookups)
+                        const blockbookUrl = activeNetwork.url;
+                        const res = await (0, blockbook_cache_1.fetchBackendAccountCached)(blockbookUrl, accountXpub, 'tokens=used&details=tokens');
+                        const tokens = Array.isArray(res?.tokens) ? res.tokens : [];
+                        const addrToPath = new Map();
+                        for (const t of tokens) {
+                            if (t?.name && t?.path) {
+                                addrToPath.set(String(t.name), String(t.path));
+                            }
+                        }
+                        const inputs = psbt?.data?.inputs || [];
+                        for (let i = 0; i < inputs.length; i++) {
+                            const input = inputs[i];
+                            const unknowns = input?.unknownKeyVals || [];
+                            const hasPath = unknowns.some((kv) => kv?.key?.toString?.() === 'path');
+                            if (hasPath)
+                                continue;
+                            const addrKv = unknowns.find((kv) => kv?.key?.toString?.() === 'address');
+                            const addr = addrKv?.value
+                                ? String(Buffer.from(addrKv.value).toString())
+                                : null;
+                            if (!addr)
+                                continue;
+                            const fullPath = addrToPath.get(addr);
+                            if (!fullPath)
+                                continue;
+                            // Imported extended keys are account-level (BIP84 account node), so we must provide a
+                            // path relative to that node (change/index), not the full m/84'/... path.
+                            const pathForSigner = isImportedExtended
+                                ? (() => {
+                                    const parts = String(fullPath).split('/').filter(Boolean);
+                                    // Expected: m/84'/slip44'/account'/change/index
+                                    if (parts.length >= 2) {
+                                        const change = parts[parts.length - 2];
+                                        const index = parts[parts.length - 1];
+                                        return `${change}/${index}`;
+                                    }
+                                    return fullPath;
+                                })()
+                                : fullPath;
+                            psbt.addUnknownKeyValToInput(i, {
+                                key: Buffer.from('path'),
+                                value: Buffer.from(pathForSigner),
+                            });
+                        }
+                    }
+                }
+                catch (_e) {
+                    // Best-effort enrichment; if it fails, fall back to default signing error path.
+                }
+                assertCurrent();
+                (0, psbt_account_scope_1.assertPsbtAccountScope)(psbt, scope);
+                const { hd } = this.getSigner();
+                const signedPsbt = await this.signPSBTWithSigner({
+                    psbt,
+                    signer: hd,
+                });
+                assertCurrent();
+                return signedPsbt;
+            }
+        };
+        // Create unsigned PSBT and estimate fee - NO SIGNING
+        this.getEstimateSysTransactionFee = async ({ txOptions = {}, isMax = false, nativeSweep = false, amount, receivingAddress, feeRate, token = null, excludedOutpoints = [], }) => {
+            try {
+                if (nativeSweep !== false &&
+                    (nativeSweep !== true || isMax !== true || token !== null))
+                    throw sweepError('INVALID_NATIVE_SWEEP', 'Native sweep requires explicit MAX and a native transaction.');
+                // Ensure RBF is enabled by default if not explicitly set
+                const finalTxOptions = { rbf: true, ...txOptions };
+                // Use read-only signer since we're just estimating fees and creating unsigned PSBT
+                const { main } = this.getReadOnlySigner();
+                // Step 1: Determine fee rate
+                let actualFeeRate;
+                if (feeRate !== undefined) {
+                    actualFeeRate = feeRate;
+                }
+                else {
+                    actualFeeRate = await this.getRecommendedFee(main.blockbookURL);
+                }
+                // Convert fee rate to satoshis/byte and ensure minimum relay of 1 sat/vB
+                // Blockbook returns coins per kB; after division by 1024, some testnets
+                // can yield < 1 sat/vB (e.g., 0.9765625). Round up and clamp to 1 to
+                // avoid zero-fee transactions due to truncation when converting to BN.
+                const satPerByte = Math.max(1, Math.ceil(actualFeeRate * 1e8));
+                const feeRateBN = new syscoinjs.utils.BN(satPerByte);
+                // Step 2: Create unsigned PSBT
+                const result = await this.createUnsignedPSBT({
+                    txOptions: finalTxOptions,
+                    isMax,
+                    nativeSweep,
+                    amount,
+                    receivingAddress,
+                    feeRateBN,
+                    token,
+                    excludedOutpoints,
+                });
+                return {
+                    fee: result.fee / 1e8,
+                    psbt: psbt_1.PsbtUtils.toPali(result.psbt), // Return UNSIGNED PSBT as JSON
+                    ...(nativeSweep
+                        ? {
+                            grossAmount: result.grossAmount,
+                            recipientAmount: result.recipientAmount,
+                        }
+                        : {}),
+                };
+            }
+            catch (error) {
+                // Pass through structured errors from syscoinjs-lib
+                if (error.error && error.code) {
+                    // Convert fee from satoshis to SYS if available
+                    if (error.fee !== undefined) {
+                        // If fee is a BN object, convert to number first
+                        if (typeof error.fee === 'object' && error.fee.toNumber) {
+                            error.fee = error.fee.toNumber() / 1e8;
+                        }
+                        else {
+                            error.fee = error.fee / 1e8;
+                        }
+                    }
+                    if (error.remainingFee !== undefined) {
+                        // If remainingFee is a BN object, convert to number first
+                        if (typeof error.remainingFee === 'object' &&
+                            error.remainingFee.toNumber) {
+                            error.remainingFee = error.remainingFee.toNumber() / 1e8;
+                        }
+                        else {
+                            error.remainingFee = error.remainingFee / 1e8;
+                        }
+                    }
+                    if (error.shortfall !== undefined) {
+                        // If shortfall is a BN object, convert to number first
+                        if (typeof error.shortfall === 'object' && error.shortfall.toNumber) {
+                            error.shortfall = error.shortfall.toNumber() / 1e8;
+                        }
+                        else {
+                            error.shortfall = error.shortfall / 1e8;
+                        }
+                    }
+                    throw error;
+                }
+                // Wrap other errors
+                throw {
+                    error: true,
+                    code: 'TRANSACTION_CREATION_FAILED',
+                    message: error.message || 'Failed to estimate transaction fee',
+                    details: error,
+                };
+            }
+        };
+        // Removed createAndSignSysTransaction - functionality merged into getEstimateSysTransactionFee
+        this.sendSignedTransaction = async (psbt) => {
+            try {
+                // Use read-only signer since we're just broadcasting an already-signed transaction
+                const { main } = this.getReadOnlySigner();
+                // Send the transaction
+                const result = await main.send(psbt);
+                // Extract the transaction ID
+                const txid = result.extractTransaction().getId();
+                return { txid };
+            }
+            catch (error) {
+                // Pass through structured errors
+                if (error.error && error.code) {
+                    throw error;
+                }
+                // Wrap other errors
+                throw {
+                    error: true,
+                    code: 'TRANSACTION_SEND_FAILED',
+                    message: error.message || 'Failed to send transaction',
+                    details: error,
+                };
+            }
+        };
+        this.signPSBT = async ({ psbt, isTrezor = false, isLedger = false, }) => {
+            const psbtObj = psbt_1.PsbtUtils.fromPali(psbt, this.getState().activeNetwork);
+            // Scope validation temporarily removes other signers' hints. Preserve the
+            // public metadata for the next cosigner, without exposing it to our signer.
+            const cosignerMetadata = psbtObj.data.inputs.map((input, index) => ({
+                hash: Buffer.from(psbtObj.txInputs[index].hash),
+                index: psbtObj.txInputs[index].index,
+                bip32Derivation: input.bip32Derivation?.map((value) => ({ ...value })),
+                tapBip32Derivation: input.tapBip32Derivation?.map((value) => ({
+                    ...value,
+                })),
+                path: input.unknownKeyVals
+                    ?.filter((value) => Buffer.from(value.key).toString() === 'path')
+                    .map((value) => ({
+                    key: Buffer.from(value.key),
+                    value: Buffer.from(value.value),
+                }))[0],
+            }));
+            const signedPsbt = await this.signPSBTWithMethod(psbtObj, isTrezor, isLedger);
+            signedPsbt.data.inputs.forEach((input, index) => {
+                if (input.finalScriptSig || input.finalScriptWitness)
+                    return;
+                const metadata = cosignerMetadata[index];
+                if (!metadata)
+                    return;
+                const signed = signedPsbt.txInputs[index];
+                if (!signed ||
+                    metadata.index !== signed.index ||
+                    !metadata.hash.equals(Buffer.from(signed.hash)))
+                    throw new Error('Wallet signing context changed');
+                if (metadata.bip32Derivation)
+                    input.bip32Derivation = metadata.bip32Derivation;
+                if (metadata.tapBip32Derivation)
+                    input.tapBip32Derivation = metadata.tapBip32Derivation;
+                if (metadata.path) {
+                    input.unknownKeyVals = (input.unknownKeyVals || []).filter((value) => Buffer.from(value.key).toString() !== 'path');
+                    input.unknownKeyVals.push(metadata.path);
+                }
+            });
+            return psbt_1.PsbtUtils.toPali(signedPsbt);
+        };
+        this.sendTransaction = async (psbt) => {
+            if (!psbt) {
+                throw new Error('Signed PSBT is required for broadcasting.');
+            }
+            return await this.sendSignedTransaction(psbt_1.PsbtUtils.fromPali(psbt, this.getState().activeNetwork));
+        };
+        this.getSigner = getSyscoinSigner;
+        this.getReadOnlySigner = getReadOnlySigner;
+        this.getState = getState;
+        this.getAddress = getAddress;
+        this.hardwareSigners = hardwareSigners;
+        this.captureSigningContext = captureSigningContext;
+    }
+}
+exports.SyscoinTransactionsCore = SyscoinTransactionsCore;
+//# sourceMappingURL=syscoin-core.js.map