@bitgo-beta/sdk-coin-trx 1.2.3-alpha.317 → 1.2.3-alpha.319

package/dist/src/lib/voteWitnessTxBuilder.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoteWitnessTxBuilder = void 0;
+const crypto_1 = require("crypto");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const transaction_1 = require("./transaction");
+const utils_1 = require("./utils");
+const tron_1 = require("../../resources/protobuf/tron");
+var ContractType = tron_1.protocol.Transaction.Contract.ContractType;
+class VoteWitnessTxBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._signingKeys = [];
+        this.transaction = new transaction_1.Transaction(_coinConfig);
+    }
+    /** @inheritdoc */
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingVote;
+    }
+    /**
+     * Set the votes to be used in the transaction
+     *
+     * @param votes vote data containing vote address and vote count
+     * @returns the builder with the new parameter set
+     */
+    setVotes(votes) {
+        this.validateVotes(votes);
+        this._votes = votes.map((vote) => ({
+            ...vote,
+            vote_address: (0, utils_1.getHexAddressFromBase58Address)(vote.vote_address),
+        }));
+        return this;
+    }
+    /** @inheritdoc */
+    extendValidTo(extensionMs) {
+        if (this.transaction.signature && this.transaction.signature.length > 0) {
+            throw new sdk_core_1.ExtendTransactionError('Cannot extend a signed transaction');
+        }
+        if (extensionMs <= 0) {
+            throw new Error('Value cannot be below zero');
+        }
+        if (extensionMs > utils_1.TRANSACTION_MAX_EXPIRATION) {
+            throw new sdk_core_1.ExtendTransactionError('The expiration cannot be extended more than one year');
+        }
+        if (this._expiration) {
+            this._expiration = this._expiration + extensionMs;
+        }
+        else {
+            throw new Error('There is not expiration to extend');
+        }
+    }
+    /**
+     * Initialize the transaction builder fields using the transaction data
+     *
+     * @param {TransactionReceipt | string} rawTransaction the transaction data in a string or JSON format
+     * @returns {VoteWitnessTxBuilder} the builder with the transaction data set
+     */
+    initBuilder(rawTransaction) {
+        this.transaction = this.fromImplementation(rawTransaction);
+        this.transaction.setTransactionType(this.transactionType);
+        this.validateRawTransaction(rawTransaction);
+        const tx = this.fromImplementation(rawTransaction);
+        this.transaction = tx;
+        this._signingKeys = [];
+        const rawData = tx.toJson().raw_data;
+        this._refBlockBytes = rawData.ref_block_bytes;
+        this._refBlockHash = rawData.ref_block_hash;
+        this._expiration = rawData.expiration;
+        this._timestamp = rawData.timestamp;
+        this.transaction.setTransactionType(sdk_core_1.TransactionType.StakingVote);
+        const contractCall = rawData.contract[0];
+        this.initVoteWitnessContractCall(contractCall);
+        return this;
+    }
+    /**
+     * Initialize the votewitnesscontract call specific data
+     *
+     * @param {VoteWitnessContract} contractCall object with transfer data
+     */
+    initVoteWitnessContractCall(voteWitnessContractCall) {
+        const { votes, owner_address } = voteWitnessContractCall.parameter.value;
+        if (owner_address) {
+            this.source({ address: (0, utils_1.getBase58AddressFromHex)(owner_address) });
+        }
+        if (votes) {
+            this.setVotes(votes.map((vote) => ({
+                ...vote,
+                vote_address: (0, utils_1.getBase58AddressFromHex)(vote.vote_address),
+            })));
+        }
+    }
+    async buildImplementation() {
+        this.createVoteWitnessContractTransaction();
+        /** @inheritdoccreateTransaction */
+        // This method must be extended on child classes
+        if (this._signingKeys.length > 0) {
+            this.applySignatures();
+        }
+        if (!this.transaction.id) {
+            throw new sdk_core_1.BuildTransactionError('A valid transaction must have an id');
+        }
+        return Promise.resolve(this.transaction);
+    }
+    /**
+     * Creates the vote witness transaction
+     */
+    createVoteWitnessContractTransaction() {
+        const rawDataHex = this.getVoteWitnessRawDataHex();
+        const rawData = (0, utils_1.decodeTransaction)(rawDataHex);
+        const contract = rawData.contract[0];
+        const contractParameter = contract.parameter;
+        contractParameter.value.owner_address = this._ownerAddress.toLocaleLowerCase();
+        contractParameter.value.votes = this._votes;
+        contractParameter.type_url = 'type.googleapis.com/protocol.VoteWitnessContract';
+        contract.type = 'VoteWitnessContract';
+        const hexBuffer = Buffer.from(rawDataHex, 'hex');
+        const id = (0, crypto_1.createHash)('sha256').update(hexBuffer).digest('hex');
+        const txRecip = {
+            raw_data: rawData,
+            raw_data_hex: rawDataHex,
+            txID: id,
+            signature: this.transaction.signature,
+        };
+        this.transaction = new transaction_1.Transaction(this._coinConfig, txRecip);
+    }
+    /**
+     * Helper method to get the vote witness transaction raw data hex
+     * @returns vote witness transaction raw data hex
+     */
+    getVoteWitnessRawDataHex() {
+        const voteArray = this._votes.map((vote) => {
+            const voteObject = tron_1.protocol.Vote.fromObject({
+                voteAddress: (0, utils_1.getByteArrayFromHexAddress)(vote.vote_address),
+                voteCount: vote.vote_count,
+            });
+            return tron_1.protocol.Vote.create(voteObject);
+        });
+        const rawContract = {
+            ownerAddress: (0, utils_1.getByteArrayFromHexAddress)(this._ownerAddress),
+            votes: voteArray,
+        };
+        const voteWitnessContract = tron_1.protocol.VoteWitnessContract.fromObject(rawContract);
+        const voteWitnessContractBytes = tron_1.protocol.VoteWitnessContract.encode(voteWitnessContract).finish();
+        const txContract = {
+            type: ContractType.VoteWitnessContract,
+            parameter: {
+                value: voteWitnessContractBytes,
+                type_url: 'type.googleapis.com/protocol.VoteWitnessContract',
+            },
+        };
+        const raw = {
+            refBlockBytes: Buffer.from(this._refBlockBytes, 'hex'),
+            refBlockHash: Buffer.from(this._refBlockHash, 'hex'),
+            expiration: this._expiration || Date.now() + utils_1.TRANSACTION_DEFAULT_EXPIRATION,
+            timestamp: this._timestamp || Date.now(),
+            contract: [txContract],
+        };
+        const rawTx = tron_1.protocol.Transaction.raw.create(raw);
+        return Buffer.from(tron_1.protocol.Transaction.raw.encode(rawTx).finish()).toString('hex');
+    }
+    /** @inheritdoc */
+    signImplementation(key) {
+        if (this._signingKeys.some((signingKey) => signingKey.key === key.key)) {
+            throw new sdk_core_1.SigningError('Duplicated key');
+        }
+        this._signingKeys.push(key);
+        // We keep this return for compatibility but is not meant to be use
+        return this.transaction;
+    }
+    applySignatures() {
+        if (!this.transaction.inputs) {
+            throw new sdk_core_1.SigningError('Transaction has no inputs');
+        }
+        this._signingKeys.forEach((key) => this.applySignature(key));
+    }
+    validateTransaction(transaction) {
+        this.validateVoteTransactionFields();
+    }
+    /**
+     * Validates the votes array
+     *
+     * @param {VoteWitnessData[]} votes - The votes array to validate
+     * @throws {Error} when the votes array is invalid
+     */
+    validateVotes(votes) {
+        if (!votes || votes.length === 0) {
+            throw new Error('Votes array is missing or empty');
+        }
+        votes.forEach((vote) => {
+            if (!vote.vote_address) {
+                throw new Error('Vote address is missing');
+            }
+            this.validateAddress({ address: vote.vote_address });
+            if (vote.vote_count == null || vote.vote_count < 0) {
+                throw new Error('Invalid vote count');
+            }
+        });
+    }
+    /**
+     * Validates if the transaction is a valid vote transaction
+     * @param {TransactionReceipt} transaction - The transaction to validate
+     * @throws {InvalidTransactionError} when the transaction is invalid
+     */
+    validateVoteTransactionFields() {
+        if (!this._ownerAddress) {
+            throw new sdk_core_1.BuildTransactionError('Missing parameter: source');
+        }
+        if (!this._refBlockBytes || !this._refBlockHash) {
+            throw new sdk_core_1.BuildTransactionError('Missing block reference information');
+        }
+        // Validate votes
+        if (!this._votes || this._votes.length === 0) {
+            throw new sdk_core_1.BuildTransactionError('Missing or empty votes array');
+        }
+    }
+}
+exports.VoteWitnessTxBuilder = VoteWitnessTxBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"voteWitnessTxBuilder.js","sourceRoot":"","sources":["../../../src/lib/voteWitnessTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'crypto';\nimport { TransactionType, BaseKey, BuildTransactionError, SigningError, ExtendTransactionError } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { Transaction } from './transaction';\nimport { TransactionReceipt, VoteWitnessData, VoteWitnessContract } from './iface';\nimport {\n  decodeTransaction,\n  getHexAddressFromBase58Address,\n  getByteArrayFromHexAddress,\n  getBase58AddressFromHex,\n  TRANSACTION_DEFAULT_EXPIRATION,\n  TRANSACTION_MAX_EXPIRATION,\n} from './utils';\nimport { protocol } from '../../resources/protobuf/tron';\n\nimport ContractType = protocol.Transaction.Contract.ContractType;\n\nexport class VoteWitnessTxBuilder extends TransactionBuilder {\n  protected _signingKeys: BaseKey[];\n  private _votes: VoteWitnessData[];\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._signingKeys = [];\n    this.transaction = new Transaction(_coinConfig);\n  }\n\n  /** @inheritdoc */\n  protected get transactionType(): TransactionType {\n    return TransactionType.StakingVote;\n  }\n\n  /**\n   * Set the votes to be used in the transaction\n   *\n   * @param votes vote data containing vote address and vote count\n   * @returns the builder with the new parameter set\n   */\n  setVotes(votes: VoteWitnessData[]): this {\n    this.validateVotes(votes);\n    this._votes = votes.map((vote) => ({\n      ...vote,\n      vote_address: getHexAddressFromBase58Address(vote.vote_address),\n    }));\n    return this;\n  }\n\n  /** @inheritdoc */\n  extendValidTo(extensionMs: number): void {\n    if (this.transaction.signature && this.transaction.signature.length > 0) {\n      throw new ExtendTransactionError('Cannot extend a signed transaction');\n    }\n\n    if (extensionMs <= 0) {\n      throw new Error('Value cannot be below zero');\n    }\n\n    if (extensionMs > TRANSACTION_MAX_EXPIRATION) {\n      throw new ExtendTransactionError('The expiration cannot be extended more than one year');\n    }\n\n    if (this._expiration) {\n      this._expiration = this._expiration + extensionMs;\n    } else {\n      throw new Error('There is not expiration to extend');\n    }\n  }\n\n  /**\n   * Initialize the transaction builder fields using the transaction data\n   *\n   * @param {TransactionReceipt | string} rawTransaction the transaction data in a string or JSON format\n   * @returns {VoteWitnessTxBuilder} the builder with the transaction data set\n   */\n  initBuilder(rawTransaction: TransactionReceipt | string): this {\n    this.transaction = this.fromImplementation(rawTransaction);\n    this.transaction.setTransactionType(this.transactionType);\n    this.validateRawTransaction(rawTransaction);\n    const tx = this.fromImplementation(rawTransaction);\n    this.transaction = tx;\n    this._signingKeys = [];\n    const rawData = tx.toJson().raw_data;\n    this._refBlockBytes = rawData.ref_block_bytes;\n    this._refBlockHash = rawData.ref_block_hash;\n    this._expiration = rawData.expiration;\n    this._timestamp = rawData.timestamp;\n    this.transaction.setTransactionType(TransactionType.StakingVote);\n    const contractCall = rawData.contract[0] as VoteWitnessContract;\n    this.initVoteWitnessContractCall(contractCall);\n    return this;\n  }\n\n  /**\n   * Initialize the votewitnesscontract call specific data\n   *\n   * @param {VoteWitnessContract} contractCall object with transfer data\n   */\n  protected initVoteWitnessContractCall(voteWitnessContractCall: VoteWitnessContract): void {\n    const { votes, owner_address } = voteWitnessContractCall.parameter.value;\n    if (owner_address) {\n      this.source({ address: getBase58AddressFromHex(owner_address) });\n    }\n\n    if (votes) {\n      this.setVotes(\n        votes.map((vote) => ({\n          ...vote,\n          vote_address: getBase58AddressFromHex(vote.vote_address),\n        }))\n      );\n    }\n  }\n\n  protected async buildImplementation(): Promise<Transaction> {\n    this.createVoteWitnessContractTransaction();\n    /** @inheritdoccreateTransaction */\n    // This method must be extended on child classes\n    if (this._signingKeys.length > 0) {\n      this.applySignatures();\n    }\n\n    if (!this.transaction.id) {\n      throw new BuildTransactionError('A valid transaction must have an id');\n    }\n    return Promise.resolve(this.transaction);\n  }\n\n  /**\n   * Creates the vote witness transaction\n   */\n  private createVoteWitnessContractTransaction(): void {\n    const rawDataHex = this.getVoteWitnessRawDataHex();\n    const rawData = decodeTransaction(rawDataHex);\n    const contract = rawData.contract[0] as VoteWitnessContract;\n    const contractParameter = contract.parameter;\n    contractParameter.value.owner_address = this._ownerAddress.toLocaleLowerCase();\n    contractParameter.value.votes = this._votes;\n    contractParameter.type_url = 'type.googleapis.com/protocol.VoteWitnessContract';\n    contract.type = 'VoteWitnessContract';\n    const hexBuffer = Buffer.from(rawDataHex, 'hex');\n    const id = createHash('sha256').update(hexBuffer).digest('hex');\n    const txRecip: TransactionReceipt = {\n      raw_data: rawData,\n      raw_data_hex: rawDataHex,\n      txID: id,\n      signature: this.transaction.signature,\n    };\n    this.transaction = new Transaction(this._coinConfig, txRecip);\n  }\n\n  /**\n   * Helper method to get the vote witness transaction raw data hex\n   * @returns vote witness transaction raw data hex\n   */\n  private getVoteWitnessRawDataHex(): string {\n    const voteArray = this._votes.map((vote) => {\n      const voteObject = protocol.Vote.fromObject({\n        voteAddress: getByteArrayFromHexAddress(vote.vote_address),\n        voteCount: vote.vote_count,\n      });\n\n      return protocol.Vote.create(voteObject);\n    });\n    const rawContract = {\n      ownerAddress: getByteArrayFromHexAddress(this._ownerAddress),\n      votes: voteArray,\n    };\n\n    const voteWitnessContract = protocol.VoteWitnessContract.fromObject(rawContract);\n    const voteWitnessContractBytes = protocol.VoteWitnessContract.encode(voteWitnessContract).finish();\n    const txContract = {\n      type: ContractType.VoteWitnessContract,\n      parameter: {\n        value: voteWitnessContractBytes,\n        type_url: 'type.googleapis.com/protocol.VoteWitnessContract',\n      },\n    };\n    const raw = {\n      refBlockBytes: Buffer.from(this._refBlockBytes, 'hex'),\n      refBlockHash: Buffer.from(this._refBlockHash, 'hex'),\n      expiration: this._expiration || Date.now() + TRANSACTION_DEFAULT_EXPIRATION,\n      timestamp: this._timestamp || Date.now(),\n      contract: [txContract],\n    };\n    const rawTx = protocol.Transaction.raw.create(raw);\n    return Buffer.from(protocol.Transaction.raw.encode(rawTx).finish()).toString('hex');\n  }\n\n  /** @inheritdoc */\n  protected signImplementation(key: BaseKey): Transaction {\n    if (this._signingKeys.some((signingKey) => signingKey.key === key.key)) {\n      throw new SigningError('Duplicated key');\n    }\n    this._signingKeys.push(key);\n\n    // We keep this return for compatibility but is not meant to be use\n    return this.transaction;\n  }\n\n  private applySignatures(): void {\n    if (!this.transaction.inputs) {\n      throw new SigningError('Transaction has no inputs');\n    }\n    this._signingKeys.forEach((key) => this.applySignature(key));\n  }\n\n  validateTransaction(transaction: Transaction): void {\n    this.validateVoteTransactionFields();\n  }\n\n  /**\n   * Validates the votes array\n   *\n   * @param {VoteWitnessData[]} votes - The votes array to validate\n   * @throws {Error} when the votes array is invalid\n   */\n  validateVotes(votes: VoteWitnessData[]): void {\n    if (!votes || votes.length === 0) {\n      throw new Error('Votes array is missing or empty');\n    }\n\n    votes.forEach((vote) => {\n      if (!vote.vote_address) {\n        throw new Error('Vote address is missing');\n      }\n      this.validateAddress({ address: vote.vote_address });\n\n      if (vote.vote_count == null || vote.vote_count < 0) {\n        throw new Error('Invalid vote count');\n      }\n    });\n  }\n\n  /**\n   * Validates if the transaction is a valid vote transaction\n   * @param {TransactionReceipt} transaction - The transaction to validate\n   * @throws {InvalidTransactionError} when the transaction is invalid\n   */\n  private validateVoteTransactionFields(): void {\n    if (!this._ownerAddress) {\n      throw new BuildTransactionError('Missing parameter: source');\n    }\n\n    if (!this._refBlockBytes || !this._refBlockHash) {\n      throw new BuildTransactionError('Missing block reference information');\n    }\n\n    // Validate votes\n    if (!this._votes || this._votes.length === 0) {\n      throw new BuildTransactionError('Missing or empty votes array');\n    }\n  }\n}\n"]}

