@btc-vision/transaction 1.0.122 → 1.1.0

package/build/transaction/builders/UnwrapTransaction.js

@@ -1,258 +0,0 @@
-import { TransactionType } from '../enums/TransactionType.js';
-import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
-import { TransactionBuilder } from './TransactionBuilder.js';
-import { wBTC } from '../../metadata/contracts/wBTC.js';
-import { payments, } from '@btc-vision/bitcoin';
-import { EcKeyPair } from '../../keypair/EcKeyPair.js';
-import { PsbtTransaction } from '../processor/PsbtTransaction.js';
-import { MultiSignGenerator } from '../../generators/builders/MultiSignGenerator.js';
-import { MultiSignTransaction } from './MultiSignTransaction.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
-import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
-import { currentConsensusConfig } from '../../consensus/ConsensusConfig.js';
-import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
-import { Features } from '../../generators/Features.js';
-import { ABICoder } from '../../abi/ABICoder.js';
-import { BinaryWriter } from '../../buffer/BinaryWriter.js';
-const abiCoder = new ABICoder();
-const numsPoint = Buffer.from('50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0', 'hex');
-export class UnwrapTransaction extends SharedInteractionTransaction {
-    constructor(parameters) {
-        if (parameters.amount < TransactionBuilder.MINIMUM_DUST) {
-            throw new Error('Amount is below dust limit');
-        }
-        parameters.disableAutoRefund = true;
-        parameters.calldata = UnwrapTransaction.generateBurnCalldata(parameters.amount);
-        super(parameters);
-        this.type = TransactionType.WBTC_UNWRAP;
-        this.sighashTypes = [];
-        this.estimatedFeeLoss = 0n;
-        this.calculatedSignHash = PsbtTransaction.calculateSignHash(this.sighashTypes);
-        this.wbtc = new wBTC(parameters.network, parameters.chainId);
-        this.to = this.wbtc.getAddress();
-        this.vaultUTXOs = parameters.unwrapUTXOs;
-        this.estimatedFeeLoss = UnwrapTransaction.preEstimateTaprootTransactionFees(BigInt(this.feeRate), this.calculateNumInputs(this.vaultUTXOs), 2n, this.calculateNumSignatures(this.vaultUTXOs), 65n, this.calculateNumEmptyWitnesses(this.vaultUTXOs));
-        this.amount = parameters.amount;
-        this.contractSecret = this.generateSecret();
-        this.calldataGenerator = new CalldataGenerator(Buffer.from(this.signer.publicKey), this.scriptSignerXOnlyPubKey(), this.network);
-        this.compiledTargetScript = this.calldataGenerator.compile(this.calldata, this.contractSecret, [Features.UNWRAP]);
-        this.scriptTree = this.getScriptTree();
-        this.internalInit();
-    }
-    static generateBurnCalldata(amount) {
-        if (!amount)
-            throw new Error('Amount is required');
-        const bufWriter = new BinaryWriter();
-        bufWriter.writeSelector(UnwrapTransaction.UNWRAP_SELECTOR);
-        bufWriter.writeU256(amount);
-        return Buffer.from(bufWriter.getBuffer());
-    }
-    async signPSBT() {
-        if (this.to && !EcKeyPair.verifyContractAddress(this.to, this.network)) {
-            throw new Error('Invalid contract address. The contract address must be a taproot address.');
-        }
-        if (!this.vaultUTXOs.length) {
-            throw new Error('No vault UTXOs provided');
-        }
-        await this.buildTransaction();
-        this.ignoreSignatureError();
-        this.mergeVaults();
-        const builtTx = await this.internalBuildTransaction(this.transaction);
-        if (builtTx) {
-            return this.transaction;
-        }
-        throw new Error('Could not sign transaction');
-    }
-    getRefund() {
-        let losses = -currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT;
-        for (const vault of this.vaultUTXOs) {
-            for (let i = 0; i < vault.utxos.length; i++) {
-                losses += currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT;
-            }
-        }
-        return losses;
-    }
-    getFeeLossOrRefund() {
-        const refund = this.getRefund();
-        return refund - this.estimatedFeeLoss;
-    }
-    mergeVaults() {
-        const totalInputAmount = this.getVaultTotalOutputAmount(this.vaultUTXOs);
-        let refund = this.getRefund();
-        const outputLeftAmount = totalInputAmount - refund - this.amount;
-        if (outputLeftAmount === currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT) {
-            refund += currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT;
-        }
-        else if (outputLeftAmount < currentConsensusConfig.VAULT_MINIMUM_AMOUNT) {
-            throw new Error(`Output left amount is below the minimum amount: ${outputLeftAmount} below ${currentConsensusConfig.VAULT_MINIMUM_AMOUNT}`);
-        }
-        const outAmount = this.amount + refund - this.estimatedFeeLoss;
-        const bestVault = BitcoinUtils.findVaultWithMostPublicKeys(this.vaultUTXOs);
-        if (!bestVault) {
-            throw new Error('No vaults provided');
-        }
-        const hasConsolidation = outputLeftAmount > currentConsensusConfig.VAULT_MINIMUM_AMOUNT &&
-            outputLeftAmount - currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT !== 0n;
-        if (hasConsolidation) {
-            this.success(`Consolidating output with ${outputLeftAmount} sat.`);
-        }
-        else {
-            this.warn(`No consolidation in this transaction.`);
-        }
-        if (outputLeftAmount - currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT !==
-            0n) {
-            this.addOutput({
-                address: bestVault.vault,
-                value: Number(outputLeftAmount),
-            });
-        }
-        if (outAmount < TransactionBuilder.MINIMUM_DUST) {
-            throw new Error(`Amount is below dust limit. The requested amount can not be unwrapped since, after fees, it is below the dust limit. Dust: ${outAmount} sat. Are your bitcoin fees too high?`);
-        }
-        const percentageLossOverInitialAmount = (outAmount * 100n) / this.amount;
-        if (percentageLossOverInitialAmount <= 60n) {
-            throw new Error(`For user safety, OPNet will decline this transaction since you will lose ${100n - percentageLossOverInitialAmount}% of your btc by doing this transaction due to bitcoin fees. Are your bitcoin fees too high?`);
-        }
-        this.addOutput({
-            address: this.from,
-            value: Number(outAmount),
-        });
-        for (const vault of this.vaultUTXOs) {
-            this.addVaultInputs(vault);
-        }
-    }
-    calculateNumEmptyWitnesses(vault) {
-        let numSignatures = 0n;
-        for (const v of vault) {
-            numSignatures += BigInt(v.publicKeys.length - v.minimum) * BigInt(v.utxos.length);
-        }
-        return numSignatures;
-    }
-    calculateNumSignatures(vault) {
-        let numSignatures = 0n;
-        for (const v of vault) {
-            numSignatures += BigInt(v.minimum * v.utxos.length);
-        }
-        return numSignatures;
-    }
-    calculateNumInputs(vault) {
-        let numSignatures = 0n;
-        for (const v of vault) {
-            numSignatures += BigInt(v.utxos.length);
-        }
-        return numSignatures;
-    }
-    internalPubKeyToXOnly() {
-        return toXOnly(numsPoint);
-    }
-    generateTapDataForInput(pubkeys, minimumSignatures) {
-        const compiledTargetScript = MultiSignGenerator.compile(pubkeys, minimumSignatures);
-        const scriptTree = [
-            {
-                output: compiledTargetScript,
-                version: 192,
-            },
-            {
-                output: MultiSignTransaction.LOCK_LEAF_SCRIPT,
-                version: 192,
-            },
-        ];
-        const redeem = {
-            output: compiledTargetScript,
-            redeemVersion: 192,
-        };
-        return {
-            internalPubkey: this.internalPubKeyToXOnly(),
-            network: this.network,
-            scriptTree: scriptTree,
-            redeem: redeem,
-        };
-    }
-    getScriptSolution(input) {
-        if (!input.tapScriptSig) {
-            throw new Error('Tap script signature is required');
-        }
-        return [
-            this.contractSecret,
-            toXOnly(Buffer.from(this.signer.publicKey)),
-            input.tapScriptSig[0].signature,
-            input.tapScriptSig[1].signature,
-        ];
-    }
-    async internalBuildTransaction(transaction, checkPartialSigs = false) {
-        if (transaction.data.inputs.length === 0) {
-            const inputs = this.getInputs();
-            const outputs = this.getOutputs();
-            transaction.setMaximumFeeRate(this._maximumFeeRate);
-            transaction.addInputs(inputs, checkPartialSigs);
-            for (let i = 0; i < this.updateInputs.length; i++) {
-                transaction.updateInput(i, this.updateInputs[i]);
-            }
-            transaction.addOutputs(outputs);
-        }
-        try {
-            try {
-                await this.signInputs(transaction);
-            }
-            catch (e) {
-                console.log(e);
-            }
-            if (this.finalized) {
-                this.transactionFee = BigInt(transaction.getFee());
-            }
-            return true;
-        }
-        catch (e) {
-            const err = e;
-            this.error(`[internalBuildTransaction] Something went wrong while getting building the transaction: ${err.stack}`);
-        }
-        return false;
-    }
-    addVaultUTXO(utxo, pubkeys, minimumSignatures) {
-        const tapInput = this.generateTapDataForInput(pubkeys, minimumSignatures);
-        const tap = payments.p2tr(tapInput);
-        if (!tap.witness)
-            throw new Error('Failed to generate taproot witness');
-        const controlBlock = tap.witness[tap.witness.length - 1];
-        const input = {
-            hash: utxo.hash,
-            index: utxo.outputIndex,
-            witnessUtxo: {
-                script: Buffer.from(utxo.output, 'base64'),
-                value: Number(utxo.value),
-            },
-            sequence: this.sequence,
-            tapLeafScript: [
-                {
-                    leafVersion: tapInput.redeem.redeemVersion,
-                    script: tapInput.redeem.output,
-                    controlBlock: controlBlock,
-                },
-            ],
-        };
-        if (this.calculatedSignHash) {
-            input.sighashType = this.calculatedSignHash;
-        }
-        this.addInput(input);
-    }
-    addVaultInputs(vault) {
-        const pubKeys = vault.publicKeys.map((key) => Buffer.from(key, 'base64'));
-        for (const utxo of vault.utxos) {
-            this.addVaultUTXO(utxo, pubKeys, vault.minimum);
-        }
-    }
-    calculateOutputLeftAmountFromVaults(vaults) {
-        const total = this.getVaultTotalOutputAmount(vaults);
-        return total - this.amount;
-    }
-    getVaultTotalOutputAmount(vaults) {
-        let total = BigInt(0);
-        for (const vault of vaults) {
-            for (const utxo of vault.utxos) {
-                total += BigInt(utxo.value);
-            }
-        }
-        return total;
-    }
-}
-UnwrapTransaction.UNWRAP_SELECTOR = Number('0x' + abiCoder.encodeSelector('burn'));

