@bitgo-beta/sdk-coin-vet 1.0.1-beta.59 → 1.0.1-beta.590

package/dist/src/lib/transaction/validatorRegistrationTransaction.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorRegistrationTransaction = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const sdk_core_2 = require("@vechain/sdk-core");
+const transaction_1 = require("./transaction");
+const ethereumjs_abi_1 = __importDefault(require("ethereumjs-abi"));
+const utils_1 = __importDefault(require("../utils"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ethereumjs_util_1 = require("ethereumjs-util");
+const constants_1 = require("../constants");
+class ValidatorRegistrationTransaction extends transaction_1.Transaction {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._type = sdk_core_1.TransactionType.StakingLock;
+    }
+    get validator() {
+        return this._validator;
+    }
+    set validator(address) {
+        this._validator = address;
+    }
+    get stakingPeriod() {
+        return this._stakingPeriod;
+    }
+    set stakingPeriod(period) {
+        this._stakingPeriod = period;
+    }
+    get stakingContractAddress() {
+        return this._stakingContractAddress;
+    }
+    set stakingContractAddress(address) {
+        this._stakingContractAddress = address;
+    }
+    buildClauses() {
+        if (!this.stakingContractAddress) {
+            throw new Error('Staking contract address is not set');
+        }
+        if (!this.validator) {
+            throw new Error('Validator address is not set');
+        }
+        if (!this.stakingPeriod) {
+            throw new Error('Staking period is not set');
+        }
+        utils_1.default.validateContractAddressForValidatorRegistration(this.stakingContractAddress, this._coinConfig);
+        const addValidationData = this.getAddValidationClauseData(this.validator, this.stakingPeriod);
+        this._transactionData = addValidationData;
+        // Create the clause for delegation
+        this._clauses = [
+            {
+                to: this.stakingContractAddress,
+                value: constants_1.ZERO_VALUE_AMOUNT,
+                data: addValidationData,
+            },
+        ];
+        // Set recipients based on the clauses
+        this._recipients = [
+            {
+                address: this.stakingContractAddress,
+                amount: constants_1.ZERO_VALUE_AMOUNT,
+            },
+        ];
+    }
+    /**
+     * Encodes addValidation transaction data using ethereumjs-abi for addValidation method
+     * @param {string} validator - address of the validator
+     * @param {number} period - staking period, denoted in blocks, that the Validator commits to hard
+  locking their VET into the built-in staker contract. Allowed values are 60480 (7 days),
+  129600 (15 days) or 259200 (30 days)
+     * @returns {string} - The encoded transaction data
+     */
+    getAddValidationClauseData(validator, period) {
+        const methodName = 'addValidation';
+        const types = ['address', 'uint32'];
+        const params = [validator, new ethereumjs_util_1.BN(period)];
+        const method = ethereumjs_abi_1.default.methodID(methodName, types);
+        const args = ethereumjs_abi_1.default.rawEncode(types, params);
+        return (0, ethereumjs_util_1.addHexPrefix)(Buffer.concat([method, args]).toString('hex'));
+    }
+    toJson() {
+        const json = {
+            id: this.id,
+            chainTag: this.chainTag,
+            blockRef: this.blockRef,
+            expiration: this.expiration,
+            gasPriceCoef: this.gasPriceCoef,
+            gas: this.gas,
+            dependsOn: this.dependsOn,
+            nonce: this.nonce,
+            data: this.transactionData,
+            value: constants_1.ZERO_VALUE_AMOUNT,
+            sender: this.sender,
+            to: this.stakingContractAddress,
+            stakingContractAddress: this.stakingContractAddress,
+            amountToStake: constants_1.ZERO_VALUE_AMOUNT,
+            validatorAddress: this.validator,
+            stakingPeriod: this.stakingPeriod,
+        };
+        return json;
+    }
+    fromDeserializedSignedTransaction(signedTx) {
+        try {
+            if (!signedTx || !signedTx.body) {
+                throw new sdk_core_1.InvalidTransactionError('Invalid transaction: missing transaction body');
+            }
+            // Store the raw transaction
+            this.rawTransaction = signedTx;
+            // Set transaction body properties
+            const body = signedTx.body;
+            this.chainTag = typeof body.chainTag === 'number' ? body.chainTag : 0;
+            this.blockRef = body.blockRef || '0x0';
+            this.expiration = typeof body.expiration === 'number' ? body.expiration : 64;
+            this.clauses = body.clauses || [];
+            this.gasPriceCoef = typeof body.gasPriceCoef === 'number' ? body.gasPriceCoef : 128;
+            this.gas = typeof body.gas === 'number' ? body.gas : Number(body.gas) || 0;
+            this.dependsOn = body.dependsOn || null;
+            this.nonce = String(body.nonce);
+            // Set validator registration-specific properties
+            if (body.clauses.length > 0) {
+                // Get the addValidation clause
+                const addValidationClause = body.clauses[0];
+                if (addValidationClause.to) {
+                    this.stakingContractAddress = addValidationClause.to;
+                }
+                // Extract validator and period from addValidation data
+                if (addValidationClause.data) {
+                    this.transactionData = addValidationClause.data;
+                    const decoded = utils_1.default.decodeAddValidationData(addValidationClause.data);
+                    this.validator = decoded.validator;
+                    this.stakingPeriod = decoded.period;
+                }
+            }
+            // Set recipients from clauses
+            this.recipients = body.clauses.map((clause) => ({
+                address: (clause.to || '0x0').toString().toLowerCase(),
+                amount: new bignumber_js_1.default(clause.value || 0).toString(),
+            }));
+            this.loadInputsAndOutputs();
+            // Set sender address
+            if (signedTx.signature && signedTx.origin) {
+                this.sender = signedTx.origin.toString().toLowerCase();
+            }
+            // Set signatures if present
+            if (signedTx.signature) {
+                // First signature is sender's signature
+                this.senderSignature = Buffer.from(signedTx.signature.slice(0, sdk_core_2.Secp256k1.SIGNATURE_LENGTH));
+                // If there's additional signature data, it's the fee payer's signature
+                if (signedTx.signature.length > sdk_core_2.Secp256k1.SIGNATURE_LENGTH) {
+                    this.feePayerSignature = Buffer.from(signedTx.signature.slice(sdk_core_2.Secp256k1.SIGNATURE_LENGTH));
+                }
+            }
+        }
+        catch (e) {
+            throw new sdk_core_1.InvalidTransactionError(`Failed to deserialize transaction: ${e.message}`);
+        }
+    }
+}
+exports.ValidatorRegistrationTransaction = ValidatorRegistrationTransaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validatorRegistrationTransaction.js","sourceRoot":"","sources":["../../../../src/lib/transaction/validatorRegistrationTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionType, InvalidTransactionError } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { Transaction as VetTransaction, Secp256k1 } from '@vechain/sdk-core';\nimport { Transaction } from './transaction';\nimport { VetTransactionData } from '../iface';\nimport EthereumAbi from 'ethereumjs-abi';\nimport utils from '../utils';\nimport BigNumber from 'bignumber.js';\nimport { addHexPrefix, BN } from 'ethereumjs-util';\nimport { ZERO_VALUE_AMOUNT } from '../constants';\n\nexport class ValidatorRegistrationTransaction extends Transaction {\n  private _stakingContractAddress: string;\n  private _validator: string;\n  private _stakingPeriod: number;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._type = TransactionType.StakingLock;\n  }\n\n  get validator(): string {\n    return this._validator;\n  }\n\n  set validator(address: string) {\n    this._validator = address;\n  }\n\n  get stakingPeriod(): number {\n    return this._stakingPeriod;\n  }\n\n  set stakingPeriod(period: number) {\n    this._stakingPeriod = period;\n  }\n\n  get stakingContractAddress(): string {\n    return this._stakingContractAddress;\n  }\n\n  set stakingContractAddress(address: string) {\n    this._stakingContractAddress = address;\n  }\n\n  buildClauses(): void {\n    if (!this.stakingContractAddress) {\n      throw new Error('Staking contract address is not set');\n    }\n\n    if (!this.validator) {\n      throw new Error('Validator address is not set');\n    }\n\n    if (!this.stakingPeriod) {\n      throw new Error('Staking period is not set');\n    }\n\n    utils.validateContractAddressForValidatorRegistration(this.stakingContractAddress, this._coinConfig);\n    const addValidationData = this.getAddValidationClauseData(this.validator, this.stakingPeriod);\n    this._transactionData = addValidationData;\n    // Create the clause for delegation\n    this._clauses = [\n      {\n        to: this.stakingContractAddress,\n        value: ZERO_VALUE_AMOUNT,\n        data: addValidationData,\n      },\n    ];\n\n    // Set recipients based on the clauses\n    this._recipients = [\n      {\n        address: this.stakingContractAddress,\n        amount: ZERO_VALUE_AMOUNT,\n      },\n    ];\n  }\n\n  /**\n   * Encodes addValidation transaction data using ethereumjs-abi for addValidation method\n   * @param {string} validator - address of the validator\n   * @param {number} period - staking period, denoted in blocks, that the Validator commits to hard\nlocking their VET into the built-in staker contract. Allowed values are 60480 (7 days),\n129600 (15 days) or 259200 (30 days)\n   * @returns {string} - The encoded transaction data\n   */\n  getAddValidationClauseData(validator: string, period: number): string {\n    const methodName = 'addValidation';\n    const types = ['address', 'uint32'];\n    const params = [validator, new BN(period)];\n\n    const method = EthereumAbi.methodID(methodName, types);\n    const args = EthereumAbi.rawEncode(types, params);\n\n    return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n  }\n\n  toJson(): VetTransactionData {\n    const json: VetTransactionData = {\n      id: this.id,\n      chainTag: this.chainTag,\n      blockRef: this.blockRef,\n      expiration: this.expiration,\n      gasPriceCoef: this.gasPriceCoef,\n      gas: this.gas,\n      dependsOn: this.dependsOn,\n      nonce: this.nonce,\n      data: this.transactionData,\n      value: ZERO_VALUE_AMOUNT,\n      sender: this.sender,\n      to: this.stakingContractAddress,\n      stakingContractAddress: this.stakingContractAddress,\n      amountToStake: ZERO_VALUE_AMOUNT,\n      validatorAddress: this.validator,\n      stakingPeriod: this.stakingPeriod,\n    };\n\n    return json;\n  }\n\n  fromDeserializedSignedTransaction(signedTx: VetTransaction): void {\n    try {\n      if (!signedTx || !signedTx.body) {\n        throw new InvalidTransactionError('Invalid transaction: missing transaction body');\n      }\n\n      // Store the raw transaction\n      this.rawTransaction = signedTx;\n\n      // Set transaction body properties\n      const body = signedTx.body;\n      this.chainTag = typeof body.chainTag === 'number' ? body.chainTag : 0;\n      this.blockRef = body.blockRef || '0x0';\n      this.expiration = typeof body.expiration === 'number' ? body.expiration : 64;\n      this.clauses = body.clauses || [];\n      this.gasPriceCoef = typeof body.gasPriceCoef === 'number' ? body.gasPriceCoef : 128;\n      this.gas = typeof body.gas === 'number' ? body.gas : Number(body.gas) || 0;\n      this.dependsOn = body.dependsOn || null;\n      this.nonce = String(body.nonce);\n\n      // Set validator registration-specific properties\n      if (body.clauses.length > 0) {\n        // Get the addValidation clause\n        const addValidationClause = body.clauses[0];\n        if (addValidationClause.to) {\n          this.stakingContractAddress = addValidationClause.to;\n        }\n\n        // Extract validator and period from addValidation data\n        if (addValidationClause.data) {\n          this.transactionData = addValidationClause.data;\n          const decoded = utils.decodeAddValidationData(addValidationClause.data);\n          this.validator = decoded.validator;\n          this.stakingPeriod = decoded.period;\n        }\n      }\n\n      // Set recipients from clauses\n      this.recipients = body.clauses.map((clause) => ({\n        address: (clause.to || '0x0').toString().toLowerCase(),\n        amount: new BigNumber(clause.value || 0).toString(),\n      }));\n      this.loadInputsAndOutputs();\n\n      // Set sender address\n      if (signedTx.signature && signedTx.origin) {\n        this.sender = signedTx.origin.toString().toLowerCase();\n      }\n\n      // Set signatures if present\n      if (signedTx.signature) {\n        // First signature is sender's signature\n        this.senderSignature = Buffer.from(signedTx.signature.slice(0, Secp256k1.SIGNATURE_LENGTH));\n\n        // If there's additional signature data, it's the fee payer's signature\n        if (signedTx.signature.length > Secp256k1.SIGNATURE_LENGTH) {\n          this.feePayerSignature = Buffer.from(signedTx.signature.slice(Secp256k1.SIGNATURE_LENGTH));\n        }\n      }\n    } catch (e) {\n      throw new InvalidTransactionError(`Failed to deserialize transaction: ${e.message}`);\n    }\n  }\n}\n"]}

package/dist/src/lib/transactionBuilder/addressInitializationBuilder.d.ts

@@ -0,0 +1,78 @@
+import { TransactionClause } from '@vechain/sdk-core';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionBuilder } from './transactionBuilder';
+import { AddressInitializationTransaction } from '../transaction/addressInitializationTransaction';
+import { Transaction } from '../transaction/transaction';
+export declare class AddressInitializationBuilder extends TransactionBuilder {
+    /**
+     * Creates a new AddressInitializationBuilder instance.
+     *
+     * @param {Readonly<CoinConfig>} _coinConfig - The coin configuration object
+     */
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Initializes the builder with an existing AddressInitializationTransaction.
+     *
+     * @param {AddressInitializationTransaction} tx - The transaction to initialize the builder with
+     */
+    initBuilder(tx: AddressInitializationTransaction): void;
+    /**
+     * Gets the address initialization transaction instance.
+     *
+     * @returns {AddressInitializationTransaction} The address initialization transaction
+     */
+    get addressInitializationTransaction(): AddressInitializationTransaction;
+    /**
+     * Gets the transaction type for address initialization.
+     *
+     * @returns {TransactionType} The transaction type
+     */
+    protected get transactionType(): TransactionType;
+    /**
+     * Validates the transaction clauses for address initialization.
+     * @param {TransactionClause[]} clauses - The transaction clauses to validate.
+     * @returns {boolean} - Returns true if the clauses are valid, false otherwise.
+     */
+    protected isValidTransactionClauses(clauses: TransactionClause[]): boolean;
+    /**
+     * Sets the base address for this forwarder init tx.
+     *
+     * @param {string} address - The base address to be set for the forwarder address
+     * @returns {AddressInitializationBuilder} This transaction builder
+     */
+    baseAddress(address: string): this;
+    /**
+     * Sets the fee address for this forwarder init tx.
+     *
+     * @param {string} address - The fee address to be set for the forwarder address
+     * @returns {AddressInitializationBuilder} This transaction builder
+     */
+    feeAddress(address: string): this;
+    /**
+     * Sets the salt value for the forwarder address creation.
+     *
+     * @param {string} salt - The salt value to use for address creation
+     * @returns {AddressInitializationBuilder} This transaction builder
+     */
+    salt(salt: string): this;
+    /**
+     * Sets the initialization code for the forwarder contract.
+     *
+     * @param {string} address - The address to generate proxy init code for
+     * @returns {AddressInitializationBuilder} This transaction builder
+     */
+    initCode(address: string): this;
+    /** @inheritdoc */
+    validateTransaction(transaction?: AddressInitializationTransaction): void;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    /**
+     * Generates the transaction data for address initialization by encoding the createForwarder method call.
+     *
+     * @private
+     * @returns {string} The encoded transaction data as a hex string
+     */
+    private getAddressInitializationData;
+}
+//# sourceMappingURL=addressInitializationBuilder.d.ts.map

