@bitgo-beta/abstract-eth 1.0.2-beta.230 → 1.0.2-beta.2301

package/dist/src/lib/transactionBuilder.js

@@ -0,0 +1,1120 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilder = void 0;
+const statics_1 = require("@bitgo-beta/statics");
+const ethereumjs_abi_1 = __importDefault(require("ethereumjs-abi"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ethUtil = __importStar(require("ethereumjs-util"));
+const tx_1 = require("@ethereumjs/tx");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const keyPair_1 = require("./keyPair");
+const iface_1 = require("./iface");
+const utils_1 = require("./utils");
+const zamaUtils_1 = require("./zamaUtils");
+const walletUtil_1 = require("./walletUtil");
+const transaction_1 = require("./transaction");
+const DEFAULT_M = 3;
+const RAW_TX_HEX_REGEX = /^(0x)?[0-9a-f]{1,}$/;
+/**
+ * EthereumLike transaction builder.
+ */
+class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
+    /**
+     * Public constructor.
+     *
+     * @param _coinConfig
+     */
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._common = (0, utils_1.getCommon)(this._coinConfig.network);
+        this._type = sdk_core_1.TransactionType.Send;
+        this._counter = 0;
+        this._value = '0';
+        this._walletOwnerAddresses = [];
+        this._forwarderVersion = 0;
+        this._walletVersion = 0;
+        this.transaction = new transaction_1.Transaction(this._coinConfig, this._common);
+        this._walletSimpleByteCode = '';
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        const transactionData = this.getTransactionData();
+        if (this._txSignature) {
+            Object.assign(transactionData, this._txSignature);
+        }
+        this.transaction.setTransactionType(this._type);
+        transactionData.from = this._sourceKeyPair ? this._sourceKeyPair.getAddress() : undefined;
+        this.transaction.setTransactionData(transactionData, this._transfer ? this._transfer.getIsFirstSigner() : undefined);
+        // Build and sign a new transaction based on the latest changes
+        if (this._sourceKeyPair && this._sourceKeyPair.getKeys().prv) {
+            await this.transaction.sign(this._sourceKeyPair);
+        }
+        return this.transaction;
+    }
+    getTransactionData() {
+        switch (this._type) {
+            case sdk_core_1.TransactionType.WalletInitialization:
+                return this.buildWalletInitializationTransaction(this._walletVersion);
+            case sdk_core_1.TransactionType.RecoveryWalletDeployment:
+                return this.buildBase(this._data);
+            case sdk_core_1.TransactionType.Send:
+            case sdk_core_1.TransactionType.SendERC721:
+            case sdk_core_1.TransactionType.SendERC1155:
+            case sdk_core_1.TransactionType.SendERC7984:
+                return this.buildSendTransaction();
+            case sdk_core_1.TransactionType.AddressInitialization:
+                return this.buildAddressInitializationTransaction();
+            case sdk_core_1.TransactionType.FlushTokens:
+                return this.buildFlushTokensTransaction();
+            case sdk_core_1.TransactionType.FlushCoins:
+                return this.buildFlushCoinsTransaction();
+            case sdk_core_1.TransactionType.FlushERC721:
+                return this.buildFlushERC721Transaction();
+            case sdk_core_1.TransactionType.FlushERC1155:
+                return this.buildFlushERC1155Transaction();
+            case sdk_core_1.TransactionType.SingleSigSend:
+                return this.buildBase('0x');
+            case sdk_core_1.TransactionType.ContractCall:
+            case sdk_core_1.TransactionType.DecryptionDelegation:
+                return this.buildGenericContractCallTransaction();
+            case sdk_core_1.TransactionType.FlushERC7984ForwarderToken:
+                return this.buildFlushERC7984ForwarderTokenTransaction();
+            case sdk_core_1.TransactionType.WrapERC7984:
+                return this.buildWrapERC7984Transaction();
+            case sdk_core_1.TransactionType.UnwrapERC7984:
+                return this.buildUnwrapERC7984Transaction();
+            case sdk_core_1.TransactionType.FinalizeUnwrapERC7984:
+                return this.buildFinalizeUnwrapERC7984Transaction();
+            default:
+                throw new sdk_core_1.BuildTransactionError('Unsupported transaction type');
+        }
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction, isFirstSigner) {
+        let tx;
+        if (RAW_TX_HEX_REGEX.test(rawTransaction.toLowerCase())) {
+            tx = transaction_1.Transaction.fromSerialized(this._coinConfig, this._common, rawTransaction, isFirstSigner);
+            this.loadBuilderInput(tx.toJson(), isFirstSigner);
+        }
+        else {
+            const txData = JSON.parse(rawTransaction);
+            tx = new transaction_1.Transaction(this._coinConfig, txData);
+        }
+        return tx;
+    }
+    /**
+     * Load the builder data using the deserialized transaction
+     *
+     * @param {TxData} transactionJson the deserialized transaction json
+     * @param {boolean} isFirstSigner if the transaction is being signed by the first signer
+     */
+    loadBuilderInput(transactionJson, isFirstSigner) {
+        const decodedType = (0, utils_1.classifyTransaction)(transactionJson.data);
+        this.type(decodedType);
+        this.counter(transactionJson.nonce);
+        this.value(transactionJson.value);
+        if (transactionJson._type === iface_1.ETHTransactionType.LEGACY) {
+            this.fee({
+                fee: transactionJson.gasPrice,
+                gasPrice: transactionJson.gasPrice,
+                gasLimit: transactionJson.gasLimit,
+            });
+        }
+        else {
+            this.fee({
+                gasLimit: transactionJson.gasLimit,
+                fee: transactionJson.maxFeePerGas,
+                eip1559: {
+                    maxFeePerGas: transactionJson.maxFeePerGas,
+                    maxPriorityFeePerGas: transactionJson.maxPriorityFeePerGas,
+                },
+            });
+        }
+        if ((0, utils_1.hasSignature)(transactionJson)) {
+            this._txSignature = { v: transactionJson.v, r: transactionJson.r, s: transactionJson.s };
+        }
+        this.setTransactionTypeFields(decodedType, transactionJson, isFirstSigner);
+    }
+    setTransactionTypeFields(decodedType, transactionJson, isFirstSigner) {
+        switch (decodedType) {
+            case sdk_core_1.TransactionType.WalletInitialization:
+                const { owners, salt } = (0, utils_1.decodeWalletCreationData)(transactionJson.data);
+                owners.forEach((element) => {
+                    this.owner(element);
+                });
+                if (salt) {
+                    this.salt(salt);
+                    this.walletVersion(1);
+                    this.setContract(transactionJson.to);
+                }
+                break;
+            case sdk_core_1.TransactionType.RecoveryWalletDeployment:
+                this.data(transactionJson.data);
+                break;
+            case sdk_core_1.TransactionType.FlushTokens:
+                this.setContract(transactionJson.to);
+                const { forwarderAddress, tokenAddress, forwarderVersion } = (0, utils_1.decodeFlushTokensData)(transactionJson.data, transactionJson.to);
+                if (forwarderVersion === 4) {
+                    this.forwarderVersion(4);
+                }
+                this.forwarderAddress(forwarderAddress);
+                this.tokenAddress(tokenAddress);
+                break;
+            case sdk_core_1.TransactionType.FlushCoins:
+                this.setContract(transactionJson.to);
+                break;
+            case sdk_core_1.TransactionType.FlushERC721:
+                this.setContract(transactionJson.to);
+                const erc721Data = (0, utils_1.decodeFlushERC721TokensData)(transactionJson.data, transactionJson.to);
+                if (erc721Data.forwarderVersion === 4) {
+                    this.forwarderVersion(erc721Data.forwarderVersion);
+                }
+                this.forwarderAddress(erc721Data.forwarderAddress);
+                this.tokenAddress(erc721Data.tokenAddress);
+                this.tokenId(erc721Data.tokenId);
+                break;
+            case sdk_core_1.TransactionType.FlushERC1155:
+                this.setContract(transactionJson.to);
+                const erc1155Data = (0, utils_1.decodeFlushERC1155TokensData)(transactionJson.data, transactionJson.to);
+                if (erc1155Data.forwarderVersion === 4) {
+                    this.forwarderVersion(erc1155Data.forwarderVersion);
+                }
+                this.forwarderAddress(erc1155Data.forwarderAddress);
+                this.tokenAddress(erc1155Data.tokenAddress);
+                this.tokenId(erc1155Data.tokenId);
+                break;
+            case sdk_core_1.TransactionType.Send:
+            case sdk_core_1.TransactionType.SendERC1155:
+            case sdk_core_1.TransactionType.SendERC721:
+            case sdk_core_1.TransactionType.SendERC7984:
+                this.setContract(transactionJson.to);
+                this._transfer = this.transfer(transactionJson.data, isFirstSigner);
+                break;
+            case sdk_core_1.TransactionType.AddressInitialization:
+                this.setContract(transactionJson.to);
+                const { baseAddress, addressCreationSalt, feeAddress } = (0, utils_1.decodeForwarderCreationData)(transactionJson.data);
+                if (baseAddress && addressCreationSalt) {
+                    this.baseAddress(baseAddress);
+                    this.salt(addressCreationSalt);
+                    if (feeAddress) {
+                        this.feeAddress(feeAddress);
+                        this.forwarderVersion(4);
+                    }
+                    else {
+                        this.forwarderVersion(1);
+                    }
+                    const forwarderImplementationAddress = this._coinConfig.network
+                        .forwarderImplementationAddress;
+                    if (forwarderImplementationAddress) {
+                        this.initCode(forwarderImplementationAddress);
+                    }
+                }
+                break;
+            case sdk_core_1.TransactionType.SingleSigSend:
+                this.setContract(transactionJson.to);
+                break;
+            case sdk_core_1.TransactionType.ContractCall:
+            case sdk_core_1.TransactionType.DecryptionDelegation:
+                this.setContract(transactionJson.to);
+                this.data(transactionJson.data);
+                break;
+            case sdk_core_1.TransactionType.FlushERC7984ForwarderToken: {
+                this.setContract(transactionJson.to);
+                const erc7984Data = (0, utils_1.decodeFlushERC7984ForwarderTokenData)(transactionJson.data, transactionJson.to);
+                this.forwarderAddress(erc7984Data.forwarderAddress);
+                this.tokenContractAddress(erc7984Data.tokenContractAddress);
+                this.encryptedHandle(erc7984Data.encryptedHandle);
+                this.parentAddress(erc7984Data.parentAddress);
+                break;
+            }
+            case sdk_core_1.TransactionType.WrapERC7984: {
+                this.setContract(transactionJson.to);
+                const wrapData = (0, utils_1.decodeWrapERC7984Data)(transactionJson.data, transactionJson.to);
+                this.wrapRecipient(wrapData.to);
+                this.wrapAmount(wrapData.amount);
+                // rate is not encoded in calldata; callers that rebuild must set wrapRate() again
+                break;
+            }
+            case sdk_core_1.TransactionType.UnwrapERC7984: {
+                this.setContract(transactionJson.to);
+                const unwrapData = (0, utils_1.decodeUnwrapERC7984Data)(transactionJson.data, transactionJson.to);
+                this.unwrapFrom(unwrapData.from);
+                this.unwrapTo(unwrapData.to);
+                this.unwrapEncryptedAmount(unwrapData.encryptedAmount);
+                this.unwrapInputProof(unwrapData.inputProof);
+                break;
+            }
+            case sdk_core_1.TransactionType.FinalizeUnwrapERC7984: {
+                this.setContract(transactionJson.to);
+                const finalizeData = (0, utils_1.decodeFinalizeUnwrapERC7984Data)(transactionJson.data, transactionJson.to);
+                this.finalizeUnwrapRequestId(finalizeData.requestId);
+                this.finalizeUnwrapCleartextAmount(finalizeData.cleartextAmount);
+                this.finalizeUnwrapDecryptionProof(finalizeData.decryptionProof);
+                break;
+            }
+            default:
+                throw new sdk_core_1.BuildTransactionError('Unsupported transaction type');
+            // TODO: Add other cases of deserialization
+        }
+    }
+    /** @inheritdoc */
+    signImplementation(key) {
+        const signer = new keyPair_1.KeyPair({ prv: key.key });
+        if (this._type === sdk_core_1.TransactionType.WalletInitialization && this._walletOwnerAddresses.length === 0) {
+            throw new sdk_core_1.SigningError('Cannot sign an wallet initialization transaction without owners');
+        }
+        if (this._sourceKeyPair) {
+            throw new sdk_core_1.SigningError('Cannot sign multiple times a non send-type transaction');
+        }
+        // Signing the transaction is an async operation, so save the source and leave the actual
+        // signing for the build step
+        this._sourceKeyPair = signer;
+        return this.transaction;
+    }
+    /** @inheritdoc */
+    validateAddress(address) {
+        if (!(0, utils_1.isValidEthAddress)(address.address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address ' + address.address);
+        }
+    }
+    /** @inheritdoc */
+    validateKey(key) {
+        if (!((0, sdk_core_1.isValidXprv)(key.key) || (0, sdk_core_1.isValidPrv)(key.key))) {
+            throw new sdk_core_1.BuildTransactionError('Invalid key');
+        }
+    }
+    /**
+     * Validate the raw transaction is either a JSON or
+     * a hex encoded transaction
+     *
+     * @param {any} rawTransaction The raw transaction to be validated
+     */
+    validateRawTransaction(rawTransaction) {
+        if (!rawTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Raw transaction is empty');
+        }
+        if (typeof rawTransaction === 'string') {
+            if (RAW_TX_HEX_REGEX.test(rawTransaction.toLowerCase())) {
+                const txBytes = ethUtil.toBuffer(ethUtil.addHexPrefix(rawTransaction.toLowerCase()));
+                if (!this.isEip1559Txn(txBytes) && !this.isRLPDecodable(txBytes)) {
+                    throw new sdk_core_1.ParseTransactionError('There was error in decoding the hex string');
+                }
+            }
+            else {
+                try {
+                    JSON.parse(rawTransaction);
+                }
+                catch (e) {
+                    throw new sdk_core_1.ParseTransactionError('There was error in parsing the JSON string');
+                }
+            }
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError('Transaction is not a hex string or stringified json');
+        }
+    }
+    isEip1559Txn(txn) {
+        try {
+            tx_1.FeeMarketEIP1559Transaction.fromSerializedTx(txn);
+            return true;
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    isRLPDecodable(bytes) {
+        try {
+            ethUtil.rlp.decode(bytes);
+            return true;
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    validateBaseTransactionFields() {
+        if (this._fee === undefined || (!this._fee.fee && !this._fee.gasPrice && !this._fee.eip1559)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing fee');
+        }
+        if (this._common === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: network common');
+        }
+        if (this._counter === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing address counter');
+        }
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        this.validateBaseTransactionFields();
+        switch (this._type) {
+            case sdk_core_1.TransactionType.WalletInitialization:
+                this.validateWalletInitializationFields();
+                break;
+            case sdk_core_1.TransactionType.RecoveryWalletDeployment:
+                this.validateDataField();
+                break;
+            case sdk_core_1.TransactionType.Send:
+            case sdk_core_1.TransactionType.SendERC721:
+            case sdk_core_1.TransactionType.SendERC1155:
+            case sdk_core_1.TransactionType.SendERC7984:
+                this.validateContractAddress();
+                break;
+            case sdk_core_1.TransactionType.AddressInitialization:
+                this.validateContractAddress();
+                break;
+            case sdk_core_1.TransactionType.FlushCoins:
+                this.validateContractAddress();
+                break;
+            case sdk_core_1.TransactionType.FlushTokens:
+                this.validateContractAddress();
+                this.validateForwarderAddress();
+                this.validateTokenAddress();
+                break;
+            case sdk_core_1.TransactionType.FlushERC721:
+            case sdk_core_1.TransactionType.FlushERC1155:
+                this.validateContractAddress();
+                if (this._forwarderVersion < 4) {
+                    this.validateForwarderAddress();
+                }
+                this.validateTokenAddress();
+                if (!this._tokenId) {
+                    throw new sdk_core_1.BuildTransactionError(this._type === sdk_core_1.TransactionType.FlushERC721
+                        ? 'Token ID is required for ERC721 flush'
+                        : 'Token ID is required for ERC1155 flush');
+                }
+                break;
+            case sdk_core_1.TransactionType.SingleSigSend:
+                // for single sig sends, the contract address is actually the recipient
+                this.validateContractAddress();
+                break;
+            case sdk_core_1.TransactionType.StakingLock:
+            case sdk_core_1.TransactionType.StakingUnlock:
+            case sdk_core_1.TransactionType.StakingVote:
+            case sdk_core_1.TransactionType.StakingUnvote:
+            case sdk_core_1.TransactionType.StakingActivate:
+            case sdk_core_1.TransactionType.StakingWithdraw:
+                break;
+            case sdk_core_1.TransactionType.ContractCall:
+            case sdk_core_1.TransactionType.DecryptionDelegation:
+                this.validateContractAddress();
+                this.validateDataField();
+                break;
+            case sdk_core_1.TransactionType.FlushERC7984ForwarderToken:
+                this.validateContractAddress();
+                this.validateForwarderAddress();
+                this.validateTokenContractAddress();
+                this.validateEncryptedHandle();
+                this.validateParentAddress();
+                break;
+            case sdk_core_1.TransactionType.WrapERC7984:
+                this.validateContractAddress();
+                this.validateWrapRecipient();
+                this.validateWrapAmount();
+                break;
+            case sdk_core_1.TransactionType.UnwrapERC7984:
+                this.validateContractAddress();
+                this.validateUnwrapFrom();
+                this.validateUnwrapTo();
+                this.validateUnwrapEncryptedAmount();
+                this.validateUnwrapInputProof();
+                break;
+            case sdk_core_1.TransactionType.FinalizeUnwrapERC7984:
+                this.validateContractAddress();
+                this.validateFinalizeUnwrapRequestId();
+                this.validateFinalizeUnwrapCleartextAmount();
+                this.validateFinalizeUnwrapDecryptionProof();
+                break;
+            default:
+                throw new sdk_core_1.BuildTransactionError('Unsupported transaction type');
+        }
+    }
+    /**
+     * Check wallet owner addresses for wallet initialization transactions are valid or throw.
+     */
+    validateWalletInitializationFields() {
+        if (this._walletOwnerAddresses === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing wallet owners');
+        }
+        if (this._walletOwnerAddresses.length !== 3) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid transaction: wrong number of owners -- required: 3, found: ${this._walletOwnerAddresses.length}`);
+        }
+    }
+    /**
+     * Check if a token address for the tx was defined or throw.
+     */
+    validateTokenAddress() {
+        if (this._tokenAddress === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing token address');
+        }
+    }
+    /**
+     * Check if a forwarder address for the tx was defined or throw.
+     */
+    validateForwarderAddress() {
+        if (this._forwarderAddress === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing forwarder address');
+        }
+    }
+    /**
+     * Check if a contract address for the wallet was defined or throw.
+     */
+    validateContractAddress() {
+        if (this._contractAddress === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing contract address');
+        }
+    }
+    /**
+     * Checks if a contract call data field was defined or throws otherwise
+     */
+    validateDataField() {
+        if (!this._data) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing contract call data field');
+        }
+    }
+    /**
+     * Check if a token contract address for ERC-7984 flush was defined or throw.
+     */
+    validateTokenContractAddress() {
+        if (!this._tokenContractAddress) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing tokenContractAddress');
+        }
+    }
+    /**
+     * Check if an encrypted handle for ERC-7984 flush was defined or throw.
+     */
+    validateEncryptedHandle() {
+        if (!this._encryptedHandle) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing encryptedHandle');
+        }
+    }
+    /**
+     * Check if a parent address for ERC-7984 flush was defined or throw.
+     */
+    validateParentAddress() {
+        if (!this._parentAddress) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing parentAddress');
+        }
+    }
+    validateWrapRecipient() {
+        if (!this._wrapRecipient) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing wrapRecipient');
+        }
+    }
+    validateWrapAmount() {
+        if (!this._wrapAmount) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing wrapAmount');
+        }
+    }
+    validateUnwrapFrom() {
+        if (!this._unwrapFrom) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing unwrapFrom');
+        }
+    }
+    validateUnwrapTo() {
+        if (!this._unwrapTo) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing unwrapTo');
+        }
+    }
+    validateUnwrapEncryptedAmount() {
+        if (!this._unwrapEncryptedAmount) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing unwrapEncryptedAmount');
+        }
+    }
+    validateUnwrapInputProof() {
+        if (!this._unwrapInputProof) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing unwrapInputProof');
+        }
+    }
+    validateFinalizeUnwrapRequestId() {
+        if (!this._finalizeUnwrapRequestId) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing finalizeUnwrapRequestId');
+        }
+    }
+    validateFinalizeUnwrapCleartextAmount() {
+        if (!this._finalizeUnwrapCleartextAmount) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing finalizeUnwrapCleartextAmount');
+        }
+    }
+    validateFinalizeUnwrapDecryptionProof() {
+        if (!this._finalizeUnwrapDecryptionProof) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing finalizeUnwrapDecryptionProof');
+        }
+    }
+    setContract(address) {
+        if (address === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Undefined recipient address');
+        }
+        this.contract(address);
+    }
+    validateValue(value) {
+        if (value.isLessThan(0)) {
+            throw new sdk_core_1.BuildTransactionError('Value cannot be below less than zero');
+        }
+        // TODO: validate the amount is not bigger than the max amount in each Eth family coin
+    }
+    // region Common builder methods
+    /**
+     * The type of transaction being built.
+     *
+     * @param {TransactionType} type
+     */
+    type(type) {
+        this._type = type;
+    }
+    /**
+     * Set the transaction fees. Low fees may get a transaction rejected or never picked up by bakers.
+     *
+     * @param {Fee} fee Baker fees. May also include the maximum gas to pay
+     */
+    fee(fee) {
+        this.validateValue(new bignumber_js_1.default(fee.fee));
+        if (fee.gasLimit) {
+            this.validateValue(new bignumber_js_1.default(fee.gasLimit));
+        }
+        if (fee.eip1559) {
+            const maxFee = new bignumber_js_1.default(fee.eip1559.maxFeePerGas);
+            const priorityFee = new bignumber_js_1.default(fee.eip1559.maxPriorityFeePerGas);
+            this.validateValue(maxFee);
+            this.validateValue(priorityFee);
+            if (priorityFee.isGreaterThan(maxFee)) {
+                throw new sdk_core_1.BuildTransactionError('maxPriorityFeePerGas cannot exceed maxFeePerGas');
+            }
+        }
+        if (fee.gasPrice) {
+            this.validateValue(new bignumber_js_1.default(fee.gasPrice));
+        }
+        this._fee = fee;
+    }
+    /**
+     * Set the transaction counter to prevent submitting repeated transactions.
+     *
+     * @param {number} counter The counter to use
+     */
+    counter(counter) {
+        if (counter < 0) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid counter: ${counter}`);
+        }
+        this._counter = counter;
+    }
+    /**
+     * The value to send along with this transaction. 0 by default
+     *
+     * @param {string} value The value to send along with this transaction
+     */
+    value(value) {
+        this._value = value;
+    }
+    // set args that are required for all types of eth transactions
+    buildBase(data) {
+        const baseParams = {
+            gasLimit: this._fee.gasLimit,
+            nonce: this._counter,
+            data: data,
+            chainId: this._common.chainIdBN().toString(),
+            value: this._value,
+            to: this._contractAddress,
+        };
+        if (this._fee.eip1559) {
+            return {
+                ...baseParams,
+                _type: iface_1.ETHTransactionType.EIP1559,
+                maxFeePerGas: this._fee.eip1559.maxFeePerGas,
+                maxPriorityFeePerGas: this._fee.eip1559.maxPriorityFeePerGas,
+            };
+        }
+        else {
+            return {
+                ...baseParams,
+                _type: iface_1.ETHTransactionType.LEGACY,
+                gasPrice: this._fee?.gasPrice ?? this._fee.fee,
+                v: this.getFinalV(),
+            };
+        }
+    }
+    // endregion
+    // region WalletInitialization builder methods
+    /**
+     * Set one of the owners of the multisig wallet.
+     *
+     * @param {string} address An Ethereum address
+     */
+    owner(address) {
+        if (this._type !== sdk_core_1.TransactionType.WalletInitialization) {
+            throw new sdk_core_1.BuildTransactionError('Multisig wallet owner can only be set for initialization transactions');
+        }
+        if (this._walletOwnerAddresses.length >= DEFAULT_M) {
+            throw new sdk_core_1.BuildTransactionError('A maximum of ' + DEFAULT_M + ' owners can be set for a multisig wallet');
+        }
+        if (!(0, utils_1.isValidEthAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + address);
+        }
+        if (this._walletOwnerAddresses.includes(address)) {
+            throw new sdk_core_1.BuildTransactionError('Repeated owner address: ' + address);
+        }
+        this._walletOwnerAddresses.push(address);
+    }
+    /**
+     * Build a transaction for a generic multisig contract.
+     *
+     * @returns {TxData} The Ethereum transaction data
+     */
+    buildWalletInitializationTransaction(walletVersion) {
+        const walletInitData = walletVersion === walletUtil_1.defaultWalletVersion
+            ? this.getContractData(this._walletOwnerAddresses)
+            : (0, utils_1.getV1WalletInitializationData)(this._walletOwnerAddresses, this._salt);
+        return this.buildBase(walletInitData);
+    }
+    /**
+     * Returns the smart contract encoded data
+     *
+     * @param {string[]} addresses - the contract signers
+     * @returns {string} - the smart contract encoded data
+     */
+    getContractData(addresses) {
+        const params = [addresses];
+        const resultEncodedParameters = ethereumjs_abi_1.default.rawEncode(walletUtil_1.walletSimpleConstructor, params)
+            .toString('hex')
+            .replace('0x', '');
+        return this._walletSimpleByteCode + resultEncodedParameters;
+    }
+    // endregion
+    // region Send builder methods
+    contract(address) {
+        if (!(0, utils_1.isValidEthAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + address);
+        }
+        this._contractAddress = address;
+    }
+    /**
+     * Returns the serialized sendMultiSig contract method data
+     *
+     * @returns {string} serialized sendMultiSig data
+     */
+    getSendData() {
+        if (!this._transfer) {
+            throw new sdk_core_1.BuildTransactionError('Missing transfer information');
+        }
+        const chainId = this._common.chainIdBN().toString();
+        this._transfer.walletVersion(this._walletVersion);
+        // This change is made to support new contracts with different encoding type
+        return this._transfer.signAndBuild(chainId, this.coinUsesNonPackedEncodingForTxData());
+    }
+    /**
+     * Decide if the coin uses non-packed encoding for tx data
+     *
+     * @returns {boolean} true if the coin uses non-packed encoding for tx data
+     */
+    coinUsesNonPackedEncodingForTxData() {
+        return (this._walletVersion === 4 || this._coinConfig.features.includes(statics_1.CoinFeature.USES_NON_PACKED_ENCODING_FOR_TXDATA));
+    }
+    buildSendTransaction() {
+        const sendData = this.getSendData();
+        const tx = this.buildBase(sendData);
+        tx.to = this._contractAddress;
+        return tx;
+    }
+    // endregion
+    // region AddressInitialization builder methods
+    /**
+     * Set the contract transaction nonce to calculate the forwarder address.
+     *
+     * @param {number} contractCounter The counter to use
+     */
+    contractCounter(contractCounter) {
+        if (contractCounter < 0) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid contract counter: ${contractCounter}`);
+        }
+        this._contractCounter = contractCounter;
+    }
+    /**
+     * Build a transaction to create a forwarder.
+     *
+     * @returns {TxData} The Ethereum transaction data
+     */
+    buildAddressInitializationTransaction() {
+        const addressInitData = (0, utils_1.getAddressInitDataAllForwarderVersions)(this._forwarderVersion, this._baseAddress, this._salt, this._feeAddress);
+        const tx = this.buildBase(addressInitData);
+        tx.to = this._contractAddress;
+        if (this._contractCounter) {
+            tx.deployedAddress = (0, utils_1.calculateForwarderAddress)(this._contractAddress, this._contractCounter);
+        }
+        if (this._salt && this._initCode) {
+            const saltBuffer = ethUtil.setLengthLeft(ethUtil.toBuffer(this._salt), 32);
+            const { createForwarderParams, createForwarderTypes } = (0, utils_1.getCreateForwarderParamsAndTypes)(this._baseAddress, saltBuffer, this._feeAddress);
+            // Hash the wallet base address and fee address if present with the given salt, so the address directly relies on the base address and fee address
+            const calculationSalt = ethUtil.bufferToHex(ethereumjs_abi_1.default.soliditySHA3(createForwarderTypes, createForwarderParams));
+            tx.deployedAddress = (0, utils_1.calculateForwarderV1Address)(this._contractAddress, calculationSalt, this._initCode);
+        }
+        return tx;
+    }
+    // endregion
+    // region flush methods
+    /**
+     * Set the forwarder address to flush
+     *
+     * @param {string} address The address to flush
+     */
+    forwarderAddress(address) {
+        if (!(0, utils_1.isValidEthAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + address);
+        }
+        this._forwarderAddress = address;
+    }
+    /**
+     * Set the address of the ERC20 token contract that we are flushing tokens for
+     *
+     * @param {string} address the contract address of the token to flush
+     */
+    tokenAddress(address) {
+        if (!(0, utils_1.isValidEthAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + address);
+        }
+        this._tokenAddress = address;
+    }
+    /**
+     * Set the token ID for ERC721/ERC1155 token flush
+     *
+     * @param {string} tokenId the token ID to flush
+     */
+    tokenId(tokenId) {
+        this._tokenId = tokenId;
+    }
+    /**
+     * Build a transaction to flush tokens from a forwarder.
+     *
+     * @returns {TxData} The Ethereum transaction data
+     */
+    buildFlushTokensTransaction() {
+        if (this._forwarderVersion >= 4 && this._contractAddress !== this._forwarderAddress) {
+            throw new sdk_core_1.BuildTransactionError('Invalid contract address: ' + this._contractAddress);
+        }
+        return this.buildBase((0, utils_1.flushTokensData)(this._forwarderAddress, this._tokenAddress, this._forwarderVersion));
+    }
+    /**
+     * Build a transaction to flush tokens from a forwarder.
+     *
+     * @returns {TxData} The Ethereum transaction data
+     */
+    buildFlushCoinsTransaction() {
+        return this.buildBase((0, utils_1.flushCoinsData)());
+    }
+    /**
+     * Build a transaction to flush ERC721 NFTs from a forwarder.
+     *
+     * @returns {TxData} The Ethereum transaction data
+     */
+    buildFlushERC721Transaction() {
+        if (!this._tokenAddress) {
+            throw new sdk_core_1.BuildTransactionError('Token address is required for ERC721 flush');
+        }
+        if (!this._tokenId) {
+            throw new sdk_core_1.BuildTransactionError('Token ID is required for ERC721 flush');
+        }
+        if (this._forwarderVersion >= 4 && this._contractAddress !== this._forwarderAddress) {
+            throw new sdk_core_1.BuildTransactionError('Invalid contract address: ' + this._contractAddress);
+        }
+        return this.buildBase((0, utils_1.flushERC721TokensData)(this._forwarderAddress, this._tokenAddress, this._tokenId, this._forwarderVersion));
+    }
+    /**
+     * Build a transaction to flush ERC1155 tokens from a forwarder.
+     *
+     * @returns {TxData} The Ethereum transaction data
+     */
+    buildFlushERC1155Transaction() {
+        if (!this._tokenAddress) {
+            throw new sdk_core_1.BuildTransactionError('Token address is required for ERC1155 flush');
+        }
+        if (!this._tokenId) {
+            throw new sdk_core_1.BuildTransactionError('Token ID is required for ERC1155 flush');
+        }
+        if (this._forwarderVersion >= 4 && this._contractAddress !== this._forwarderAddress) {
+            throw new sdk_core_1.BuildTransactionError('Invalid contract address: ' + this._contractAddress);
+        }
+        return this.buildBase((0, utils_1.flushERC1155TokensData)(this._forwarderAddress, this._tokenAddress, this._tokenId, this._forwarderVersion));
+    }
+    // endregion
+    // region generic contract call
+    data(encodedCall) {
+        const supportedTransactionTypes = [
+            sdk_core_1.TransactionType.ContractCall,
+            sdk_core_1.TransactionType.RecoveryWalletDeployment,
+            sdk_core_1.TransactionType.DecryptionDelegation,
+        ];
+        if (!supportedTransactionTypes.includes(this._type)) {
+            throw new sdk_core_1.BuildTransactionError('data can only be set for contract call transaction types');
+        }
+        this._data = encodedCall;
+    }
+    buildGenericContractCallTransaction() {
+        return this.buildBase(this._data);
+    }
+    // endregion
+    /** @inheritdoc */
+    get transaction() {
+        return this._transaction;
+    }
+    /** @inheritdoc */
+    set transaction(transaction) {
+        this._transaction = transaction;
+    }
+    /**
+     * Get the final v value. Final v is described in EIP-155.
+     *
+     * @protected for internal use when the enableFinalVField flag is true.
+     */
+    getFinalV() {
+        return ethUtil.addHexPrefix(this._common.chainIdBN().muln(2).addn(35).toString(16));
+    }
+    /**
+     * Set the forwarder version for address to be initialized
+     *
+     * @param {number} version forwarder version
+     */
+    forwarderVersion(version) {
+        if (version < 0 || version > 4 || version === 3) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid forwarder version: ${version}`);
+        }
+        this._forwarderVersion = version;
+    }
+    /**
+     * Set the salt to create the address using create2
+     *
+     * @param {string} salt The salt to create the address using create2, hex string
+     */
+    salt(salt) {
+        this._salt = salt;
+    }
+    /**
+     * Take the implementation address for the proxy contract, and get the binary initcode for the associated proxy
+     *
+     * @param {string} implementationAddress The address of the implementation contract
+     */
+    initCode(implementationAddress) {
+        if (!(0, utils_1.isValidEthAddress)(implementationAddress)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + implementationAddress);
+        }
+        this._initCode = (0, utils_1.getProxyInitcode)(implementationAddress);
+    }
+    /**
+     * Set the wallet version for wallet to be initialized
+     *
+     * @param {number} version wallet version
+     */
+    walletVersion(version) {
+        if (version < 0 || version > 4 || version === 3) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid wallet version: ${version}`);
+        }
+        this._walletVersion = version;
+    }
+    /**
+     * Set the base address of the wallet
+     *
+     * @param {string} address The wallet contract address
+     */
+    baseAddress(address) {
+        if (!(0, utils_1.isValidEthAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + address);
+        }
+        this._baseAddress = address;
+    }
+    /**
+     * Set the fee address of the wallet
+     *
+     * @param {string} address The fee address of the wallet
+     */
+    feeAddress(address) {
+        if (!(0, utils_1.isValidEthAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + address);
+        }
+        this._feeAddress = address;
+    }
+    /**
+     * Get the wallet version for wallet
+     */
+    getWalletVersion() {
+        return this._walletVersion;
+    }
+    // region FlushERC7984ForwarderToken builder methods
+    /**
+     * Set the ERC-7984 token contract address for forwarder flush transactions.
+     *
+     * @param {string} address The ERC-7984 token contract address
+     */
+    tokenContractAddress(address) {
+        if (!(0, utils_1.isValidEthAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + address);
+        }
+        this._tokenContractAddress = address;
+    }
+    /**
+     * Set the encrypted balance handle (bytes32 hex) for forwarder flush transactions.
+     * This is the opaque handle returned by confidentialBalanceOf() on the ERC-7984 token contract.
+     *
+     * @param {string} handle The bytes32 hex encrypted balance handle
+     */
+    encryptedHandle(handle) {
+        this._encryptedHandle = handle;
+    }
+    /**
+     * Set the parent address (root wallet) for ERC-7984 forwarder flush transactions.
+     * The flushed tokens will be transferred to this address.
+     *
+     * @param {string} address The parent wallet address
+     */
+    parentAddress(address) {
+        if (!(0, utils_1.isValidEthAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + address);
+        }
+        this._parentAddress = address;
+    }
+    /**
+     * Build a transaction to flush ERC-7984 tokens from a V4 forwarder to the parent wallet.
+     * Encodes: callFromParent(tokenContractAddress, 0, confidentialTransfer(parentAddress, encryptedHandle))
+     *
+     * @returns {TxData} The Ethereum transaction data
+     */
+    buildFlushERC7984ForwarderTokenTransaction() {
+        if (this._contractAddress !== this._forwarderAddress) {
+            throw new sdk_core_1.BuildTransactionError('contractAddress must equal forwarderAddress for FlushERC7984ForwarderToken');
+        }
+        const data = (0, zamaUtils_1.buildFlushERC7984ForwarderTokenCalldata)(this._tokenContractAddress, this._parentAddress, this._encryptedHandle);
+        return this.buildBase(data);
+    }
+    // endregion
+    // region WrapERC7984 builder methods
+    /**
+     * Set the wrap recipient (`to` argument of wrap(address,uint256)).
+     * Self-directed shields use the wallet base address.
+     */
+    wrapRecipient(address) {
+        if (!(0, utils_1.isValidEthAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + address);
+        }
+        this._wrapRecipient = address;
+    }
+    /**
+     * Set the underlying amount to wrap (base units, decimal string).
+     */
+    wrapAmount(amount) {
+        this._wrapAmount = amount;
+    }
+    /**
+     * Set the wrapper on-chain `rate()` used for amount × rate uint64 validation.
+     */
+    wrapRate(rate) {
+        this._wrapRate = rate;
+    }
+    /**
+     * Build a WrapERC7984 (shield) transaction: wrap(to, amount) against the wrapper contract.
+     * Does not set gasLimit — WP owns gas.
+     */
+    buildWrapERC7984Transaction() {
+        const data = (0, zamaUtils_1.buildWrapCalldata)(this._wrapRecipient, this._wrapAmount, this._wrapRate);
+        return this.buildBase(data);
+    }
+    // endregion
+    // region UnwrapERC7984 builder methods
+    /**
+     * Set the unwrap `from` address (source of confidential balance).
+     */
+    unwrapFrom(address) {
+        if (!(0, utils_1.isValidEthAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + address);
+        }
+        this._unwrapFrom = address;
+    }
+    /**
+     * Set the unwrap `to` address (recipient of released ERC-20).
+     */
+    unwrapTo(address) {
+        if (!(0, utils_1.isValidEthAddress)(address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address: ' + address);
+        }
+        this._unwrapTo = address;
+    }
+    /**
+     * Set the bytes32 encrypted amount handle for unwrap.
+     */
+    unwrapEncryptedAmount(encryptedAmount) {
+        this._unwrapEncryptedAmount = encryptedAmount;
+    }
+    /**
+     * Set the encryption input proof for unwrap.
+     */
+    unwrapInputProof(inputProof) {
+        this._unwrapInputProof = inputProof;
+    }
+    /**
+     * Build an UnwrapERC7984 (unshield phase-1) transaction.
+     * Does not set gasLimit — WP owns gas.
+     */
+    buildUnwrapERC7984Transaction() {
+        const data = (0, zamaUtils_1.buildUnwrapCalldata)(this._unwrapFrom, this._unwrapTo, this._unwrapEncryptedAmount, this._unwrapInputProof);
+        return this.buildBase(data);
+    }
+    // endregion
+    // region FinalizeUnwrapERC7984 builder methods
+    /**
+     * Set the bytes32 unwrap request id for finalizeUnwrap.
+     */
+    finalizeUnwrapRequestId(requestId) {
+        this._finalizeUnwrapRequestId = requestId;
+    }
+    /**
+     * Set the cleartext (decrypted) amount for finalizeUnwrap.
+     */
+    finalizeUnwrapCleartextAmount(cleartextAmount) {
+        this._finalizeUnwrapCleartextAmount = cleartextAmount;
+    }
+    /**
+     * Set the oracle decryption proof for finalizeUnwrap.
+     */
+    finalizeUnwrapDecryptionProof(decryptionProof) {
+        this._finalizeUnwrapDecryptionProof = decryptionProof;
+    }
+    /**
+     * Build a FinalizeUnwrapERC7984 (unshield phase-2) transaction.
+     * Does not set gasLimit — WP owns gas.
+     */
+    buildFinalizeUnwrapERC7984Transaction() {
+        const data = (0, zamaUtils_1.buildFinalizeUnwrapCalldata)(this._finalizeUnwrapRequestId, this._finalizeUnwrapCleartextAmount, this._finalizeUnwrapDecryptionProof);
+        return this.buildBase(data);
+    }
+}
+exports.TransactionBuilder = TransactionBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig, EthereumNetwork, CoinFeature } from '@bitgo-beta/statics';\nimport EthereumCommon from '@ethereumjs/common';\nimport EthereumAbi from 'ethereumjs-abi';\nimport BigNumber from 'bignumber.js';\nimport * as ethUtil from 'ethereumjs-util';\nimport { FeeMarketEIP1559Transaction } from '@ethereumjs/tx';\n\nimport {\n  BaseAddress,\n  BaseKey,\n  BaseTransaction,\n  BaseTransactionBuilder,\n  BuildTransactionError,\n  InvalidTransactionError,\n  isValidPrv,\n  isValidXprv,\n  ParseTransactionError,\n  SigningError,\n  TransactionType,\n} from '@bitgo-beta/sdk-core';\n\nimport { KeyPair } from './keyPair';\nimport {\n  ETHTransactionType,\n  Fee,\n  FlushERC7984ForwarderTokenData,\n  SignatureParts,\n  TxData,\n  WrapERC7984Data,\n  UnwrapERC7984Data,\n  FinalizeUnwrapERC7984Data,\n} from './iface';\nimport {\n  calculateForwarderAddress,\n  calculateForwarderV1Address,\n  classifyTransaction,\n  decodeForwarderCreationData,\n  decodeFlushTokensData,\n  decodeFlushERC721TokensData,\n  decodeFlushERC1155TokensData,\n  decodeFlushERC7984ForwarderTokenData,\n  decodeWrapERC7984Data,\n  decodeUnwrapERC7984Data,\n  decodeFinalizeUnwrapERC7984Data,\n  decodeWalletCreationData,\n  flushCoinsData,\n  flushTokensData,\n  flushERC721TokensData,\n  flushERC1155TokensData,\n  getAddressInitDataAllForwarderVersions,\n  getCommon,\n  getProxyInitcode,\n  hasSignature,\n  isValidEthAddress,\n  getV1WalletInitializationData,\n  getCreateForwarderParamsAndTypes,\n} from './utils';\nimport {\n  buildFlushERC7984ForwarderTokenCalldata,\n  buildWrapCalldata,\n  buildUnwrapCalldata,\n  buildFinalizeUnwrapCalldata,\n} from './zamaUtils';\nimport { defaultWalletVersion, walletSimpleConstructor } from './walletUtil';\nimport { ERC1155TransferBuilder } from './transferBuilders/transferBuilderERC1155';\nimport { ERC721TransferBuilder } from './transferBuilders/transferBuilderERC721';\nimport { TransferBuilderERC7984 } from './transferBuilders/transferBuilderERC7984';\nimport { Transaction } from './transaction';\nimport { TransferBuilder } from './transferBuilder';\n\nconst DEFAULT_M = 3;\nconst RAW_TX_HEX_REGEX = /^(0x)?[0-9a-f]{1,}$/;\n\n/**\n * EthereumLike transaction builder.\n */\nexport abstract class TransactionBuilder extends BaseTransactionBuilder {\n  protected _type: TransactionType;\n  // Specifies common chain and hardfork parameters.\n  protected _common: EthereumCommon;\n  protected _sourceKeyPair: KeyPair;\n  private _transaction: Transaction;\n  private _counter: number;\n  private _fee: Fee;\n  protected _value: string;\n\n  // the signature on the external ETH transaction\n  private _txSignature: SignatureParts;\n\n  // Wallet initialization transaction parameters\n  private _walletOwnerAddresses: string[];\n  protected _walletVersion: number;\n\n  // flush tokens parameters\n  private _forwarderAddress: string;\n  private _tokenAddress: string;\n  private _tokenId: string;\n\n  // FlushERC7984ForwarderToken parameters\n  private _tokenContractAddress: string;\n  private _encryptedHandle: string; // bytes32 hex from confidentialBalanceOf\n  private _parentAddress: string; // where flushed tokens go (wallet base address)\n\n  // WrapERC7984 parameters\n  private _wrapRecipient: string; // wrap(to, ...) recipient of confidential mint\n  private _wrapAmount: string; // underlying amount to wrap (base units)\n  private _wrapRate: string; // on-chain rate() for uint64 validation\n\n  // UnwrapERC7984 parameters\n  private _unwrapFrom: string;\n  private _unwrapTo: string;\n  private _unwrapEncryptedAmount: string;\n  private _unwrapInputProof: string;\n\n  // FinalizeUnwrapERC7984 parameters\n  private _finalizeUnwrapRequestId: string;\n  private _finalizeUnwrapCleartextAmount: string;\n  private _finalizeUnwrapDecryptionProof: string;\n\n  // Send and AddressInitialization transaction specific parameters\n  protected _transfer: TransferBuilder | ERC721TransferBuilder | ERC1155TransferBuilder | TransferBuilderERC7984;\n  private _contractAddress: string;\n  private _contractCounter: number;\n  private _forwarderVersion: number;\n  private _initCode: string;\n  private _baseAddress: string;\n  private _feeAddress: string;\n\n  // generic contract call builder\n  // encoded contract call hex\n  private _data: string;\n\n  // Common parameter for wallet initialization and address initialization transaction\n  private _salt: string;\n\n  // walletsimplebytecode\n  protected _walletSimpleByteCode: string;\n\n  /**\n   * Public constructor.\n   *\n   * @param _coinConfig\n   */\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._common = getCommon(this._coinConfig.network as EthereumNetwork);\n    this._type = TransactionType.Send;\n    this._counter = 0;\n    this._value = '0';\n    this._walletOwnerAddresses = [];\n    this._forwarderVersion = 0;\n    this._walletVersion = 0;\n    this.transaction = new Transaction(this._coinConfig, this._common);\n    this._walletSimpleByteCode = '';\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<BaseTransaction> {\n    const transactionData = this.getTransactionData();\n\n    if (this._txSignature) {\n      Object.assign(transactionData, this._txSignature);\n    }\n\n    this.transaction.setTransactionType(this._type);\n    transactionData.from = this._sourceKeyPair ? this._sourceKeyPair.getAddress() : undefined;\n    this.transaction.setTransactionData(\n      transactionData,\n      this._transfer ? this._transfer.getIsFirstSigner() : undefined\n    );\n    // Build and sign a new transaction based on the latest changes\n    if (this._sourceKeyPair && this._sourceKeyPair.getKeys().prv) {\n      await this.transaction.sign(this._sourceKeyPair);\n    }\n    return this.transaction;\n  }\n\n  protected getTransactionData(): TxData {\n    switch (this._type) {\n      case TransactionType.WalletInitialization:\n        return this.buildWalletInitializationTransaction(this._walletVersion);\n      case TransactionType.RecoveryWalletDeployment:\n        return this.buildBase(this._data);\n      case TransactionType.Send:\n      case TransactionType.SendERC721:\n      case TransactionType.SendERC1155:\n      case TransactionType.SendERC7984:\n        return this.buildSendTransaction();\n      case TransactionType.AddressInitialization:\n        return this.buildAddressInitializationTransaction();\n      case TransactionType.FlushTokens:\n        return this.buildFlushTokensTransaction();\n      case TransactionType.FlushCoins:\n        return this.buildFlushCoinsTransaction();\n      case TransactionType.FlushERC721:\n        return this.buildFlushERC721Transaction();\n      case TransactionType.FlushERC1155:\n        return this.buildFlushERC1155Transaction();\n      case TransactionType.SingleSigSend:\n        return this.buildBase('0x');\n      case TransactionType.ContractCall:\n      case TransactionType.DecryptionDelegation:\n        return this.buildGenericContractCallTransaction();\n      case TransactionType.FlushERC7984ForwarderToken:\n        return this.buildFlushERC7984ForwarderTokenTransaction();\n      case TransactionType.WrapERC7984:\n        return this.buildWrapERC7984Transaction();\n      case TransactionType.UnwrapERC7984:\n        return this.buildUnwrapERC7984Transaction();\n      case TransactionType.FinalizeUnwrapERC7984:\n        return this.buildFinalizeUnwrapERC7984Transaction();\n      default:\n        throw new BuildTransactionError('Unsupported transaction type');\n    }\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string, isFirstSigner?: boolean): Transaction {\n    let tx: Transaction;\n    if (RAW_TX_HEX_REGEX.test(rawTransaction.toLowerCase())) {\n      tx = Transaction.fromSerialized(this._coinConfig, this._common, rawTransaction, isFirstSigner);\n      this.loadBuilderInput(tx.toJson(), isFirstSigner);\n    } else {\n      const txData = JSON.parse(rawTransaction);\n      tx = new Transaction(this._coinConfig, txData);\n    }\n    return tx;\n  }\n\n  /**\n   * Load the builder data using the deserialized transaction\n   *\n   * @param {TxData} transactionJson the deserialized transaction json\n   * @param {boolean} isFirstSigner if the transaction is being signed by the first signer\n   */\n  protected loadBuilderInput(transactionJson: TxData, isFirstSigner?: boolean): void {\n    const decodedType = classifyTransaction(transactionJson.data);\n    this.type(decodedType);\n    this.counter(transactionJson.nonce);\n    this.value(transactionJson.value);\n\n    if (transactionJson._type === ETHTransactionType.LEGACY) {\n      this.fee({\n        fee: transactionJson.gasPrice,\n        gasPrice: transactionJson.gasPrice,\n        gasLimit: transactionJson.gasLimit,\n      });\n    } else {\n      this.fee({\n        gasLimit: transactionJson.gasLimit,\n        fee: transactionJson.maxFeePerGas,\n        eip1559: {\n          maxFeePerGas: transactionJson.maxFeePerGas,\n          maxPriorityFeePerGas: transactionJson.maxPriorityFeePerGas,\n        },\n      });\n    }\n\n    if (hasSignature(transactionJson)) {\n      this._txSignature = { v: transactionJson.v!, r: transactionJson.r!, s: transactionJson.s! };\n    }\n    this.setTransactionTypeFields(decodedType, transactionJson, isFirstSigner);\n  }\n\n  protected setTransactionTypeFields(\n    decodedType: TransactionType,\n    transactionJson: TxData,\n    isFirstSigner?: boolean\n  ): void {\n    switch (decodedType) {\n      case TransactionType.WalletInitialization:\n        const { owners, salt } = decodeWalletCreationData(transactionJson.data);\n        owners.forEach((element) => {\n          this.owner(element);\n        });\n        if (salt) {\n          this.salt(salt as string);\n          this.walletVersion(1);\n          this.setContract(transactionJson.to);\n        }\n        break;\n      case TransactionType.RecoveryWalletDeployment:\n        this.data(transactionJson.data);\n        break;\n      case TransactionType.FlushTokens:\n        this.setContract(transactionJson.to);\n        const { forwarderAddress, tokenAddress, forwarderVersion } = decodeFlushTokensData(\n          transactionJson.data,\n          transactionJson.to\n        );\n        if (forwarderVersion === 4) {\n          this.forwarderVersion(4);\n        }\n        this.forwarderAddress(forwarderAddress);\n        this.tokenAddress(tokenAddress);\n        break;\n      case TransactionType.FlushCoins:\n        this.setContract(transactionJson.to);\n        break;\n      case TransactionType.FlushERC721:\n        this.setContract(transactionJson.to);\n        const erc721Data = decodeFlushERC721TokensData(transactionJson.data, transactionJson.to);\n        if (erc721Data.forwarderVersion === 4) {\n          this.forwarderVersion(erc721Data.forwarderVersion);\n        }\n        this.forwarderAddress(erc721Data.forwarderAddress);\n        this.tokenAddress(erc721Data.tokenAddress);\n        this.tokenId(erc721Data.tokenId);\n        break;\n      case TransactionType.FlushERC1155:\n        this.setContract(transactionJson.to);\n        const erc1155Data = decodeFlushERC1155TokensData(transactionJson.data, transactionJson.to);\n        if (erc1155Data.forwarderVersion === 4) {\n          this.forwarderVersion(erc1155Data.forwarderVersion);\n        }\n        this.forwarderAddress(erc1155Data.forwarderAddress);\n        this.tokenAddress(erc1155Data.tokenAddress);\n        this.tokenId(erc1155Data.tokenId);\n        break;\n      case TransactionType.Send:\n      case TransactionType.SendERC1155:\n      case TransactionType.SendERC721:\n      case TransactionType.SendERC7984:\n        this.setContract(transactionJson.to);\n        this._transfer = this.transfer(transactionJson.data, isFirstSigner);\n        break;\n      case TransactionType.AddressInitialization:\n        this.setContract(transactionJson.to);\n        const { baseAddress, addressCreationSalt, feeAddress } = decodeForwarderCreationData(transactionJson.data);\n        if (baseAddress && addressCreationSalt) {\n          this.baseAddress(baseAddress);\n          this.salt(addressCreationSalt);\n          if (feeAddress) {\n            this.feeAddress(feeAddress);\n            this.forwarderVersion(4);\n          } else {\n            this.forwarderVersion(1);\n          }\n          const forwarderImplementationAddress = (this._coinConfig.network as EthereumNetwork)\n            .forwarderImplementationAddress as string;\n          if (forwarderImplementationAddress) {\n            this.initCode(forwarderImplementationAddress);\n          }\n        }\n        break;\n      case TransactionType.SingleSigSend:\n        this.setContract(transactionJson.to);\n        break;\n      case TransactionType.ContractCall:\n      case TransactionType.DecryptionDelegation:\n        this.setContract(transactionJson.to);\n        this.data(transactionJson.data);\n        break;\n      case TransactionType.FlushERC7984ForwarderToken: {\n        this.setContract(transactionJson.to);\n        const erc7984Data: FlushERC7984ForwarderTokenData = decodeFlushERC7984ForwarderTokenData(\n          transactionJson.data,\n          transactionJson.to!\n        );\n        this.forwarderAddress(erc7984Data.forwarderAddress);\n        this.tokenContractAddress(erc7984Data.tokenContractAddress);\n        this.encryptedHandle(erc7984Data.encryptedHandle);\n        this.parentAddress(erc7984Data.parentAddress);\n        break;\n      }\n      case TransactionType.WrapERC7984: {\n        this.setContract(transactionJson.to);\n        const wrapData: WrapERC7984Data = decodeWrapERC7984Data(transactionJson.data, transactionJson.to!);\n        this.wrapRecipient(wrapData.to);\n        this.wrapAmount(wrapData.amount);\n        // rate is not encoded in calldata; callers that rebuild must set wrapRate() again\n        break;\n      }\n      case TransactionType.UnwrapERC7984: {\n        this.setContract(transactionJson.to);\n        const unwrapData: UnwrapERC7984Data = decodeUnwrapERC7984Data(transactionJson.data, transactionJson.to!);\n        this.unwrapFrom(unwrapData.from);\n        this.unwrapTo(unwrapData.to);\n        this.unwrapEncryptedAmount(unwrapData.encryptedAmount);\n        this.unwrapInputProof(unwrapData.inputProof);\n        break;\n      }\n      case TransactionType.FinalizeUnwrapERC7984: {\n        this.setContract(transactionJson.to);\n        const finalizeData: FinalizeUnwrapERC7984Data = decodeFinalizeUnwrapERC7984Data(\n          transactionJson.data,\n          transactionJson.to!\n        );\n        this.finalizeUnwrapRequestId(finalizeData.requestId);\n        this.finalizeUnwrapCleartextAmount(finalizeData.cleartextAmount);\n        this.finalizeUnwrapDecryptionProof(finalizeData.decryptionProof);\n        break;\n      }\n      default:\n        throw new BuildTransactionError('Unsupported transaction type');\n      // TODO: Add other cases of deserialization\n    }\n  }\n\n  /** @inheritdoc */\n  protected signImplementation(key: BaseKey): BaseTransaction {\n    const signer = new KeyPair({ prv: key.key });\n    if (this._type === TransactionType.WalletInitialization && this._walletOwnerAddresses.length === 0) {\n      throw new SigningError('Cannot sign an wallet initialization transaction without owners');\n    }\n    if (this._sourceKeyPair) {\n      throw new SigningError('Cannot sign multiple times a non send-type transaction');\n    }\n    // Signing the transaction is an async operation, so save the source and leave the actual\n    // signing for the build step\n    this._sourceKeyPair = signer;\n    return this.transaction;\n  }\n\n  /** @inheritdoc */\n  validateAddress(address: BaseAddress): void {\n    if (!isValidEthAddress(address.address)) {\n      throw new BuildTransactionError('Invalid address ' + address.address);\n    }\n  }\n\n  /** @inheritdoc */\n  validateKey(key: BaseKey): void {\n    if (!(isValidXprv(key.key) || isValidPrv(key.key))) {\n      throw new BuildTransactionError('Invalid key');\n    }\n  }\n\n  /**\n   * Validate the raw transaction is either a JSON or\n   * a hex encoded transaction\n   *\n   * @param {any} rawTransaction The raw transaction to be validated\n   */\n  validateRawTransaction(rawTransaction: any): void {\n    if (!rawTransaction) {\n      throw new InvalidTransactionError('Raw transaction is empty');\n    }\n    if (typeof rawTransaction === 'string') {\n      if (RAW_TX_HEX_REGEX.test(rawTransaction.toLowerCase())) {\n        const txBytes = ethUtil.toBuffer(ethUtil.addHexPrefix(rawTransaction.toLowerCase()));\n        if (!this.isEip1559Txn(txBytes) && !this.isRLPDecodable(txBytes)) {\n          throw new ParseTransactionError('There was error in decoding the hex string');\n        }\n      } else {\n        try {\n          JSON.parse(rawTransaction);\n        } catch (e) {\n          throw new ParseTransactionError('There was error in parsing the JSON string');\n        }\n      }\n    } else {\n      throw new InvalidTransactionError('Transaction is not a hex string or stringified json');\n    }\n  }\n\n  private isEip1559Txn(txn: Buffer): boolean {\n    try {\n      FeeMarketEIP1559Transaction.fromSerializedTx(txn);\n      return true;\n    } catch (_) {\n      return false;\n    }\n  }\n\n  private isRLPDecodable(bytes: Buffer): boolean {\n    try {\n      ethUtil.rlp.decode(bytes);\n      return true;\n    } catch (_) {\n      return false;\n    }\n  }\n\n  protected validateBaseTransactionFields(): void {\n    if (this._fee === undefined || (!this._fee.fee && !this._fee.gasPrice && !this._fee.eip1559)) {\n      throw new BuildTransactionError('Invalid transaction: missing fee');\n    }\n    if (this._common === undefined) {\n      throw new BuildTransactionError('Invalid transaction: network common');\n    }\n    if (this._counter === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing address counter');\n    }\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction: BaseTransaction): void {\n    this.validateBaseTransactionFields();\n    switch (this._type) {\n      case TransactionType.WalletInitialization:\n        this.validateWalletInitializationFields();\n        break;\n      case TransactionType.RecoveryWalletDeployment:\n        this.validateDataField();\n        break;\n      case TransactionType.Send:\n      case TransactionType.SendERC721:\n      case TransactionType.SendERC1155:\n      case TransactionType.SendERC7984:\n        this.validateContractAddress();\n        break;\n      case TransactionType.AddressInitialization:\n        this.validateContractAddress();\n        break;\n      case TransactionType.FlushCoins:\n        this.validateContractAddress();\n        break;\n      case TransactionType.FlushTokens:\n        this.validateContractAddress();\n        this.validateForwarderAddress();\n        this.validateTokenAddress();\n        break;\n      case TransactionType.FlushERC721:\n      case TransactionType.FlushERC1155:\n        this.validateContractAddress();\n        if (this._forwarderVersion < 4) {\n          this.validateForwarderAddress();\n        }\n        this.validateTokenAddress();\n        if (!this._tokenId) {\n          throw new BuildTransactionError(\n            this._type === TransactionType.FlushERC721\n              ? 'Token ID is required for ERC721 flush'\n              : 'Token ID is required for ERC1155 flush'\n          );\n        }\n        break;\n      case TransactionType.SingleSigSend:\n        // for single sig sends, the contract address is actually the recipient\n        this.validateContractAddress();\n        break;\n      case TransactionType.StakingLock:\n      case TransactionType.StakingUnlock:\n      case TransactionType.StakingVote:\n      case TransactionType.StakingUnvote:\n      case TransactionType.StakingActivate:\n      case TransactionType.StakingWithdraw:\n        break;\n      case TransactionType.ContractCall:\n      case TransactionType.DecryptionDelegation:\n        this.validateContractAddress();\n        this.validateDataField();\n        break;\n      case TransactionType.FlushERC7984ForwarderToken:\n        this.validateContractAddress();\n        this.validateForwarderAddress();\n        this.validateTokenContractAddress();\n        this.validateEncryptedHandle();\n        this.validateParentAddress();\n        break;\n      case TransactionType.WrapERC7984:\n        this.validateContractAddress();\n        this.validateWrapRecipient();\n        this.validateWrapAmount();\n        break;\n      case TransactionType.UnwrapERC7984:\n        this.validateContractAddress();\n        this.validateUnwrapFrom();\n        this.validateUnwrapTo();\n        this.validateUnwrapEncryptedAmount();\n        this.validateUnwrapInputProof();\n        break;\n      case TransactionType.FinalizeUnwrapERC7984:\n        this.validateContractAddress();\n        this.validateFinalizeUnwrapRequestId();\n        this.validateFinalizeUnwrapCleartextAmount();\n        this.validateFinalizeUnwrapDecryptionProof();\n        break;\n      default:\n        throw new BuildTransactionError('Unsupported transaction type');\n    }\n  }\n\n  /**\n   * Check wallet owner addresses for wallet initialization transactions are valid or throw.\n   */\n  private validateWalletInitializationFields(): void {\n    if (this._walletOwnerAddresses === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing wallet owners');\n    }\n\n    if (this._walletOwnerAddresses.length !== 3) {\n      throw new BuildTransactionError(\n        `Invalid transaction: wrong number of owners -- required: 3, found: ${this._walletOwnerAddresses.length}`\n      );\n    }\n  }\n\n  /**\n   * Check if a token address for the tx was defined or throw.\n   */\n  private validateTokenAddress(): void {\n    if (this._tokenAddress === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing token address');\n    }\n  }\n\n  /**\n   * Check if a forwarder address for the tx was defined or throw.\n   */\n  private validateForwarderAddress(): void {\n    if (this._forwarderAddress === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing forwarder address');\n    }\n  }\n\n  /**\n   * Check if a contract address for the wallet was defined or throw.\n   */\n  private validateContractAddress(): void {\n    if (this._contractAddress === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing contract address');\n    }\n  }\n\n  /**\n   * Checks if a contract call data field was defined or throws otherwise\n   */\n  private validateDataField(): void {\n    if (!this._data) {\n      throw new BuildTransactionError('Invalid transaction: missing contract call data field');\n    }\n  }\n\n  /**\n   * Check if a token contract address for ERC-7984 flush was defined or throw.\n   */\n  private validateTokenContractAddress(): void {\n    if (!this._tokenContractAddress) {\n      throw new BuildTransactionError('Invalid transaction: missing tokenContractAddress');\n    }\n  }\n\n  /**\n   * Check if an encrypted handle for ERC-7984 flush was defined or throw.\n   */\n  private validateEncryptedHandle(): void {\n    if (!this._encryptedHandle) {\n      throw new BuildTransactionError('Invalid transaction: missing encryptedHandle');\n    }\n  }\n\n  /**\n   * Check if a parent address for ERC-7984 flush was defined or throw.\n   */\n  private validateParentAddress(): void {\n    if (!this._parentAddress) {\n      throw new BuildTransactionError('Invalid transaction: missing parentAddress');\n    }\n  }\n\n  private validateWrapRecipient(): void {\n    if (!this._wrapRecipient) {\n      throw new BuildTransactionError('Invalid transaction: missing wrapRecipient');\n    }\n  }\n\n  private validateWrapAmount(): void {\n    if (!this._wrapAmount) {\n      throw new BuildTransactionError('Invalid transaction: missing wrapAmount');\n    }\n  }\n\n  private validateUnwrapFrom(): void {\n    if (!this._unwrapFrom) {\n      throw new BuildTransactionError('Invalid transaction: missing unwrapFrom');\n    }\n  }\n\n  private validateUnwrapTo(): void {\n    if (!this._unwrapTo) {\n      throw new BuildTransactionError('Invalid transaction: missing unwrapTo');\n    }\n  }\n\n  private validateUnwrapEncryptedAmount(): void {\n    if (!this._unwrapEncryptedAmount) {\n      throw new BuildTransactionError('Invalid transaction: missing unwrapEncryptedAmount');\n    }\n  }\n\n  private validateUnwrapInputProof(): void {\n    if (!this._unwrapInputProof) {\n      throw new BuildTransactionError('Invalid transaction: missing unwrapInputProof');\n    }\n  }\n\n  private validateFinalizeUnwrapRequestId(): void {\n    if (!this._finalizeUnwrapRequestId) {\n      throw new BuildTransactionError('Invalid transaction: missing finalizeUnwrapRequestId');\n    }\n  }\n\n  private validateFinalizeUnwrapCleartextAmount(): void {\n    if (!this._finalizeUnwrapCleartextAmount) {\n      throw new BuildTransactionError('Invalid transaction: missing finalizeUnwrapCleartextAmount');\n    }\n  }\n\n  private validateFinalizeUnwrapDecryptionProof(): void {\n    if (!this._finalizeUnwrapDecryptionProof) {\n      throw new BuildTransactionError('Invalid transaction: missing finalizeUnwrapDecryptionProof');\n    }\n  }\n\n  private setContract(address: string | undefined): void {\n    if (address === undefined) {\n      throw new BuildTransactionError('Undefined recipient address');\n    }\n    this.contract(address);\n  }\n\n  validateValue(value: BigNumber): void {\n    if (value.isLessThan(0)) {\n      throw new BuildTransactionError('Value cannot be below less than zero');\n    }\n    // TODO: validate the amount is not bigger than the max amount in each Eth family coin\n  }\n\n  // region Common builder methods\n\n  /**\n   * The type of transaction being built.\n   *\n   * @param {TransactionType} type\n   */\n  type(type: TransactionType): void {\n    this._type = type;\n  }\n\n  /**\n   * Set the transaction fees. Low fees may get a transaction rejected or never picked up by bakers.\n   *\n   * @param {Fee} fee Baker fees. May also include the maximum gas to pay\n   */\n  fee(fee: Fee): void {\n    this.validateValue(new BigNumber(fee.fee));\n    if (fee.gasLimit) {\n      this.validateValue(new BigNumber(fee.gasLimit));\n    }\n    if (fee.eip1559) {\n      const maxFee = new BigNumber(fee.eip1559.maxFeePerGas);\n      const priorityFee = new BigNumber(fee.eip1559.maxPriorityFeePerGas);\n      this.validateValue(maxFee);\n      this.validateValue(priorityFee);\n      if (priorityFee.isGreaterThan(maxFee)) {\n        throw new BuildTransactionError('maxPriorityFeePerGas cannot exceed maxFeePerGas');\n      }\n    }\n    if (fee.gasPrice) {\n      this.validateValue(new BigNumber(fee.gasPrice));\n    }\n    this._fee = fee;\n  }\n\n  /**\n   * Set the transaction counter to prevent submitting repeated transactions.\n   *\n   * @param {number} counter The counter to use\n   */\n  counter(counter: number): void {\n    if (counter < 0) {\n      throw new BuildTransactionError(`Invalid counter: ${counter}`);\n    }\n\n    this._counter = counter;\n  }\n\n  /**\n   * The value to send along with this transaction. 0 by default\n   *\n   * @param {string} value The value to send along with this transaction\n   */\n  value(value: string): void {\n    this._value = value;\n  }\n\n  // set args that are required for all types of eth transactions\n  protected buildBase(data: string): TxData {\n    const baseParams = {\n      gasLimit: this._fee.gasLimit,\n      nonce: this._counter,\n      data: data,\n      chainId: this._common.chainIdBN().toString(),\n      value: this._value,\n      to: this._contractAddress,\n    };\n\n    if (this._fee.eip1559) {\n      return {\n        ...baseParams,\n        _type: ETHTransactionType.EIP1559,\n        maxFeePerGas: this._fee.eip1559.maxFeePerGas,\n        maxPriorityFeePerGas: this._fee.eip1559.maxPriorityFeePerGas,\n      };\n    } else {\n      return {\n        ...baseParams,\n        _type: ETHTransactionType.LEGACY,\n        gasPrice: this._fee?.gasPrice ?? this._fee.fee,\n        v: this.getFinalV(),\n      };\n    }\n  }\n\n  // endregion\n\n  // region WalletInitialization builder methods\n  /**\n   * Set one of the owners of the multisig wallet.\n   *\n   * @param {string} address An Ethereum address\n   */\n  owner(address: string): void {\n    if (this._type !== TransactionType.WalletInitialization) {\n      throw new BuildTransactionError('Multisig wallet owner can only be set for initialization transactions');\n    }\n    if (this._walletOwnerAddresses.length >= DEFAULT_M) {\n      throw new BuildTransactionError('A maximum of ' + DEFAULT_M + ' owners can be set for a multisig wallet');\n    }\n    if (!isValidEthAddress(address)) {\n      throw new BuildTransactionError('Invalid address: ' + address);\n    }\n    if (this._walletOwnerAddresses.includes(address)) {\n      throw new BuildTransactionError('Repeated owner address: ' + address);\n    }\n    this._walletOwnerAddresses.push(address);\n  }\n\n  /**\n   * Build a transaction for a generic multisig contract.\n   *\n   * @returns {TxData} The Ethereum transaction data\n   */\n  protected buildWalletInitializationTransaction(walletVersion?: number): TxData {\n    const walletInitData =\n      walletVersion === defaultWalletVersion\n        ? this.getContractData(this._walletOwnerAddresses)\n        : getV1WalletInitializationData(this._walletOwnerAddresses, this._salt);\n    return this.buildBase(walletInitData);\n  }\n\n  /**\n   * Returns the smart contract encoded data\n   *\n   * @param {string[]} addresses - the contract signers\n   * @returns {string} - the smart contract encoded data\n   */\n  protected getContractData(addresses: string[]): string {\n    const params = [addresses];\n    const resultEncodedParameters = EthereumAbi.rawEncode(walletSimpleConstructor, params)\n      .toString('hex')\n      .replace('0x', '');\n    return this._walletSimpleByteCode + resultEncodedParameters;\n  }\n\n  // endregion\n\n  // region Send builder methods\n\n  contract(address: string): void {\n    if (!isValidEthAddress(address)) {\n      throw new BuildTransactionError('Invalid address: ' + address);\n    }\n    this._contractAddress = address;\n  }\n\n  /**\n   * Gets the transfer funds builder if exist, or creates a new one for this transaction and returns it\n   *\n   * @param {string} data transfer data to initialize the transfer builder with, empty if none given\n   * @param {boolean} isFirstSigner whether the transaction is being signed by the first signer\n   * @returns {TransferBuilder | ERC721TransferBuilder | ERC1155TransferBuilder | TransferBuilderERC7984} the transfer builder\n   */\n  abstract transfer(\n    data?: string,\n    isFirstSigner?: boolean\n  ): TransferBuilder | ERC721TransferBuilder | ERC1155TransferBuilder | TransferBuilderERC7984;\n\n  /**\n   * Returns the serialized sendMultiSig contract method data\n   *\n   * @returns {string} serialized sendMultiSig data\n   */\n  public getSendData(): string {\n    if (!this._transfer) {\n      throw new BuildTransactionError('Missing transfer information');\n    }\n    const chainId = this._common.chainIdBN().toString();\n    this._transfer.walletVersion(this._walletVersion);\n    // This change is made to support new contracts with different encoding type\n    return this._transfer.signAndBuild(chainId, this.coinUsesNonPackedEncodingForTxData());\n  }\n\n  /**\n   * Decide if the coin uses non-packed encoding for tx data\n   *\n   * @returns {boolean} true if the coin uses non-packed encoding for tx data\n   */\n  public coinUsesNonPackedEncodingForTxData(): boolean {\n    return (\n      this._walletVersion === 4 || this._coinConfig.features.includes(CoinFeature.USES_NON_PACKED_ENCODING_FOR_TXDATA)\n    );\n  }\n\n  private buildSendTransaction(): TxData {\n    const sendData = this.getSendData();\n    const tx: TxData = this.buildBase(sendData);\n    tx.to = this._contractAddress;\n    return tx;\n  }\n\n  // endregion\n\n  // region AddressInitialization builder methods\n\n  /**\n   * Set the contract transaction nonce to calculate the forwarder address.\n   *\n   * @param {number} contractCounter The counter to use\n   */\n  contractCounter(contractCounter: number): void {\n    if (contractCounter < 0) {\n      throw new BuildTransactionError(`Invalid contract counter: ${contractCounter}`);\n    }\n\n    this._contractCounter = contractCounter;\n  }\n\n  /**\n   * Build a transaction to create a forwarder.\n   *\n   * @returns {TxData} The Ethereum transaction data\n   */\n  private buildAddressInitializationTransaction(): TxData {\n    const addressInitData = getAddressInitDataAllForwarderVersions(\n      this._forwarderVersion,\n      this._baseAddress,\n      this._salt,\n      this._feeAddress\n    );\n    const tx: TxData = this.buildBase(addressInitData);\n    tx.to = this._contractAddress;\n\n    if (this._contractCounter) {\n      tx.deployedAddress = calculateForwarderAddress(this._contractAddress, this._contractCounter);\n    }\n\n    if (this._salt && this._initCode) {\n      const saltBuffer = ethUtil.setLengthLeft(ethUtil.toBuffer(this._salt), 32);\n\n      const { createForwarderParams, createForwarderTypes } = getCreateForwarderParamsAndTypes(\n        this._baseAddress,\n        saltBuffer,\n        this._feeAddress\n      );\n\n      // Hash the wallet base address and fee address if present with the given salt, so the address directly relies on the base address and fee address\n      const calculationSalt = ethUtil.bufferToHex(\n        EthereumAbi.soliditySHA3(createForwarderTypes, createForwarderParams)\n      );\n      tx.deployedAddress = calculateForwarderV1Address(this._contractAddress, calculationSalt, this._initCode);\n    }\n    return tx;\n  }\n  // endregion\n\n  // region flush methods\n  /**\n   * Set the forwarder address to flush\n   *\n   * @param {string} address The address to flush\n   */\n  forwarderAddress(address: string): void {\n    if (!isValidEthAddress(address)) {\n      throw new BuildTransactionError('Invalid address: ' + address);\n    }\n    this._forwarderAddress = address;\n  }\n\n  /**\n   * Set the address of the ERC20 token contract that we are flushing tokens for\n   *\n   * @param {string} address the contract address of the token to flush\n   */\n  tokenAddress(address: string): void {\n    if (!isValidEthAddress(address)) {\n      throw new BuildTransactionError('Invalid address: ' + address);\n    }\n    this._tokenAddress = address;\n  }\n\n  /**\n   * Set the token ID for ERC721/ERC1155 token flush\n   *\n   * @param {string} tokenId the token ID to flush\n   */\n  tokenId(tokenId: string): void {\n    this._tokenId = tokenId;\n  }\n\n  /**\n   * Build a transaction to flush tokens from a forwarder.\n   *\n   * @returns {TxData} The Ethereum transaction data\n   */\n  private buildFlushTokensTransaction(): TxData {\n    if (this._forwarderVersion >= 4 && this._contractAddress !== this._forwarderAddress) {\n      throw new BuildTransactionError('Invalid contract address: ' + this._contractAddress);\n    }\n    return this.buildBase(flushTokensData(this._forwarderAddress, this._tokenAddress, this._forwarderVersion));\n  }\n\n  /**\n   * Build a transaction to flush tokens from a forwarder.\n   *\n   * @returns {TxData} The Ethereum transaction data\n   */\n  private buildFlushCoinsTransaction(): TxData {\n    return this.buildBase(flushCoinsData());\n  }\n\n  /**\n   * Build a transaction to flush ERC721 NFTs from a forwarder.\n   *\n   * @returns {TxData} The Ethereum transaction data\n   */\n  private buildFlushERC721Transaction(): TxData {\n    if (!this._tokenAddress) {\n      throw new BuildTransactionError('Token address is required for ERC721 flush');\n    }\n    if (!this._tokenId) {\n      throw new BuildTransactionError('Token ID is required for ERC721 flush');\n    }\n    if (this._forwarderVersion >= 4 && this._contractAddress !== this._forwarderAddress) {\n      throw new BuildTransactionError('Invalid contract address: ' + this._contractAddress);\n    }\n    return this.buildBase(\n      flushERC721TokensData(this._forwarderAddress, this._tokenAddress, this._tokenId, this._forwarderVersion)\n    );\n  }\n\n  /**\n   * Build a transaction to flush ERC1155 tokens from a forwarder.\n   *\n   * @returns {TxData} The Ethereum transaction data\n   */\n  private buildFlushERC1155Transaction(): TxData {\n    if (!this._tokenAddress) {\n      throw new BuildTransactionError('Token address is required for ERC1155 flush');\n    }\n    if (!this._tokenId) {\n      throw new BuildTransactionError('Token ID is required for ERC1155 flush');\n    }\n    if (this._forwarderVersion >= 4 && this._contractAddress !== this._forwarderAddress) {\n      throw new BuildTransactionError('Invalid contract address: ' + this._contractAddress);\n    }\n    return this.buildBase(\n      flushERC1155TokensData(this._forwarderAddress, this._tokenAddress, this._tokenId, this._forwarderVersion)\n    );\n  }\n  // endregion\n\n  // region generic contract call\n  data(encodedCall: string): void {\n    const supportedTransactionTypes = [\n      TransactionType.ContractCall,\n      TransactionType.RecoveryWalletDeployment,\n      TransactionType.DecryptionDelegation,\n    ];\n    if (!supportedTransactionTypes.includes(this._type)) {\n      throw new BuildTransactionError('data can only be set for contract call transaction types');\n    }\n    this._data = encodedCall;\n  }\n\n  private buildGenericContractCallTransaction(): TxData {\n    return this.buildBase(this._data);\n  }\n  // endregion\n\n  /** @inheritdoc */\n  protected get transaction(): Transaction {\n    return this._transaction;\n  }\n\n  /** @inheritdoc */\n  protected set transaction(transaction: Transaction) {\n    this._transaction = transaction;\n  }\n\n  /**\n   * Get the final v value. Final v is described in EIP-155.\n   *\n   * @protected for internal use when the enableFinalVField flag is true.\n   */\n  protected getFinalV(): string {\n    return ethUtil.addHexPrefix(this._common.chainIdBN().muln(2).addn(35).toString(16));\n  }\n\n  /**\n   * Set the forwarder version for address to be initialized\n   *\n   * @param {number} version forwarder version\n   */\n  forwarderVersion(version: number): void {\n    if (version < 0 || version > 4 || version === 3) {\n      throw new BuildTransactionError(`Invalid forwarder version: ${version}`);\n    }\n\n    this._forwarderVersion = version;\n  }\n\n  /**\n   * Set the salt to create the address using create2\n   *\n   * @param {string} salt The salt to create the address using create2, hex string\n   */\n  salt(salt: string): void {\n    this._salt = salt;\n  }\n\n  /**\n   * Take the implementation address for the proxy contract, and get the binary initcode for the associated proxy\n   *\n   * @param {string} implementationAddress The address of the implementation contract\n   */\n  initCode(implementationAddress: string): void {\n    if (!isValidEthAddress(implementationAddress)) {\n      throw new BuildTransactionError('Invalid address: ' + implementationAddress);\n    }\n    this._initCode = getProxyInitcode(implementationAddress);\n  }\n\n  /**\n   * Set the wallet version for wallet to be initialized\n   *\n   * @param {number} version wallet version\n   */\n  walletVersion(version: number): void {\n    if (version < 0 || version > 4 || version === 3) {\n      throw new BuildTransactionError(`Invalid wallet version: ${version}`);\n    }\n\n    this._walletVersion = version;\n  }\n\n  /**\n   * Set the base address of the wallet\n   *\n   * @param {string} address The wallet contract address\n   */\n  baseAddress(address: string): void {\n    if (!isValidEthAddress(address)) {\n      throw new BuildTransactionError('Invalid address: ' + address);\n    }\n    this._baseAddress = address;\n  }\n\n  /**\n   * Set the fee address of the wallet\n   *\n   * @param {string} address The fee address of the wallet\n   */\n  feeAddress(address: string): void {\n    if (!isValidEthAddress(address)) {\n      throw new BuildTransactionError('Invalid address: ' + address);\n    }\n    this._feeAddress = address;\n  }\n\n  /**\n   * Get the wallet version for wallet\n   */\n  public getWalletVersion(): number {\n    return this._walletVersion;\n  }\n\n  // region FlushERC7984ForwarderToken builder methods\n\n  /**\n   * Set the ERC-7984 token contract address for forwarder flush transactions.\n   *\n   * @param {string} address The ERC-7984 token contract address\n   */\n  tokenContractAddress(address: string): void {\n    if (!isValidEthAddress(address)) {\n      throw new BuildTransactionError('Invalid address: ' + address);\n    }\n    this._tokenContractAddress = address;\n  }\n\n  /**\n   * Set the encrypted balance handle (bytes32 hex) for forwarder flush transactions.\n   * This is the opaque handle returned by confidentialBalanceOf() on the ERC-7984 token contract.\n   *\n   * @param {string} handle The bytes32 hex encrypted balance handle\n   */\n  encryptedHandle(handle: string): void {\n    this._encryptedHandle = handle;\n  }\n\n  /**\n   * Set the parent address (root wallet) for ERC-7984 forwarder flush transactions.\n   * The flushed tokens will be transferred to this address.\n   *\n   * @param {string} address The parent wallet address\n   */\n  parentAddress(address: string): void {\n    if (!isValidEthAddress(address)) {\n      throw new BuildTransactionError('Invalid address: ' + address);\n    }\n    this._parentAddress = address;\n  }\n\n  /**\n   * Build a transaction to flush ERC-7984 tokens from a V4 forwarder to the parent wallet.\n   * Encodes: callFromParent(tokenContractAddress, 0, confidentialTransfer(parentAddress, encryptedHandle))\n   *\n   * @returns {TxData} The Ethereum transaction data\n   */\n  private buildFlushERC7984ForwarderTokenTransaction(): TxData {\n    if (this._contractAddress !== this._forwarderAddress) {\n      throw new BuildTransactionError('contractAddress must equal forwarderAddress for FlushERC7984ForwarderToken');\n    }\n    const data = buildFlushERC7984ForwarderTokenCalldata(\n      this._tokenContractAddress,\n      this._parentAddress,\n      this._encryptedHandle\n    );\n    return this.buildBase(data);\n  }\n\n  // endregion\n\n  // region WrapERC7984 builder methods\n\n  /**\n   * Set the wrap recipient (`to` argument of wrap(address,uint256)).\n   * Self-directed shields use the wallet base address.\n   */\n  wrapRecipient(address: string): void {\n    if (!isValidEthAddress(address)) {\n      throw new BuildTransactionError('Invalid address: ' + address);\n    }\n    this._wrapRecipient = address;\n  }\n\n  /**\n   * Set the underlying amount to wrap (base units, decimal string).\n   */\n  wrapAmount(amount: string): void {\n    this._wrapAmount = amount;\n  }\n\n  /**\n   * Set the wrapper on-chain `rate()` used for amount × rate uint64 validation.\n   */\n  wrapRate(rate: string): void {\n    this._wrapRate = rate;\n  }\n\n  /**\n   * Build a WrapERC7984 (shield) transaction: wrap(to, amount) against the wrapper contract.\n   * Does not set gasLimit — WP owns gas.\n   */\n  private buildWrapERC7984Transaction(): TxData {\n    const data = buildWrapCalldata(this._wrapRecipient, this._wrapAmount, this._wrapRate);\n    return this.buildBase(data);\n  }\n\n  // endregion\n\n  // region UnwrapERC7984 builder methods\n\n  /**\n   * Set the unwrap `from` address (source of confidential balance).\n   */\n  unwrapFrom(address: string): void {\n    if (!isValidEthAddress(address)) {\n      throw new BuildTransactionError('Invalid address: ' + address);\n    }\n    this._unwrapFrom = address;\n  }\n\n  /**\n   * Set the unwrap `to` address (recipient of released ERC-20).\n   */\n  unwrapTo(address: string): void {\n    if (!isValidEthAddress(address)) {\n      throw new BuildTransactionError('Invalid address: ' + address);\n    }\n    this._unwrapTo = address;\n  }\n\n  /**\n   * Set the bytes32 encrypted amount handle for unwrap.\n   */\n  unwrapEncryptedAmount(encryptedAmount: string): void {\n    this._unwrapEncryptedAmount = encryptedAmount;\n  }\n\n  /**\n   * Set the encryption input proof for unwrap.\n   */\n  unwrapInputProof(inputProof: string): void {\n    this._unwrapInputProof = inputProof;\n  }\n\n  /**\n   * Build an UnwrapERC7984 (unshield phase-1) transaction.\n   * Does not set gasLimit — WP owns gas.\n   */\n  private buildUnwrapERC7984Transaction(): TxData {\n    const data = buildUnwrapCalldata(\n      this._unwrapFrom,\n      this._unwrapTo,\n      this._unwrapEncryptedAmount,\n      this._unwrapInputProof\n    );\n    return this.buildBase(data);\n  }\n\n  // endregion\n\n  // region FinalizeUnwrapERC7984 builder methods\n\n  /**\n   * Set the bytes32 unwrap request id for finalizeUnwrap.\n   */\n  finalizeUnwrapRequestId(requestId: string): void {\n    this._finalizeUnwrapRequestId = requestId;\n  }\n\n  /**\n   * Set the cleartext (decrypted) amount for finalizeUnwrap.\n   */\n  finalizeUnwrapCleartextAmount(cleartextAmount: string): void {\n    this._finalizeUnwrapCleartextAmount = cleartextAmount;\n  }\n\n  /**\n   * Set the oracle decryption proof for finalizeUnwrap.\n   */\n  finalizeUnwrapDecryptionProof(decryptionProof: string): void {\n    this._finalizeUnwrapDecryptionProof = decryptionProof;\n  }\n\n  /**\n   * Build a FinalizeUnwrapERC7984 (unshield phase-2) transaction.\n   * Does not set gasLimit — WP owns gas.\n   */\n  private buildFinalizeUnwrapERC7984Transaction(): TxData {\n    const data = buildFinalizeUnwrapCalldata(\n      this._finalizeUnwrapRequestId,\n      this._finalizeUnwrapCleartextAmount,\n      this._finalizeUnwrapDecryptionProof\n    );\n    return this.buildBase(data);\n  }\n\n  // endregion\n}\n"]}