package/build/transaction/builders/WrapTransaction.d.ts

@@ -1,29 +0,0 @@
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
-import { TransactionType } from '../enums/TransactionType.js';
-import { TapLeafScript } from '../interfaces/Tap.js';
-import { IWrapParameters } from '../interfaces/ITransactionParameters.js';
-import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
-import { WrappedGeneration } from '../../wbtc/WrappedGenerationParameters.js';
-import { Address } from '../../keypair/Address.js';
-export declare class WrapTransaction extends SharedInteractionTransaction<TransactionType.WBTC_WRAP> {
-    private static readonly WRAP_SELECTOR;
-    type: TransactionType.WBTC_WRAP;
-    readonly vault: string;
-    readonly amount: bigint;
-    readonly receiver: Address;
-    protected readonly compiledTargetScript: Buffer;
-    protected readonly scriptTree: Taptree;
-    protected tapLeafScript: TapLeafScript | null;
-    protected readonly contractSecret: Buffer;
-    protected readonly interactionPubKeys: Buffer[];
-    protected readonly minimumSignatures: number;
-    private readonly wbtc;
-    constructor(parameters: IWrapParameters);
-    private static generateMintCalldata;
-    verifyPublicKeysConstraints(generation: WrappedGeneration): boolean;
-    protected buildTransaction(): Promise<void>;
-    private verifyRequiredValue;
-    private addVaultOutput;
-    private generateVaultAddress;
-    private generateChecksumSalt;
-}