package/dist/src/lib/withdrawExpireUnfreezeTxBuilder.d.ts

@@ -0,0 +1,49 @@
+import { TransactionType, BaseKey } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+import { TransactionReceipt, WithdrawExpireUnfreezeContract } from './iface';
+export declare class WithdrawExpireUnfreezeTxBuilder extends TransactionBuilder {
+    protected _signingKeys: BaseKey[];
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    protected get transactionType(): TransactionType;
+    /** @inheritdoc */
+    extendValidTo(extensionMs: number): void;
+    initBuilder(rawTransaction: TransactionReceipt | string): this;
+    /**
+     * Initialize the withdraw expire unfreeze contract call specific data
+     *
+     * @param {WithdrawExpireUnfreezeContract} withdrawExpireUnfreezeContractCall object with freeze txn data
+     */
+    protected initWithdrawExpireUnfreezeContractCall(withdrawExpireUnfreezeContractCall: WithdrawExpireUnfreezeContract): void;
+    protected buildImplementation(): Promise<Transaction>;
+    /**
+     * Helper method to create the withdraw expire unfreeze transaction
+     */
+    private createWithdrawExpireUnfreezeTransaction;
+    /**
+     * Helper method to get the withdraw expire unfreeze transaction raw data hex
+     *
+     * @returns {string} the freeze balance transaction raw data hex
+     */
+    private getWithdrawExpireUnfreezeRawDataHex;
+    /** @inheritdoc */
+    protected signImplementation(key: BaseKey): Transaction;
+    private applySignatures;
+    /**
+     * Validates the transaction
+     *
+     * @param {Transaction} transaction - The transaction to validate
+     * @throws {BuildTransactionError} when the transaction is invalid
+     */
+    validateTransaction(transaction: Transaction): void;
+    /**
+     * Validates if the transaction is a valid withdraw expire unfreeze transaction
+     *
+     * @param {TransactionReceipt} transaction - The transaction to validate
+     * @throws {BuildTransactionError} when the transaction is invalid
+     */
+    private validateWithdrawExpireUnfreezeTransactionFields;
+}
+//# sourceMappingURL=withdrawExpireUnfreezeTxBuilder.d.ts.map