package/dist/src/lib/transactionBuilder/addressInitializationBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addressInitializationBuilder.d.ts","sourceRoot":"","sources":["../../../../src/lib/transactionBuilder/addressInitializationBuilder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAI7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,gCAAgC,EAAE,MAAM,iDAAiD,CAAC;AACnG,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAGzD,qBAAa,4BAA6B,SAAQ,kBAAkB;IAClE;;;;OAIG;gBACS,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,gCAAgC,GAAG,IAAI;IAIvD;;;;OAIG;IACH,IAAI,gCAAgC,IAAI,gCAAgC,CAEvE;IAED;;;;OAIG;IACH,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;OAIG;IACH,SAAS,CAAC,yBAAyB,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,OAAO;IAiC1E;;;;;OAKG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAMlC;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAMjC;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKxB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAM/B,kBAAkB;IAClB,mBAAmB,CAAC,WAAW,CAAC,EAAE,gCAAgC,GAAG,IAAI;IAezE,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAQ3D;;;;;OAKG;IACH,OAAO,CAAC,4BAA4B;CAWrC"}

package/dist/src/lib/transactionBuilder/addressInitializationBuilder.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressInitializationBuilder = void 0;
+const assert_1 = __importDefault(require("assert"));
+const abstract_eth_1 = require("@bitgo-beta/abstract-eth");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const ethereumjs_util_1 = require("ethereumjs-util");
+const ethereumjs_abi_1 = __importDefault(require("ethereumjs-abi"));
+const transactionBuilder_1 = require("./transactionBuilder");
+const utils_1 = __importDefault(require("../utils"));
+class AddressInitializationBuilder extends transactionBuilder_1.TransactionBuilder {
+    /**
+     * Creates a new AddressInitializationBuilder instance.
+     *
+     * @param {Readonly<CoinConfig>} _coinConfig - The coin configuration object
+     */
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /**
+     * Initializes the builder with an existing AddressInitializationTransaction.
+     *
+     * @param {AddressInitializationTransaction} tx - The transaction to initialize the builder with
+     */
+    initBuilder(tx) {
+        this._transaction = tx;
+    }
+    /**
+     * Gets the address initialization transaction instance.
+     *
+     * @returns {AddressInitializationTransaction} The address initialization transaction
+     */
+    get addressInitializationTransaction() {
+        return this._transaction;
+    }
+    /**
+     * Gets the transaction type for address initialization.
+     *
+     * @returns {TransactionType} The transaction type
+     */
+    get transactionType() {
+        return sdk_core_1.TransactionType.AddressInitialization;
+    }
+    /**
+     * Validates the transaction clauses for address initialization.
+     * @param {TransactionClause[]} clauses - The transaction clauses to validate.
+     * @returns {boolean} - Returns true if the clauses are valid, false otherwise.
+     */
+    isValidTransactionClauses(clauses) {
+        try {
+            if (!clauses || !Array.isArray(clauses) || clauses.length === 0) {
+                return false;
+            }
+            const clause = clauses[0];
+            if (!clause.to || !utils_1.default.isValidAddress(clause.to)) {
+                return false;
+            }
+            // For address init transactions, value must be exactly '0x0'
+            if (clause.value !== 0) {
+                return false;
+            }
+            const { baseAddress, addressCreationSalt, feeAddress } = (0, abstract_eth_1.decodeForwarderCreationData)(clause.data);
+            if (!utils_1.default.isValidAddress(baseAddress) || !utils_1.default.isValidAddress(feeAddress)) {
+                return false;
+            }
+            if (!addressCreationSalt) {
+                return false;
+            }
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Sets the base address for this forwarder init tx.
+     *
+     * @param {string} address - The base address to be set for the forwarder address
+     * @returns {AddressInitializationBuilder} This transaction builder
+     */
+    baseAddress(address) {
+        this.validateAddress({ address });
+        this.addressInitializationTransaction.baseAddress = address;
+        return this;
+    }
+    /**
+     * Sets the fee address for this forwarder init tx.
+     *
+     * @param {string} address - The fee address to be set for the forwarder address
+     * @returns {AddressInitializationBuilder} This transaction builder
+     */
+    feeAddress(address) {
+        this.validateAddress({ address });
+        this.addressInitializationTransaction.feeAddress = address;
+        return this;
+    }
+    /**
+     * Sets the salt value for the forwarder address creation.
+     *
+     * @param {string} salt - The salt value to use for address creation
+     * @returns {AddressInitializationBuilder} This transaction builder
+     */
+    salt(salt) {
+        this.addressInitializationTransaction.salt = salt;
+        return this;
+    }
+    /**
+     * Sets the initialization code for the forwarder contract.
+     *
+     * @param {string} address - The address to generate proxy init code for
+     * @returns {AddressInitializationBuilder} This transaction builder
+     */
+    initCode(address) {
+        this.validateAddress({ address });
+        this.addressInitializationTransaction.initCode = (0, abstract_eth_1.getProxyInitcode)(address);
+        return this;
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        if (!transaction) {
+            throw new Error('transaction not defined');
+        }
+        (0, assert_1.default)(transaction.contract, 'Contract address is required');
+        (0, assert_1.default)(transaction.baseAddress, 'Base address is required');
+        (0, assert_1.default)(transaction.feeAddress, 'Fee address is required');
+        (0, assert_1.default)(transaction.salt, 'Salt is required');
+        (0, assert_1.default)(transaction.initCode, 'Init code is required');
+        this.validateAddress({ address: transaction.contract });
+        this.validateAddress({ address: transaction.baseAddress });
+        this.validateAddress({ address: transaction.feeAddress });
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        const transactionData = this.getAddressInitializationData();
+        this.transaction.type = this.transactionType;
+        this.addressInitializationTransaction.transactionData = transactionData;
+        await this.addressInitializationTransaction.build();
+        return this.transaction;
+    }
+    /**
+     * Generates the transaction data for address initialization by encoding the createForwarder method call.
+     *
+     * @private
+     * @returns {string} The encoded transaction data as a hex string
+     */
+    getAddressInitializationData() {
+        const saltBuffer = (0, ethereumjs_util_1.setLengthLeft)((0, ethereumjs_util_1.toBuffer)(this.addressInitializationTransaction.salt), 32);
+        const { createForwarderParams, createForwarderTypes } = (0, abstract_eth_1.getCreateForwarderParamsAndTypes)(this.addressInitializationTransaction.baseAddress, saltBuffer, this.addressInitializationTransaction.feeAddress);
+        const method = ethereumjs_abi_1.default.methodID('createForwarder', createForwarderTypes);
+        const args = ethereumjs_abi_1.default.rawEncode(createForwarderTypes, createForwarderParams);
+        return (0, ethereumjs_util_1.addHexPrefix)(Buffer.concat([method, args]).toString('hex'));
+    }
+}
+exports.AddressInitializationBuilder = AddressInitializationBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"addressInitializationBuilder.js","sourceRoot":"","sources":["../../../../src/lib/transactionBuilder/addressInitializationBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport { TransactionClause } from '@vechain/sdk-core';\nimport { getProxyInitcode, getCreateForwarderParamsAndTypes, decodeForwarderCreationData } from '@bitgo-beta/abstract-eth';\nimport { TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { setLengthLeft, toBuffer, addHexPrefix } from 'ethereumjs-util';\nimport EthereumAbi from 'ethereumjs-abi';\n\nimport { TransactionBuilder } from './transactionBuilder';\nimport { AddressInitializationTransaction } from '../transaction/addressInitializationTransaction';\nimport { Transaction } from '../transaction/transaction';\nimport utils from '../utils';\n\nexport class AddressInitializationBuilder extends TransactionBuilder {\n  /**\n   * Creates a new AddressInitializationBuilder instance.\n   *\n   * @param {Readonly<CoinConfig>} _coinConfig - The coin configuration object\n   */\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * Initializes the builder with an existing AddressInitializationTransaction.\n   *\n   * @param {AddressInitializationTransaction} tx - The transaction to initialize the builder with\n   */\n  initBuilder(tx: AddressInitializationTransaction): void {\n    this._transaction = tx;\n  }\n\n  /**\n   * Gets the address initialization transaction instance.\n   *\n   * @returns {AddressInitializationTransaction} The address initialization transaction\n   */\n  get addressInitializationTransaction(): AddressInitializationTransaction {\n    return this._transaction as AddressInitializationTransaction;\n  }\n\n  /**\n   * Gets the transaction type for address initialization.\n   *\n   * @returns {TransactionType} The transaction type\n   */\n  protected get transactionType(): TransactionType {\n    return TransactionType.AddressInitialization;\n  }\n\n  /**\n   * Validates the transaction clauses for address initialization.\n   * @param {TransactionClause[]} clauses - The transaction clauses to validate.\n   * @returns {boolean} - Returns true if the clauses are valid, false otherwise.\n   */\n  protected isValidTransactionClauses(clauses: TransactionClause[]): boolean {\n    try {\n      if (!clauses || !Array.isArray(clauses) || clauses.length === 0) {\n        return false;\n      }\n\n      const clause = clauses[0];\n\n      if (!clause.to || !utils.isValidAddress(clause.to)) {\n        return false;\n      }\n\n      // For address init transactions, value must be exactly '0x0'\n      if (clause.value !== 0) {\n        return false;\n      }\n\n      const { baseAddress, addressCreationSalt, feeAddress } = decodeForwarderCreationData(clause.data);\n\n      if (!utils.isValidAddress(baseAddress as string) || !utils.isValidAddress(feeAddress as string)) {\n        return false;\n      }\n\n      if (!addressCreationSalt) {\n        return false;\n      }\n\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Sets the base address for this forwarder init tx.\n   *\n   * @param {string} address - The base address to be set for the forwarder address\n   * @returns {AddressInitializationBuilder} This transaction builder\n   */\n  baseAddress(address: string): this {\n    this.validateAddress({ address });\n    this.addressInitializationTransaction.baseAddress = address;\n    return this;\n  }\n\n  /**\n   * Sets the fee address for this forwarder init tx.\n   *\n   * @param {string} address - The fee address to be set for the forwarder address\n   * @returns {AddressInitializationBuilder} This transaction builder\n   */\n  feeAddress(address: string): this {\n    this.validateAddress({ address });\n    this.addressInitializationTransaction.feeAddress = address;\n    return this;\n  }\n\n  /**\n   * Sets the salt value for the forwarder address creation.\n   *\n   * @param {string} salt - The salt value to use for address creation\n   * @returns {AddressInitializationBuilder} This transaction builder\n   */\n  salt(salt: string): this {\n    this.addressInitializationTransaction.salt = salt;\n    return this;\n  }\n\n  /**\n   * Sets the initialization code for the forwarder contract.\n   *\n   * @param {string} address - The address to generate proxy init code for\n   * @returns {AddressInitializationBuilder} This transaction builder\n   */\n  initCode(address: string): this {\n    this.validateAddress({ address });\n    this.addressInitializationTransaction.initCode = getProxyInitcode(address);\n    return this;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction?: AddressInitializationTransaction): void {\n    if (!transaction) {\n      throw new Error('transaction not defined');\n    }\n    assert(transaction.contract, 'Contract address is required');\n    assert(transaction.baseAddress, 'Base address is required');\n    assert(transaction.feeAddress, 'Fee address is required');\n    assert(transaction.salt, 'Salt is required');\n    assert(transaction.initCode, 'Init code is required');\n\n    this.validateAddress({ address: transaction.contract });\n    this.validateAddress({ address: transaction.baseAddress });\n    this.validateAddress({ address: transaction.feeAddress });\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    const transactionData = this.getAddressInitializationData();\n    this.transaction.type = this.transactionType;\n    this.addressInitializationTransaction.transactionData = transactionData;\n    await this.addressInitializationTransaction.build();\n    return this.transaction;\n  }\n\n  /**\n   * Generates the transaction data for address initialization by encoding the createForwarder method call.\n   *\n   * @private\n   * @returns {string} The encoded transaction data as a hex string\n   */\n  private getAddressInitializationData(): string {\n    const saltBuffer = setLengthLeft(toBuffer(this.addressInitializationTransaction.salt), 32);\n    const { createForwarderParams, createForwarderTypes } = getCreateForwarderParamsAndTypes(\n      this.addressInitializationTransaction.baseAddress,\n      saltBuffer,\n      this.addressInitializationTransaction.feeAddress\n    );\n    const method = EthereumAbi.methodID('createForwarder', createForwarderTypes);\n    const args = EthereumAbi.rawEncode(createForwarderTypes, createForwarderParams);\n    return addHexPrefix(Buffer.concat([method, args]).toString('hex'));\n  }\n}\n"]}

package/dist/src/lib/transactionBuilder/burnNftBuilder.d.ts

@@ -0,0 +1,59 @@
+import { TransactionClause } from '@vechain/sdk-core';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionBuilder } from './transactionBuilder';
+import { BurnNftTransaction } from '../transaction/burnNftTransaction';
+import { Transaction } from '../transaction/transaction';
+export declare class BurnNftBuilder extends TransactionBuilder {
+    /**
+     * Creates a new BurnNftBuilder instance.
+     *
+     * @param {Readonly<CoinConfig>} _coinConfig - The coin configuration object
+     */
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Initializes the builder with an existing BurnNftTransaction.
+     *
+     * @param {BurnNftTransaction} tx - The transaction to initialize the builder with
+     */
+    initBuilder(tx: BurnNftTransaction): void;
+    /**
+     * Gets the burn NFT transaction instance.
+     *
+     * @returns {BurnNftTransaction} The burn NFT transaction
+     */
+    get burnNftTransaction(): BurnNftTransaction;
+    /**
+     * Gets the transaction type for burning NFT.
+     *
+     * @returns {TransactionType} The transaction type
+     */
+    protected get transactionType(): TransactionType;
+    /**
+     * Validates the transaction clauses for burning NFT.
+     * @param {TransactionClause[]} clauses - The transaction clauses to validate.
+     * @returns {boolean} - Returns true if the clauses are valid, false otherwise.
+     */
+    protected isValidTransactionClauses(clauses: TransactionClause[]): boolean;
+    /**
+     * Sets the token ID for this burn NFT transaction.
+     *
+     * @param {string} tokenId - The ID of the NFT token to burn
+     * @returns {BurnNftBuilder} This transaction builder
+     */
+    tokenId(tokenId: string): this;
+    /**
+     * Sets the staking contract address for this staking tx.
+     * The address must be explicitly provided to ensure the correct contract is used.
+     *
+     * @param {string} address - The staking contract address (required)
+     * @returns {StakingBuilder} This transaction builder
+     * @throws {Error} If no address is provided
+     */
+    stakingContractAddress(address: string): this;
+    /** @inheritdoc */
+    validateTransaction(transaction?: BurnNftTransaction): void;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=burnNftBuilder.d.ts.map

package/dist/src/lib/transactionBuilder/burnNftBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"burnNftBuilder.d.ts","sourceRoot":"","sources":["../../../../src/lib/transactionBuilder/burnNftBuilder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAIzD,qBAAa,cAAe,SAAQ,kBAAkB;IACpD;;;;OAIG;gBACS,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,kBAAkB,GAAG,IAAI;IAIzC;;;;OAIG;IACH,IAAI,kBAAkB,IAAI,kBAAkB,CAE3C;IAED;;;;OAIG;IACH,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;OAIG;IACH,SAAS,CAAC,yBAAyB,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,OAAO;IA4B1E;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK9B;;;;;;;OAOG;IACH,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAS7C,kBAAkB;IAClB,mBAAmB,CAAC,WAAW,CAAC,EAAE,kBAAkB,GAAG,IAAI;IAU3D,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAK5D"}

package/dist/src/lib/transactionBuilder/burnNftBuilder.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BurnNftBuilder = void 0;
+const assert_1 = __importDefault(require("assert"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const burnNftTransaction_1 = require("../transaction/burnNftTransaction");
+const utils_1 = __importDefault(require("../utils"));
+const constants_1 = require("../constants");
+class BurnNftBuilder extends transactionBuilder_1.TransactionBuilder {
+    /**
+     * Creates a new BurnNftBuilder instance.
+     *
+     * @param {Readonly<CoinConfig>} _coinConfig - The coin configuration object
+     */
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._transaction = new burnNftTransaction_1.BurnNftTransaction(_coinConfig);
+    }
+    /**
+     * Initializes the builder with an existing BurnNftTransaction.
+     *
+     * @param {BurnNftTransaction} tx - The transaction to initialize the builder with
+     */
+    initBuilder(tx) {
+        this._transaction = tx;
+    }
+    /**
+     * Gets the burn NFT transaction instance.
+     *
+     * @returns {BurnNftTransaction} The burn NFT transaction
+     */
+    get burnNftTransaction() {
+        return this._transaction;
+    }
+    /**
+     * Gets the transaction type for burning NFT.
+     *
+     * @returns {TransactionType} The transaction type
+     */
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingWithdraw;
+    }
+    /**
+     * Validates the transaction clauses for burning NFT.
+     * @param {TransactionClause[]} clauses - The transaction clauses to validate.
+     * @returns {boolean} - Returns true if the clauses are valid, false otherwise.
+     */
+    isValidTransactionClauses(clauses) {
+        try {
+            if (!clauses || !Array.isArray(clauses) || clauses.length === 0) {
+                return false;
+            }
+            const clause = clauses[0];
+            if (!clause.to || !utils_1.default.isValidAddress(clause.to)) {
+                return false;
+            }
+            // For burn NFT transactions, value must be exactly '0x0'
+            if (clause.value !== 0) {
+                return false;
+            }
+            // Check if the data starts with the burn method ID
+            if (!clause.data.startsWith(constants_1.BURN_NFT_METHOD_ID)) {
+                return false;
+            }
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Sets the token ID for this burn NFT transaction.
+     *
+     * @param {string} tokenId - The ID of the NFT token to burn
+     * @returns {BurnNftBuilder} This transaction builder
+     */
+    tokenId(tokenId) {
+        this.burnNftTransaction.tokenId = tokenId;
+        return this;
+    }
+    /**
+     * Sets the staking contract address for this staking tx.
+     * The address must be explicitly provided to ensure the correct contract is used.
+     *
+     * @param {string} address - The staking contract address (required)
+     * @returns {StakingBuilder} This transaction builder
+     * @throws {Error} If no address is provided
+     */
+    stakingContractAddress(address) {
+        if (!address) {
+            throw new Error('Staking contract address is required');
+        }
+        this.validateAddress({ address });
+        this.burnNftTransaction.stakingContractAddress = address;
+        return this;
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        if (!transaction) {
+            throw new Error('transaction not defined');
+        }
+        (0, assert_1.default)(transaction.stakingContractAddress, 'Staking contract address is required');
+        (0, assert_1.default)(transaction.tokenId, 'Token ID is required');
+        this.validateAddress({ address: transaction.stakingContractAddress });
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        this.transaction.type = this.transactionType;
+        await this.burnNftTransaction.build();
+        return this.transaction;
+    }
+}
+exports.BurnNftBuilder = BurnNftBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"burnNftBuilder.js","sourceRoot":"","sources":["../../../../src/lib/transactionBuilder/burnNftBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport { TransactionClause } from '@vechain/sdk-core';\nimport { TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\n\nimport { TransactionBuilder } from './transactionBuilder';\nimport { BurnNftTransaction } from '../transaction/burnNftTransaction';\nimport { Transaction } from '../transaction/transaction';\nimport utils from '../utils';\nimport { BURN_NFT_METHOD_ID } from '../constants';\n\nexport class BurnNftBuilder extends TransactionBuilder {\n  /**\n   * Creates a new BurnNftBuilder instance.\n   *\n   * @param {Readonly<CoinConfig>} _coinConfig - The coin configuration object\n   */\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new BurnNftTransaction(_coinConfig);\n  }\n\n  /**\n   * Initializes the builder with an existing BurnNftTransaction.\n   *\n   * @param {BurnNftTransaction} tx - The transaction to initialize the builder with\n   */\n  initBuilder(tx: BurnNftTransaction): void {\n    this._transaction = tx;\n  }\n\n  /**\n   * Gets the burn NFT transaction instance.\n   *\n   * @returns {BurnNftTransaction} The burn NFT transaction\n   */\n  get burnNftTransaction(): BurnNftTransaction {\n    return this._transaction as BurnNftTransaction;\n  }\n\n  /**\n   * Gets the transaction type for burning NFT.\n   *\n   * @returns {TransactionType} The transaction type\n   */\n  protected get transactionType(): TransactionType {\n    return TransactionType.StakingWithdraw;\n  }\n\n  /**\n   * Validates the transaction clauses for burning NFT.\n   * @param {TransactionClause[]} clauses - The transaction clauses to validate.\n   * @returns {boolean} - Returns true if the clauses are valid, false otherwise.\n   */\n  protected isValidTransactionClauses(clauses: TransactionClause[]): boolean {\n    try {\n      if (!clauses || !Array.isArray(clauses) || clauses.length === 0) {\n        return false;\n      }\n\n      const clause = clauses[0];\n\n      if (!clause.to || !utils.isValidAddress(clause.to)) {\n        return false;\n      }\n\n      // For burn NFT transactions, value must be exactly '0x0'\n      if (clause.value !== 0) {\n        return false;\n      }\n\n      // Check if the data starts with the burn method ID\n      if (!clause.data.startsWith(BURN_NFT_METHOD_ID)) {\n        return false;\n      }\n\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Sets the token ID for this burn NFT transaction.\n   *\n   * @param {string} tokenId - The ID of the NFT token to burn\n   * @returns {BurnNftBuilder} This transaction builder\n   */\n  tokenId(tokenId: string): this {\n    this.burnNftTransaction.tokenId = tokenId;\n    return this;\n  }\n\n  /**\n   * Sets the staking contract address for this staking tx.\n   * The address must be explicitly provided to ensure the correct contract is used.\n   *\n   * @param {string} address - The staking contract address (required)\n   * @returns {StakingBuilder} This transaction builder\n   * @throws {Error} If no address is provided\n   */\n  stakingContractAddress(address: string): this {\n    if (!address) {\n      throw new Error('Staking contract address is required');\n    }\n    this.validateAddress({ address });\n    this.burnNftTransaction.stakingContractAddress = address;\n    return this;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction?: BurnNftTransaction): void {\n    if (!transaction) {\n      throw new Error('transaction not defined');\n    }\n    assert(transaction.stakingContractAddress, 'Staking contract address is required');\n    assert(transaction.tokenId, 'Token ID is required');\n\n    this.validateAddress({ address: transaction.stakingContractAddress });\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    this.transaction.type = this.transactionType;\n    await this.burnNftTransaction.build();\n    return this.transaction;\n  }\n}\n"]}