package/build/transaction/builders/WrapTransaction.js

@@ -1,146 +0,0 @@
-import { TransactionType } from '../enums/TransactionType.js';
-import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
-import { wBTC } from '../../metadata/contracts/wBTC.js';
-import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
-import { P2TR_MS } from '../shared/P2TR_MS.js';
-import { currentConsensusConfig } from '../../consensus/ConsensusConfig.js';
-import { ABICoder } from '../../abi/ABICoder.js';
-import { BinaryWriter } from '../../buffer/BinaryWriter.js';
-import { Address } from '../../keypair/Address.js';
-const abiCoder = new ABICoder();
-export class WrapTransaction extends SharedInteractionTransaction {
-    constructor(parameters) {
-        if (parameters.amount < currentConsensusConfig.VAULT_MINIMUM_AMOUNT) {
-            throw new Error(`Amount is below the minimum required of ${currentConsensusConfig.VAULT_MINIMUM_AMOUNT} sat.`);
-        }
-        const receiver = parameters.receiver || new Address(parameters.signer.publicKey);
-        parameters.calldata = WrapTransaction.generateMintCalldata(parameters.amount, receiver, parameters.network);
-        super(parameters);
-        this.type = TransactionType.WBTC_WRAP;
-        this.tapLeafScript = null;
-        this.interactionPubKeys = [];
-        this.minimumSignatures = 0;
-        this.wbtc = new wBTC(parameters.network, parameters.chainId);
-        this.vault = parameters.generationParameters.vault;
-        this.to = this.wbtc.getAddress();
-        this.receiver = receiver;
-        this.amount = parameters.amount;
-        this.verifyRequiredValue();
-        this.interactionPubKeys = parameters.generationParameters.pubKeys;
-        this.minimumSignatures = parameters.generationParameters.constraints.minimum;
-        this.contractSecret = this.generateSecret();
-        if (!this.verifyPublicKeysConstraints(parameters.generationParameters)) {
-            throw new Error('Oops. Your wrapping request have been decline! It failed security checks!');
-        }
-        this.compiledTargetScript = this.calldataGenerator.compile(this.calldata, this.contractSecret, [], this.interactionPubKeys, this.minimumSignatures);
-        this.scriptTree = this.getScriptTree();
-        this.internalInit();
-    }
-    static generateMintCalldata(amount, to, network) {
-        if (!amount)
-            throw new Error('Amount is required');
-        if (!to)
-            throw new Error('To address is required');
-        if (!to.isValid(network)) {
-            throw new Error(`Oops! The address ${to} is not a valid P2TR address! If you wrap at this address, your funds will be lost!`);
-        }
-        const bufWriter = new BinaryWriter();
-        bufWriter.writeSelector(WrapTransaction.WRAP_SELECTOR);
-        bufWriter.writeAddress(to);
-        bufWriter.writeU256(amount);
-        return Buffer.from(bufWriter.getBuffer());
-    }
-    verifyPublicKeysConstraints(generation) {
-        if (generation.constraints.minimum < 2) {
-            throw new Error('Minimum signatures must be at least 2');
-        }
-        if (generation.keys.length < generation.constraints.transactionMinimum ||
-            generation.keys.length < generation.constraints.minimum) {
-            throw new Error('Not enough pub keys');
-        }
-        if (generation.keys.length > 255) {
-            throw new Error('Too many pub keys');
-        }
-        const generatedVault = this.generateVaultAddress(generation.pubKeys, generation.constraints.minimum);
-        if (generatedVault !== generation.vault) {
-            throw new Error(`Invalid vault address. Expected: ${generatedVault} Got: ${generation.vault}`);
-        }
-        const passChecksum = this.generateChecksumSalt(generation, this.amount, generation.vault);
-        const checksum = BitcoinUtils.opnetHash(passChecksum);
-        if (checksum !== generation.signature) {
-            throw new Error(`Invalid checksum. Expected: ${checksum} Got: ${generation.signature}`);
-        }
-        return true;
-    }
-    async buildTransaction() {
-        if (!this.to)
-            throw new Error('To address is required');
-        const selectedRedeem = this.scriptSigner
-            ? this.targetScriptRedeem
-            : this.leftOverFundsScriptRedeem;
-        if (!selectedRedeem) {
-            throw new Error('Left over funds script redeem is required');
-        }
-        if (!selectedRedeem.redeemVersion) {
-            throw new Error('Left over funds script redeem version is required');
-        }
-        if (!selectedRedeem.output) {
-            throw new Error('Left over funds script redeem output is required');
-        }
-        this.tapLeafScript = {
-            leafVersion: selectedRedeem.redeemVersion,
-            script: selectedRedeem.output,
-            controlBlock: this.getWitness(),
-        };
-        this.addInputsFromUTXO();
-        const amountSpent = this.getTransactionOPNetFee();
-        this.addOutput({
-            value: Number(amountSpent),
-            address: this.to,
-        });
-        this.addVaultOutput();
-        await this.addRefundOutput(amountSpent +
-            this.amount +
-            currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT);
-    }
-    verifyRequiredValue() {
-        if (this.totalInputAmount < this.amount) {
-            throw new Error(`Not enough funds to wrap the amount specified. ${this.totalInputAmount} < ${this.amount}`);
-        }
-        const valueToVault = this.amount + currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT;
-        if (this.totalInputAmount < valueToVault) {
-            throw new Error(`Not enough funds to wrap the amount specified. ${this.totalInputAmount} < ${valueToVault}. Make sure that your inputs cover the amount to wrap, the priority fee and the unwrap prepaid fees.`);
-        }
-    }
-    addVaultOutput() {
-        if (!this.vault) {
-            throw new Error(`No vault address provided`);
-        }
-        const valueToSend = this.amount + currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT;
-        const amountOutput = {
-            address: this.vault,
-            value: Number(valueToSend),
-        };
-        this.addOutput(amountOutput);
-    }
-    generateVaultAddress(keys, minimumSignatureRequired) {
-        return P2TR_MS.generateMultiSigAddress(keys, minimumSignatureRequired, this.network);
-    }
-    generateChecksumSalt(param, amount, vault) {
-        const version = param.constraints.version;
-        const timestamp = param.constraints.timestamp;
-        const params = Buffer.alloc(12 + version.length);
-        params.writeBigInt64BE(BigInt(timestamp), 0);
-        params.writeInt16BE(param.constraints.minimum, 8);
-        params.writeInt16BE(param.constraints.transactionMinimum, 10);
-        params.write(version, 12, version.length, 'utf-8');
-        return Buffer.concat([
-            ...param.pubKeys,
-            ...param.entities.map((entity) => Buffer.from(entity, 'utf-8')),
-            params,
-            Buffer.from(amount.toString(), 'utf-8'),
-            Buffer.from(vault, 'utf-8'),
-        ]);
-    }
-}
-WrapTransaction.WRAP_SELECTOR = Number('0x' + abiCoder.encodeSelector('mint'));

