@bitgo-beta/sdk-coin-trx 1.2.3-alpha.401 → 1.2.3-alpha.403

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

@@ -0,0 +1,110 @@
+import BigNumber from 'bignumber.js';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { BaseKey, BaseTransaction } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { Address } from './address';
+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';
+import { WithdrawBalanceTxBuilder } from './withdrawBuilder';
+import { DelegateResourceTxBuilder } from './delegateResourceTxBuilder';
+import { UndelegateResourceTxBuilder } from './undelegateResourceTxBuilder';
+/**
+ * Wrapped Builder class
+ * This builder is created to maintain compatibility with the current uses of account-lib
+ * It has an instance of Transaction Builder or Contract Call Builder as required.
+ */
+export declare class WrappedBuilder extends TransactionBuilder {
+    private _builder;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Returns a specific builder to create a contract call transaction
+     *
+     * @param {Transaction} [tx] The transaction to initialize builder
+     * @returns {ContractCallBuilder} The specific contract call builder
+     */
+    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;
+    /**
+     * Returns a specific builder to create a withdraw balance transaction
+     *
+     * @param {Transaction} [tx] The transaction to initialize builder
+     * @returns {WithdrawBalanceTxBuilder} The specific withdraw balance builder
+     */
+    getWithdrawBalanceTxBuilder(tx?: TransactionReceipt | string): WithdrawBalanceTxBuilder;
+    /**
+     * Returns a specific builder to create a delegate resource transaction
+     *
+     * @param {TransactionReceipt | string} [tx] The transaction to initialize builder
+     * @returns {DelegateResourceTxBuilder} The specific delegate resource builder
+     */
+    getDelegateResourceTxBuilder(tx?: TransactionReceipt | string): DelegateResourceTxBuilder;
+    /**
+     * Returns a specific builder to create a undelegate resource transaction
+     *
+     * @param {TransactionReceipt | string} [tx] The transaction to initialize builder
+     * @returns {UndelegateResourceTxBuilder} The specific delegate resource builder
+     */
+    getUnDelegateResourceTxBuilder(tx?: TransactionReceipt | string): UndelegateResourceTxBuilder;
+    private initializeBuilder;
+    /** @inheritdoc */
+    extendValidTo(extensionMs: number): void;
+    /** @inheritdoc */
+    sign(key: BaseKey): void;
+    /** @inheritdoc */
+    build(): Promise<BaseTransaction>;
+    /** @inheritdoc */
+    from(raw: any): TransactionBuilder;
+    /**
+     * Get the raw data hex from a raw transaction
+     *
+     * @param {string | { [key: string]: any }} raw the raw transaction as a string or as an object
+     * @returns {string} the raw data hex
+     */
+    private getTxReceipt;
+    /** @inheritdoc */
+    validateAddress(address: Address): void;
+    /** @inheritdoc */
+    validateKey(key: BaseKey): void;
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction: any): void;
+    /** @inheritdoc */
+    validateTransaction(transaction: Transaction): void;
+    /** @inheritdoc */
+    validateValue(value: BigNumber): void;
+}
+//# sourceMappingURL=wrappedBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wrappedBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/wrappedBuilder.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/wrappedBuilder.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrappedBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const keyPair_1 = require("./keyPair");
+const utils_1 = require("./utils");
+const enum_1 = require("./enum");
+const contractCallBuilder_1 = require("./contractCallBuilder");
+const tokenTransferBuilder_1 = require("./tokenTransferBuilder");
+const freezeBalanceTxBuilder_1 = require("./freezeBalanceTxBuilder");
+const voteWitnessTxBuilder_1 = require("./voteWitnessTxBuilder");
+const unfreezeBalanceTxBuilder_1 = require("./unfreezeBalanceTxBuilder");
+const withdrawExpireUnfreezeTxBuilder_1 = require("./withdrawExpireUnfreezeTxBuilder");
+const withdrawBuilder_1 = require("./withdrawBuilder");
+const delegateResourceTxBuilder_1 = require("./delegateResourceTxBuilder");
+const undelegateResourceTxBuilder_1 = require("./undelegateResourceTxBuilder");
+/**
+ * Wrapped Builder class
+ * This builder is created to maintain compatibility with the current uses of account-lib
+ * It has an instance of Transaction Builder or Contract Call Builder as required.
+ */
+class WrappedBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        // defaults to old builder
+        this._builder = new transactionBuilder_1.TransactionBuilder(_coinConfig);
+    }
+    /**
+     * Returns a specific builder to create a contract call transaction
+     *
+     * @param {Transaction} [tx] The transaction to initialize builder
+     * @returns {ContractCallBuilder} The specific contract call builder
+     */
+    getContractCallBuilder(tx) {
+        return this.initializeBuilder(tx, new contractCallBuilder_1.ContractCallBuilder(this._coinConfig));
+    }
+    getTransactionBuilder(tx) {
+        return this.initializeBuilder(tx, new transactionBuilder_1.TransactionBuilder(this._coinConfig));
+    }
+    getTokenTransferBuilder(tx) {
+        return this.initializeBuilder(tx, new tokenTransferBuilder_1.TokenTransferBuilder(this._coinConfig));
+    }
+    /**
+     * 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) {
+        return this.initializeBuilder(tx, new freezeBalanceTxBuilder_1.FreezeBalanceTxBuilder(this._coinConfig));
+    }
+    /**
+     * 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) {
+        return this.initializeBuilder(tx, new voteWitnessTxBuilder_1.VoteWitnessTxBuilder(this._coinConfig));
+    }
+    /**
+     * 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) {
+        return this.initializeBuilder(tx, new unfreezeBalanceTxBuilder_1.UnfreezeBalanceTxBuilder(this._coinConfig));
+    }
+    /**
+     * 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) {
+        return this.initializeBuilder(tx, new withdrawExpireUnfreezeTxBuilder_1.WithdrawExpireUnfreezeTxBuilder(this._coinConfig));
+    }
+    /**
+     * Returns a specific builder to create a withdraw balance transaction
+     *
+     * @param {Transaction} [tx] The transaction to initialize builder
+     * @returns {WithdrawBalanceTxBuilder} The specific withdraw balance builder
+     */
+    getWithdrawBalanceTxBuilder(tx) {
+        return this.initializeBuilder(tx, new withdrawBuilder_1.WithdrawBalanceTxBuilder(this._coinConfig));
+    }
+    /**
+     * Returns a specific builder to create a delegate resource transaction
+     *
+     * @param {TransactionReceipt | string} [tx] The transaction to initialize builder
+     * @returns {DelegateResourceTxBuilder} The specific delegate resource builder
+     */
+    getDelegateResourceTxBuilder(tx) {
+        return this.initializeBuilder(tx, new delegateResourceTxBuilder_1.DelegateResourceTxBuilder(this._coinConfig));
+    }
+    /**
+     * Returns a specific builder to create a undelegate resource transaction
+     *
+     * @param {TransactionReceipt | string} [tx] The transaction to initialize builder
+     * @returns {UndelegateResourceTxBuilder} The specific delegate resource builder
+     */
+    getUnDelegateResourceTxBuilder(tx) {
+        return this.initializeBuilder(tx, new undelegateResourceTxBuilder_1.UndelegateResourceTxBuilder(this._coinConfig));
+    }
+    initializeBuilder(tx, builder) {
+        if (tx) {
+            builder.initBuilder(tx);
+        }
+        return builder;
+    }
+    /** @inheritdoc */
+    extendValidTo(extensionMs) {
+        this._builder.extendValidTo(extensionMs);
+    }
+    /** @inheritdoc */
+    sign(key) {
+        this._builder.sign(key);
+    }
+    /** @inheritdoc */
+    async build() {
+        return this._builder.build();
+    }
+    /** @inheritdoc */
+    from(raw) {
+        this.validateRawTransaction(raw);
+        const rawDataHex = this.getTxReceipt(raw);
+        const decodedTx = (0, utils_1.decodeTransaction)(rawDataHex);
+        const contractType = decodedTx.contractType;
+        switch (contractType) {
+            case enum_1.ContractType.Transfer:
+            case enum_1.ContractType.AccountPermissionUpdate:
+                this._builder = this.getTransactionBuilder(raw);
+                return this._builder;
+            case enum_1.ContractType.TriggerSmartContract:
+                return this.getContractCallBuilder(raw);
+            case enum_1.ContractType.FreezeBalanceV2:
+                return this.getFreezeBalanceV2TxBuilder(raw);
+            case enum_1.ContractType.VoteWitness:
+                return this.getVoteWitnessTxBuilder(raw);
+            case enum_1.ContractType.UnfreezeBalanceV2:
+                return this.getUnfreezeBalanceV2TxBuilder(raw);
+            case enum_1.ContractType.WithdrawExpireUnfreeze:
+                return this.getWithdrawExpireUnfreezeTxBuilder(raw);
+            case enum_1.ContractType.WithdrawBalance:
+                return this.getWithdrawBalanceTxBuilder(raw);
+            case enum_1.ContractType.DelegateResourceContract:
+                return this.getDelegateResourceTxBuilder(raw);
+            case enum_1.ContractType.UnDelegateResourceContract:
+                return this.getUnDelegateResourceTxBuilder(raw);
+            default:
+                throw new sdk_core_1.InvalidTransactionError('Invalid transaction type: ' + contractType);
+        }
+    }
+    /**
+     * Get the raw data hex from a raw transaction
+     *
+     * @param {string | { [key: string]: any }} raw the raw transaction as a string or as an object
+     * @returns {string} the raw data hex
+     */
+    getTxReceipt(raw) {
+        return raw['raw_data_hex'] || this.getTxReceipt(JSON.parse(raw));
+    }
+    /** @inheritdoc */
+    validateAddress(address) {
+        this._builder.validateAddress(address);
+    }
+    /** @inheritdoc */
+    validateKey(key) {
+        try {
+            new keyPair_1.KeyPair({ prv: key.key });
+        }
+        catch (err) {
+            throw new Error('The provided key is not valid');
+        }
+    }
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction) {
+        this._builder.validateRawTransaction(rawTransaction);
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        this._builder.validateTransaction(transaction);
+    }
+    /** @inheritdoc */
+    validateValue(value) {
+        this._builder.validateValue(value);
+    }
+}
+exports.WrappedBuilder = WrappedBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wrappedBuilder.js","sourceRoot":"","sources":["../../../src/lib/wrappedBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import BigNumber from 'bignumber.js';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { BaseKey, BaseTransaction, InvalidTransactionError } from '@bitgo-beta/sdk-core';\nimport { Transaction } from './transaction';\nimport { Address } from './address';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { KeyPair } from './keyPair';\nimport { decodeTransaction } from './utils';\nimport { ContractType } from './enum';\nimport { ContractCallBuilder } from './contractCallBuilder';\nimport { TransactionReceipt } from './iface';\nimport { TokenTransferBuilder } from './tokenTransferBuilder';\nimport { FreezeBalanceTxBuilder } from './freezeBalanceTxBuilder';\nimport { VoteWitnessTxBuilder } from './voteWitnessTxBuilder';\nimport { UnfreezeBalanceTxBuilder } from './unfreezeBalanceTxBuilder';\nimport { WithdrawExpireUnfreezeTxBuilder } from './withdrawExpireUnfreezeTxBuilder';\nimport { WithdrawBalanceTxBuilder } from './withdrawBuilder';\nimport { DelegateResourceTxBuilder } from './delegateResourceTxBuilder';\nimport { UndelegateResourceTxBuilder } from './undelegateResourceTxBuilder';\n\n/**\n * Wrapped Builder class\n * This builder is created to maintain compatibility with the current uses of account-lib\n * It has an instance of Transaction Builder or Contract Call Builder as required.\n */\nexport class WrappedBuilder extends TransactionBuilder {\n  private _builder: TransactionBuilder;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    // defaults to old builder\n    this._builder = new TransactionBuilder(_coinConfig);\n  }\n\n  /**\n   * Returns a specific builder to create a contract call transaction\n   *\n   * @param {Transaction} [tx] The transaction to initialize builder\n   * @returns {ContractCallBuilder} The specific contract call builder\n   */\n  getContractCallBuilder(tx?: TransactionReceipt | string): ContractCallBuilder {\n    return this.initializeBuilder(tx, new ContractCallBuilder(this._coinConfig));\n  }\n\n  getTransactionBuilder(tx?: TransactionReceipt | string): TransactionBuilder {\n    return this.initializeBuilder(tx, new TransactionBuilder(this._coinConfig));\n  }\n\n  getTokenTransferBuilder(tx?: TransactionReceipt | string): TokenTransferBuilder {\n    return this.initializeBuilder(tx, new TokenTransferBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns a specific builder to create a freeze balance transaction\n   *\n   * @param {TransactionReceipt} transaction - The transaction to initialize builder\n   * @returns {FreezeBalanceTxBuilder} The specific freeze balance builder\n   */\n  getFreezeBalanceV2TxBuilder(tx?: TransactionReceipt | string): FreezeBalanceTxBuilder {\n    return this.initializeBuilder(tx, new FreezeBalanceTxBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns a specific builder to create a vote witness transaction\n   *\n   * @param {TransactionReceipt} transaction - The transaction to initialize builder\n   * @returns {VoteWitnessTxBuilder} The specific vote witness builder\n   */\n  getVoteWitnessTxBuilder(tx?: TransactionReceipt | string): VoteWitnessTxBuilder {\n    return this.initializeBuilder(tx, new VoteWitnessTxBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns a specific builder to create an unfreeze balance transaction\n   *\n   * @param {Transaction} [tx] The transaction to initialize builder\n   * @returns {UnfreezeBalanceTxBuilder} The specific unfreeze builder\n   */\n  getUnfreezeBalanceV2TxBuilder(tx?: TransactionReceipt | string): UnfreezeBalanceTxBuilder {\n    return this.initializeBuilder(tx, new UnfreezeBalanceTxBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns a specific builder to create a withdraw expire unfreeze transaction\n   *\n   * @param {Transaction} [tx] The transaction to initialize builder\n   * @returns {WithdrawExpireUnfreezeTxBuilder} The specific withdraw builder\n   */\n  getWithdrawExpireUnfreezeTxBuilder(tx?: TransactionReceipt | string): WithdrawExpireUnfreezeTxBuilder {\n    return this.initializeBuilder(tx, new WithdrawExpireUnfreezeTxBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns a specific builder to create a withdraw balance transaction\n   *\n   * @param {Transaction} [tx] The transaction to initialize builder\n   * @returns {WithdrawBalanceTxBuilder} The specific withdraw balance builder\n   */\n  getWithdrawBalanceTxBuilder(tx?: TransactionReceipt | string): WithdrawBalanceTxBuilder {\n    return this.initializeBuilder(tx, new WithdrawBalanceTxBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns a specific builder to create a delegate resource transaction\n   *\n   * @param {TransactionReceipt | string} [tx] The transaction to initialize builder\n   * @returns {DelegateResourceTxBuilder} The specific delegate resource builder\n   */\n  getDelegateResourceTxBuilder(tx?: TransactionReceipt | string): DelegateResourceTxBuilder {\n    return this.initializeBuilder(tx, new DelegateResourceTxBuilder(this._coinConfig));\n  }\n\n  /**\n   * Returns a specific builder to create a undelegate resource transaction\n   *\n   * @param {TransactionReceipt | string} [tx] The transaction to initialize builder\n   * @returns {UndelegateResourceTxBuilder} The specific delegate resource builder\n   */\n  getUnDelegateResourceTxBuilder(tx?: TransactionReceipt | string): UndelegateResourceTxBuilder {\n    return this.initializeBuilder(tx, new UndelegateResourceTxBuilder(this._coinConfig));\n  }\n\n  private initializeBuilder<T extends TransactionBuilder>(tx: TransactionReceipt | string | undefined, builder: T): T {\n    if (tx) {\n      builder.initBuilder(tx);\n    }\n    return builder;\n  }\n\n  /** @inheritdoc */\n  extendValidTo(extensionMs: number) {\n    this._builder.extendValidTo(extensionMs);\n  }\n\n  /** @inheritdoc */\n  sign(key: BaseKey) {\n    this._builder.sign(key);\n  }\n\n  /** @inheritdoc */\n  async build(): Promise<BaseTransaction> {\n    return this._builder.build();\n  }\n\n  /** @inheritdoc */\n  from(raw: any) {\n    this.validateRawTransaction(raw);\n    const rawDataHex = this.getTxReceipt(raw);\n    const decodedTx = decodeTransaction(rawDataHex);\n    const contractType = decodedTx.contractType;\n    switch (contractType) {\n      case ContractType.Transfer:\n      case ContractType.AccountPermissionUpdate:\n        this._builder = this.getTransactionBuilder(raw);\n        return this._builder;\n      case ContractType.TriggerSmartContract:\n        return this.getContractCallBuilder(raw);\n      case ContractType.FreezeBalanceV2:\n        return this.getFreezeBalanceV2TxBuilder(raw);\n      case ContractType.VoteWitness:\n        return this.getVoteWitnessTxBuilder(raw);\n      case ContractType.UnfreezeBalanceV2:\n        return this.getUnfreezeBalanceV2TxBuilder(raw);\n      case ContractType.WithdrawExpireUnfreeze:\n        return this.getWithdrawExpireUnfreezeTxBuilder(raw);\n      case ContractType.WithdrawBalance:\n        return this.getWithdrawBalanceTxBuilder(raw);\n      case ContractType.DelegateResourceContract:\n        return this.getDelegateResourceTxBuilder(raw);\n      case ContractType.UnDelegateResourceContract:\n        return this.getUnDelegateResourceTxBuilder(raw);\n      default:\n        throw new InvalidTransactionError('Invalid transaction type: ' + contractType);\n    }\n  }\n\n  /**\n   * Get the raw data hex from a raw transaction\n   *\n   * @param {string | { [key: string]: any }} raw the raw transaction as a string or as an object\n   * @returns {string} the raw data hex\n   */\n  private getTxReceipt(raw: string | { [key: string]: any }): string {\n    return raw['raw_data_hex'] || this.getTxReceipt(JSON.parse(raw as string));\n  }\n\n  /** @inheritdoc */\n  validateAddress(address: Address): void {\n    this._builder.validateAddress(address);\n  }\n\n  /** @inheritdoc */\n  validateKey(key: BaseKey): void {\n    try {\n      new KeyPair({ prv: key.key });\n    } catch (err) {\n      throw new Error('The provided key is not valid');\n    }\n  }\n  /** @inheritdoc */\n  validateRawTransaction(rawTransaction: any): void {\n    this._builder.validateRawTransaction(rawTransaction);\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction: Transaction): void {\n    this._builder.validateTransaction(transaction);\n  }\n\n  /** @inheritdoc */\n  validateValue(value: BigNumber): void {\n    this._builder.validateValue(value);\n  }\n}\n"]}

package/dist/src/register.d.ts

@@ -0,0 +1,3 @@
+import { BitGoBase } from '@bitgo-beta/sdk-core';
+export declare const register: (sdk: BitGoBase) => void;
+//# sourceMappingURL=register.d.ts.map

package/dist/src/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../src/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAKjD,eAAO,MAAM,QAAQ,QAAS,SAAS,KAAG,IAMzC,CAAC"}

package/dist/src/register.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const trx_1 = require("./trx");
+const trxToken_1 = require("./trxToken");
+const ttrx_1 = require("./ttrx");
+const register = (sdk) => {
+    sdk.register('trx', trx_1.Trx.createInstance);
+    sdk.register('ttrx', ttrx_1.Ttrx.createInstance);
+    trxToken_1.TrxToken.createTokenConstructors().forEach(({ name, coinConstructor }) => {
+        sdk.register(name, coinConstructor);
+    });
+};
+exports.register = register;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsK0JBQTRCO0FBQzVCLHlDQUFzQztBQUN0QyxpQ0FBOEI7QUFFdkIsTUFBTSxRQUFRLEdBQUcsQ0FBQyxHQUFjLEVBQVEsRUFBRTtJQUMvQyxHQUFHLENBQUMsUUFBUSxDQUFDLEtBQUssRUFBRSxTQUFHLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDeEMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsV0FBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQzFDLG1CQUFRLENBQUMsdUJBQXVCLEVBQUUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxlQUFlLEVBQUUsRUFBRSxFQUFFO1FBQ3ZFLEdBQUcsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLGVBQWUsQ0FBQyxDQUFDO0lBQ3RDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDO0FBTlcsUUFBQSxRQUFRLFlBTW5CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQml0R29CYXNlIH0gZnJvbSAnQGJpdGdvLWJldGEvc2RrLWNvcmUnO1xuaW1wb3J0IHsgVHJ4IH0gZnJvbSAnLi90cngnO1xuaW1wb3J0IHsgVHJ4VG9rZW4gfSBmcm9tICcuL3RyeFRva2VuJztcbmltcG9ydCB7IFR0cnggfSBmcm9tICcuL3R0cngnO1xuXG5leHBvcnQgY29uc3QgcmVnaXN0ZXIgPSAoc2RrOiBCaXRHb0Jhc2UpOiB2b2lkID0+IHtcbiAgc2RrLnJlZ2lzdGVyKCd0cngnLCBUcnguY3JlYXRlSW5zdGFuY2UpO1xuICBzZGsucmVnaXN0ZXIoJ3R0cngnLCBUdHJ4LmNyZWF0ZUluc3RhbmNlKTtcbiAgVHJ4VG9rZW4uY3JlYXRlVG9rZW5Db25zdHJ1Y3RvcnMoKS5mb3JFYWNoKCh7IG5hbWUsIGNvaW5Db25zdHJ1Y3RvciB9KSA9PiB7XG4gICAgc2RrLnJlZ2lzdGVyKG5hbWUsIGNvaW5Db25zdHJ1Y3Rvcik7XG4gIH0pO1xufTtcbiJdfQ==