package/dist/src/lib/withdrawExpireUnfreezeTxBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdrawExpireUnfreezeTxBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/withdrawExpireUnfreezeTxBuilder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,OAAO,EAA+D,MAAM,sBAAsB,CAAC;AAC7H,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,8BAA8B,EAAE,MAAM,SAAS,CAAC;AAY7E,qBAAa,+BAAgC,SAAQ,kBAAkB;IACrE,SAAS,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC;gBAEtB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAM7C,kBAAkB;IAClB,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,kBAAkB;IAClB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAoBxC,WAAW,CAAC,cAAc,EAAE,kBAAkB,GAAG,MAAM,GAAG,IAAI;IAiB9D;;;;OAIG;IACH,SAAS,CAAC,sCAAsC,CAC9C,kCAAkC,EAAE,8BAA8B,GACjE,IAAI;cAOS,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAc3D;;OAEG;IACH,OAAO,CAAC,uCAAuC;IAmB/C;;;;OAIG;IACH,OAAO,CAAC,mCAAmC;IAyB3C,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW;IAUvD,OAAO,CAAC,eAAe;IAQvB;;;;;OAKG;IACH,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAInD;;;;;OAKG;IACH,OAAO,CAAC,+CAA+C;CASxD"}

package/dist/src/lib/withdrawExpireUnfreezeTxBuilder.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithdrawExpireUnfreezeTxBuilder = void 0;
+const crypto_1 = require("crypto");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const transaction_1 = require("./transaction");
+const tron_1 = require("../../resources/protobuf/tron");
+const utils_1 = require("./utils");
+var ContractType = tron_1.protocol.Transaction.Contract.ContractType;
+class WithdrawExpireUnfreezeTxBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._signingKeys = [];
+        this.transaction = new transaction_1.Transaction(_coinConfig);
+    }
+    /** @inheritdoc */
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingWithdraw;
+    }
+    /** @inheritdoc */
+    extendValidTo(extensionMs) {
+        if (this.transaction.signature && this.transaction.signature.length > 0) {
+            throw new sdk_core_1.ExtendTransactionError('Cannot extend a signed transaction');
+        }
+        if (extensionMs <= 0) {
+            throw new Error('Value cannot be below zero');
+        }
+        if (extensionMs > utils_1.TRANSACTION_MAX_EXPIRATION) {
+            throw new sdk_core_1.ExtendTransactionError('The expiration cannot be extended more than one year');
+        }
+        if (this._expiration) {
+            this._expiration = this._expiration + extensionMs;
+        }
+        else {
+            throw new Error('There is not expiration to extend');
+        }
+    }
+    initBuilder(rawTransaction) {
+        this.transaction = this.fromImplementation(rawTransaction);
+        this.transaction.setTransactionType(this.transactionType);
+        this.validateRawTransaction(rawTransaction);
+        const tx = this.fromImplementation(rawTransaction);
+        this.transaction = tx;
+        this._signingKeys = [];
+        const rawData = tx.toJson().raw_data;
+        this._refBlockBytes = rawData.ref_block_bytes;
+        this._refBlockHash = rawData.ref_block_hash;
+        this._expiration = rawData.expiration;
+        this._timestamp = rawData.timestamp;
+        const contractCall = rawData.contract[0];
+        this.initWithdrawExpireUnfreezeContractCall(contractCall);
+        return this;
+    }
+    /**
+     * Initialize the withdraw expire unfreeze contract call specific data
+     *
+     * @param {WithdrawExpireUnfreezeContract} withdrawExpireUnfreezeContractCall object with freeze txn data
+     */
+    initWithdrawExpireUnfreezeContractCall(withdrawExpireUnfreezeContractCall) {
+        const { owner_address } = withdrawExpireUnfreezeContractCall.parameter.value;
+        if (owner_address) {
+            this.source({ address: (0, utils_1.getBase58AddressFromHex)(owner_address) });
+        }
+    }
+    async buildImplementation() {
+        this.createWithdrawExpireUnfreezeTransaction();
+        /** @inheritdoccreateTransaction */
+        // This method must be extended on child classes
+        if (this._signingKeys.length > 0) {
+            this.applySignatures();
+        }
+        if (!this.transaction.id) {
+            throw new sdk_core_1.BuildTransactionError('A valid transaction must have an id');
+        }
+        return Promise.resolve(this.transaction);
+    }
+    /**
+     * Helper method to create the withdraw expire unfreeze transaction
+     */
+    createWithdrawExpireUnfreezeTransaction() {
+        const rawDataHex = this.getWithdrawExpireUnfreezeRawDataHex();
+        const rawData = (0, utils_1.decodeTransaction)(rawDataHex);
+        const contract = rawData.contract[0];
+        const contractParameter = contract.parameter;
+        contractParameter.value.owner_address = this._ownerAddress.toLocaleLowerCase();
+        contractParameter.type_url = 'type.googleapis.com/protocol.WithdrawExpireUnfreezeContract';
+        contract.type = 'WithdrawExpireUnfreezeContract';
+        const hexBuffer = Buffer.from(rawDataHex, 'hex');
+        const id = (0, crypto_1.createHash)('sha256').update(hexBuffer).digest('hex');
+        const txRecip = {
+            raw_data: rawData,
+            raw_data_hex: rawDataHex,
+            txID: id,
+            signature: this.transaction.signature,
+        };
+        this.transaction = new transaction_1.Transaction(this._coinConfig, txRecip);
+    }
+    /**
+     * Helper method to get the withdraw expire unfreeze transaction raw data hex
+     *
+     * @returns {string} the freeze balance transaction raw data hex
+     */
+    getWithdrawExpireUnfreezeRawDataHex() {
+        const rawContract = {
+            ownerAddress: (0, utils_1.getByteArrayFromHexAddress)(this._ownerAddress),
+        };
+        const withdrawExpireUnfreezeContract = tron_1.protocol.WithdrawExpireUnfreezeContract.fromObject(rawContract);
+        const withdrawExpireUnfreezeContractBytes = tron_1.protocol.WithdrawExpireUnfreezeContract.encode(withdrawExpireUnfreezeContract).finish();
+        const txContract = {
+            type: ContractType.WithdrawExpireUnfreezeContract,
+            parameter: {
+                value: withdrawExpireUnfreezeContractBytes,
+                type_url: 'type.googleapis.com/protocol.WithdrawExpireUnfreezeContract',
+            },
+        };
+        const raw = {
+            refBlockBytes: Buffer.from(this._refBlockBytes, 'hex'),
+            refBlockHash: Buffer.from(this._refBlockHash, 'hex'),
+            expiration: this._expiration || Date.now() + utils_1.TRANSACTION_DEFAULT_EXPIRATION,
+            timestamp: this._timestamp || Date.now(),
+            contract: [txContract],
+        };
+        const rawTx = tron_1.protocol.Transaction.raw.create(raw);
+        return Buffer.from(tron_1.protocol.Transaction.raw.encode(rawTx).finish()).toString('hex');
+    }
+    /** @inheritdoc */
+    signImplementation(key) {
+        if (this._signingKeys.some((signingKey) => signingKey.key === key.key)) {
+            throw new sdk_core_1.SigningError('Duplicated key');
+        }
+        this._signingKeys.push(key);
+        // We keep this return for compatibility but is not meant to be use
+        return this.transaction;
+    }
+    applySignatures() {
+        if (!this.transaction.inputs) {
+            throw new sdk_core_1.SigningError('Transaction has no inputs');
+        }
+        this._signingKeys.forEach((key) => this.applySignature(key));
+    }
+    /**
+     * Validates the transaction
+     *
+     * @param {Transaction} transaction - The transaction to validate
+     * @throws {BuildTransactionError} when the transaction is invalid
+     */
+    validateTransaction(transaction) {
+        this.validateWithdrawExpireUnfreezeTransactionFields();
+    }
+    /**
+     * Validates if the transaction is a valid withdraw expire unfreeze transaction
+     *
+     * @param {TransactionReceipt} transaction - The transaction to validate
+     * @throws {BuildTransactionError} when the transaction is invalid
+     */
+    validateWithdrawExpireUnfreezeTransactionFields() {
+        if (!this._ownerAddress) {
+            throw new sdk_core_1.BuildTransactionError('Missing parameter: source');
+        }
+        if (!this._refBlockBytes || !this._refBlockHash) {
+            throw new sdk_core_1.BuildTransactionError('Missing block reference information');
+        }
+    }
+}
+exports.WithdrawExpireUnfreezeTxBuilder = WithdrawExpireUnfreezeTxBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"withdrawExpireUnfreezeTxBuilder.js","sourceRoot":"","sources":["../../../src/lib/withdrawExpireUnfreezeTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'crypto';\nimport { TransactionType, BaseKey, ExtendTransactionError, BuildTransactionError, SigningError } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { Transaction } from './transaction';\nimport { TransactionReceipt, WithdrawExpireUnfreezeContract } from './iface';\nimport { protocol } from '../../resources/protobuf/tron';\nimport {\n  decodeTransaction,\n  getByteArrayFromHexAddress,\n  getBase58AddressFromHex,\n  TRANSACTION_MAX_EXPIRATION,\n  TRANSACTION_DEFAULT_EXPIRATION,\n} from './utils';\n\nimport ContractType = protocol.Transaction.Contract.ContractType;\n\nexport class WithdrawExpireUnfreezeTxBuilder extends TransactionBuilder {\n  protected _signingKeys: BaseKey[];\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._signingKeys = [];\n    this.transaction = new Transaction(_coinConfig);\n  }\n\n  /** @inheritdoc */\n  protected get transactionType(): TransactionType {\n    return TransactionType.StakingWithdraw;\n  }\n\n  /** @inheritdoc */\n  extendValidTo(extensionMs: number): void {\n    if (this.transaction.signature && this.transaction.signature.length > 0) {\n      throw new ExtendTransactionError('Cannot extend a signed transaction');\n    }\n\n    if (extensionMs <= 0) {\n      throw new Error('Value cannot be below zero');\n    }\n\n    if (extensionMs > TRANSACTION_MAX_EXPIRATION) {\n      throw new ExtendTransactionError('The expiration cannot be extended more than one year');\n    }\n\n    if (this._expiration) {\n      this._expiration = this._expiration + extensionMs;\n    } else {\n      throw new Error('There is not expiration to extend');\n    }\n  }\n\n  initBuilder(rawTransaction: TransactionReceipt | string): this {\n    this.transaction = this.fromImplementation(rawTransaction);\n    this.transaction.setTransactionType(this.transactionType);\n    this.validateRawTransaction(rawTransaction);\n    const tx = this.fromImplementation(rawTransaction);\n    this.transaction = tx;\n    this._signingKeys = [];\n    const rawData = tx.toJson().raw_data;\n    this._refBlockBytes = rawData.ref_block_bytes;\n    this._refBlockHash = rawData.ref_block_hash;\n    this._expiration = rawData.expiration;\n    this._timestamp = rawData.timestamp;\n    const contractCall = rawData.contract[0] as WithdrawExpireUnfreezeContract;\n    this.initWithdrawExpireUnfreezeContractCall(contractCall);\n    return this;\n  }\n\n  /**\n   * Initialize the withdraw expire unfreeze contract call specific data\n   *\n   * @param {WithdrawExpireUnfreezeContract} withdrawExpireUnfreezeContractCall object with freeze txn data\n   */\n  protected initWithdrawExpireUnfreezeContractCall(\n    withdrawExpireUnfreezeContractCall: WithdrawExpireUnfreezeContract\n  ): void {\n    const { owner_address } = withdrawExpireUnfreezeContractCall.parameter.value;\n    if (owner_address) {\n      this.source({ address: getBase58AddressFromHex(owner_address) });\n    }\n  }\n\n  protected async buildImplementation(): Promise<Transaction> {\n    this.createWithdrawExpireUnfreezeTransaction();\n    /** @inheritdoccreateTransaction */\n    // This method must be extended on child classes\n    if (this._signingKeys.length > 0) {\n      this.applySignatures();\n    }\n\n    if (!this.transaction.id) {\n      throw new BuildTransactionError('A valid transaction must have an id');\n    }\n    return Promise.resolve(this.transaction);\n  }\n\n  /**\n   * Helper method to create the withdraw expire unfreeze transaction\n   */\n  private createWithdrawExpireUnfreezeTransaction(): void {\n    const rawDataHex = this.getWithdrawExpireUnfreezeRawDataHex();\n    const rawData = decodeTransaction(rawDataHex);\n    const contract = rawData.contract[0] as WithdrawExpireUnfreezeContract;\n    const contractParameter = contract.parameter;\n    contractParameter.value.owner_address = this._ownerAddress.toLocaleLowerCase();\n    contractParameter.type_url = 'type.googleapis.com/protocol.WithdrawExpireUnfreezeContract';\n    contract.type = 'WithdrawExpireUnfreezeContract';\n    const hexBuffer = Buffer.from(rawDataHex, 'hex');\n    const id = createHash('sha256').update(hexBuffer).digest('hex');\n    const txRecip: TransactionReceipt = {\n      raw_data: rawData,\n      raw_data_hex: rawDataHex,\n      txID: id,\n      signature: this.transaction.signature,\n    };\n    this.transaction = new Transaction(this._coinConfig, txRecip);\n  }\n\n  /**\n   * Helper method to get the withdraw expire unfreeze transaction raw data hex\n   *\n   * @returns {string} the freeze balance transaction raw data hex\n   */\n  private getWithdrawExpireUnfreezeRawDataHex(): string {\n    const rawContract = {\n      ownerAddress: getByteArrayFromHexAddress(this._ownerAddress),\n    };\n    const withdrawExpireUnfreezeContract = protocol.WithdrawExpireUnfreezeContract.fromObject(rawContract);\n    const withdrawExpireUnfreezeContractBytes =\n      protocol.WithdrawExpireUnfreezeContract.encode(withdrawExpireUnfreezeContract).finish();\n    const txContract = {\n      type: ContractType.WithdrawExpireUnfreezeContract,\n      parameter: {\n        value: withdrawExpireUnfreezeContractBytes,\n        type_url: 'type.googleapis.com/protocol.WithdrawExpireUnfreezeContract',\n      },\n    };\n    const raw = {\n      refBlockBytes: Buffer.from(this._refBlockBytes, 'hex'),\n      refBlockHash: Buffer.from(this._refBlockHash, 'hex'),\n      expiration: this._expiration || Date.now() + TRANSACTION_DEFAULT_EXPIRATION,\n      timestamp: this._timestamp || Date.now(),\n      contract: [txContract],\n    };\n    const rawTx = protocol.Transaction.raw.create(raw);\n    return Buffer.from(protocol.Transaction.raw.encode(rawTx).finish()).toString('hex');\n  }\n\n  /** @inheritdoc */\n  protected signImplementation(key: BaseKey): Transaction {\n    if (this._signingKeys.some((signingKey) => signingKey.key === key.key)) {\n      throw new SigningError('Duplicated key');\n    }\n    this._signingKeys.push(key);\n\n    // We keep this return for compatibility but is not meant to be use\n    return this.transaction;\n  }\n\n  private applySignatures(): void {\n    if (!this.transaction.inputs) {\n      throw new SigningError('Transaction has no inputs');\n    }\n\n    this._signingKeys.forEach((key) => this.applySignature(key));\n  }\n\n  /**\n   * Validates the transaction\n   *\n   * @param {Transaction} transaction - The transaction to validate\n   * @throws {BuildTransactionError} when the transaction is invalid\n   */\n  validateTransaction(transaction: Transaction): void {\n    this.validateWithdrawExpireUnfreezeTransactionFields();\n  }\n\n  /**\n   * Validates if the transaction is a valid withdraw expire unfreeze transaction\n   *\n   * @param {TransactionReceipt} transaction - The transaction to validate\n   * @throws {BuildTransactionError} when the transaction is invalid\n   */\n  private validateWithdrawExpireUnfreezeTransactionFields(): void {\n    if (!this._ownerAddress) {\n      throw new BuildTransactionError('Missing parameter: source');\n    }\n\n    if (!this._refBlockBytes || !this._refBlockHash) {\n      throw new BuildTransactionError('Missing block reference information');\n    }\n  }\n}\n"]}