package/build/wbtc/Generate.d.ts

@@ -1,18 +0,0 @@
-import { VaultUTXOs } from '../transaction/processor/PsbtTransaction.js';
-export interface GenerationConstraints {
-    readonly timestamp: number;
-    readonly version: string;
-    readonly minimum: number;
-    readonly transactionMinimum: number;
-}
-export interface WrappedGenerationParameters {
-    readonly keys: string[];
-    readonly vault: string;
-    readonly entities: string[];
-    readonly signature: string;
-    readonly constraints: GenerationConstraints;
-}
-export interface UnwrappedGenerationParameters {
-    readonly vaultUTXOs: VaultUTXOs[];
-    readonly balance: string;
-}

package/build/wbtc/Generate.js

@@ -1 +0,0 @@
-export {};

package/build/wbtc/UnwrapGeneration.d.ts

@@ -1,7 +0,0 @@
-import { UnwrappedGenerationParameters } from './Generate.js';
-import { VaultUTXOs } from '../transaction/processor/PsbtTransaction.js';
-export declare class UnwrapGeneration implements Omit<UnwrappedGenerationParameters, 'balance'> {
-    readonly vaultUTXOs: VaultUTXOs[];
-    readonly balance: bigint;
-    constructor(params: UnwrappedGenerationParameters);
-}

package/build/wbtc/UnwrapGeneration.js

@@ -1,6 +0,0 @@
-export class UnwrapGeneration {
-    constructor(params) {
-        this.vaultUTXOs = params.vaultUTXOs;
-        this.balance = BigInt(params.balance);
-    }
-}

package/build/wbtc/WrappedGenerationParameters.d.ts

@@ -1,10 +0,0 @@
-import { GenerationConstraints, WrappedGenerationParameters } from './Generate.js';
-export declare class WrappedGeneration implements WrappedGenerationParameters {
-    readonly constraints: GenerationConstraints;
-    readonly entities: string[];
-    readonly keys: string[];
-    readonly signature: string;
-    readonly vault: string;
-    readonly pubKeys: Buffer[];
-    constructor(params: WrappedGenerationParameters);
-}

package/build/wbtc/WrappedGenerationParameters.js

@@ -1,10 +0,0 @@
-export class WrappedGeneration {
-    constructor(params) {
-        this.constraints = params.constraints;
-        this.entities = params.entities;
-        this.keys = params.keys;
-        this.signature = params.signature;
-        this.vault = params.vault;
-        this.pubKeys = this.keys.map((key) => Buffer.from(key, 'base64'));
-    }
-}

package/src/metadata/contracts/wBTC.ts