package/dist/src/lib/wrappedBuilder.d.ts

@@ -7,6 +7,10 @@ import { TransactionBuilder } from './transactionBuilder';
 import { ContractCallBuilder } from './contractCallBuilder';
 import { TransactionReceipt } from './iface';
 import { TokenTransferBuilder } from './tokenTransferBuilder';
+import { FreezeBalanceTxBuilder } from './freezeBalanceTxBuilder';
+import { VoteWitnessTxBuilder } from './voteWitnessTxBuilder';
+import { UnfreezeBalanceTxBuilder } from './unfreezeBalanceTxBuilder';
+import { WithdrawExpireUnfreezeTxBuilder } from './withdrawExpireUnfreezeTxBuilder';
 /**
  * Wrapped Builder class
  * This builder is created to maintain compatibility with the current uses of account-lib
@@ -24,6 +28,34 @@ export declare class WrappedBuilder extends TransactionBuilder {
     getContractCallBuilder(tx?: TransactionReceipt | string): ContractCallBuilder;
     getTransactionBuilder(tx?: TransactionReceipt | string): TransactionBuilder;
     getTokenTransferBuilder(tx?: TransactionReceipt | string): TokenTransferBuilder;
+    /**
+     * Returns a specific builder to create a freeze balance transaction
+     *
+     * @param {TransactionReceipt} transaction - The transaction to initialize builder
+     * @returns {FreezeBalanceTxBuilder} The specific freeze balance builder
+     */
+    getFreezeBalanceV2TxBuilder(tx?: TransactionReceipt | string): FreezeBalanceTxBuilder;
+    /**
+     * Returns a specific builder to create a vote witness transaction
+     *
+     * @param {TransactionReceipt} transaction - The transaction to initialize builder
+     * @returns {VoteWitnessTxBuilder} The specific vote witness builder
+     */
+    getVoteWitnessTxBuilder(tx?: TransactionReceipt | string): VoteWitnessTxBuilder;
+    /**
+     * Returns a specific builder to create an unfreeze balance transaction
+     *
+     * @param {Transaction} [tx] The transaction to initialize builder
+     * @returns {UnfreezeBalanceTxBuilder} The specific unfreeze builder
+     */
+    getUnfreezeBalanceV2TxBuilder(tx?: TransactionReceipt | string): UnfreezeBalanceTxBuilder;
+    /**
+     * Returns a specific builder to create a withdraw expire unfreeze transaction
+     *
+     * @param {Transaction} [tx] The transaction to initialize builder
+     * @returns {WithdrawExpireUnfreezeTxBuilder} The specific withdraw builder
+     */
+    getWithdrawExpireUnfreezeTxBuilder(tx?: TransactionReceipt | string): WithdrawExpireUnfreezeTxBuilder;
     private initializeBuilder;
     /** @inheritdoc */
     extendValidTo(extensionMs: number): void;