@@ -1,59 +0,0 @@
-import { Network, networks } from '@btc-vision/bitcoin';
-import { ChainId } from '../../network/ChainId.js';
-import { ContractBaseMetadata } from '../ContractBaseMetadata.js';
-import { WBTC_ADDRESS_FRACTAL, WBTC_ADDRESS_REGTEST, WBTC_ADDRESS_TESTNET } from '../tokens.js';
-import { Address } from '../../keypair/Address.js';
-
-/**
- * @description Wrapped Bitcoin (wBTC) contract metadata.
- * */
-export class wBTC extends ContractBaseMetadata {
-    /**
-     * @description Token Name
-     */
-    public readonly tokenName: string = 'Wrapped Bitcoin';
-
-    /**
-     * @description Token Symbol
-     */
-    public readonly tokenSymbol: string = 'wBTC';
-
-    /**
-     * @description Token Decimals, same as Bitcoin
-     */
-    public readonly decimals: number = 8;
-
-    protected readonly address: string;
-
-    constructor(
-        protected network: Network = networks.bitcoin,
-        chainId: ChainId = ChainId.Bitcoin,
-    ) {
-        super(network);
-
-        this.address = wBTC.getAddress(network, chainId);
-    }
-
-    public static getAddress(network: Network = networks.bitcoin, chainId?: ChainId): string {
-        switch (network.bech32) {
-            case networks.bitcoin.bech32:
-                return this.getWBTCAddressForChain(chainId ?? ChainId.Bitcoin).p2tr(network);
-            case networks.regtest.bech32:
-                return WBTC_ADDRESS_REGTEST.p2tr(network);
-            case networks.testnet.bech32:
-                return WBTC_ADDRESS_TESTNET.p2tr(network);
-            default:
-                throw new Error(`Invalid network: ${network.bech32}`);
-        }
-    }
-
-    private static getWBTCAddressForChain(chainId: ChainId): Address {
-        switch (chainId) {
-            //case ChainId.Bitcoin:
-            case ChainId.Fractal:
-                return WBTC_ADDRESS_FRACTAL;
-            default:
-                throw new Error(`Unsupported chainId: ${chainId}`);
-        }
-    }
-}