package/dist/src/lib/wrappedBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrappedBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/wrappedBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,eAAe,EAA2B,MAAM,sBAAsB,CAAC;AACzF,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAI1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,kBAAkB;IACpD,OAAO,CAAC,QAAQ,CAAqB;gBAEzB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAM7C;;;;;OAKG;IACH,sBAAsB,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAAG,mBAAmB;IAI7E,qBAAqB,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAAG,kBAAkB;IAI3E,uBAAuB,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAAG,oBAAoB;IAI/E,OAAO,CAAC,iBAAiB;IAOzB,kBAAkB;IAClB,aAAa,CAAC,WAAW,EAAE,MAAM;IAIjC,kBAAkB;IAClB,IAAI,CAAC,GAAG,EAAE,OAAO;IAIjB,kBAAkB;IACZ,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAIvC,kBAAkB;IAClB,IAAI,CAAC,GAAG,EAAE,GAAG;IAiBb;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB,kBAAkB;IAClB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIvC,kBAAkB;IAClB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAO/B,kBAAkB;IAClB,sBAAsB,CAAC,cAAc,EAAE,GAAG,GAAG,IAAI;IAIjD,kBAAkB;IAClB,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAInD,kBAAkB;IAClB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;CAGtC"}
+{"version":3,"file":"wrappedBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/wrappedBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,eAAe,EAA2B,MAAM,sBAAsB,CAAC;AACzF,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAI1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AAEpF;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,kBAAkB;IACpD,OAAO,CAAC,QAAQ,CAAqB;gBAEzB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAM7C;;;;;OAKG;IACH,sBAAsB,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAAG,mBAAmB;IAI7E,qBAAqB,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAAG,kBAAkB;IAI3E,uBAAuB,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAAG,oBAAoB;IAI/E;;;;;OAKG;IACH,2BAA2B,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAAG,sBAAsB;IAIrF;;;;;OAKG;IACH,uBAAuB,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAAG,oBAAoB;IAI/E;;;;;OAKG;IACH,6BAA6B,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAAG,wBAAwB;IAIzF;;;;;OAKG;IACH,kCAAkC,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAAG,+BAA+B;IAIrG,OAAO,CAAC,iBAAiB;IAOzB,kBAAkB;IAClB,aAAa,CAAC,WAAW,EAAE,MAAM;IAIjC,kBAAkB;IAClB,IAAI,CAAC,GAAG,EAAE,OAAO;IAIjB,kBAAkB;IACZ,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAIvC,kBAAkB;IAClB,IAAI,CAAC,GAAG,EAAE,GAAG;IAyBb;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB,kBAAkB;IAClB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIvC,kBAAkB;IAClB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAO/B,kBAAkB;IAClB,sBAAsB,CAAC,cAAc,EAAE,GAAG,GAAG,IAAI;IAIjD,kBAAkB;IAClB,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAInD,kBAAkB;IAClB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;CAGtC"}