@bitgo/account-lib 2.20.1 → 2.21.0-hotfix.1

package/dist/src/coin/hbar/transactionBuilder.js

@@ -0,0 +1,270 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilder = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const Long = __importStar(require("long"));
+const proto = __importStar(require("@hashgraph/proto"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+const transaction_1 = require("./transaction");
+const utils_1 = require("./utils");
+const keyPair_1 = require("./keyPair");
+class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._node = { nodeId: '0.0.4' };
+        this._duration = new proto.Duration({ seconds: Long.fromNumber(120) });
+        this._txBody = new proto.TransactionBody();
+        this._txBody.transactionValidDuration = this._duration;
+        this._multiSignerKeyPairs = [];
+        this._signatures = [];
+        this.transaction = new transaction_1.Transaction(_coinConfig);
+    }
+    // region Base Builder
+    /** @inheritdoc */
+    async buildImplementation() {
+        this._txBody.nodeAccountID = utils_1.buildHederaAccountID(this._node.nodeId);
+        this._txBody.transactionFee = Long.fromString(this._fee.fee);
+        this._txBody.transactionID = this.buildTxId();
+        this._txBody.memo = this._memo;
+        const hTransaction = this.transaction.hederaTx || new proto.Transaction();
+        hTransaction.bodyBytes = proto.TransactionBody.encode(this._txBody).finish();
+        this.transaction.body(hTransaction);
+        for (const kp of this._multiSignerKeyPairs) {
+            await this.transaction.sign(kp);
+        }
+        for (const { signature, keyPair } of this._signatures) {
+            this.transaction.addSignature(signature, keyPair);
+        }
+        return this.transaction;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = new transaction_1.Transaction(this._coinConfig);
+        this.validateRawTransaction(rawTransaction);
+        tx.fromRawTransaction(rawTransaction);
+        this.initBuilder(tx);
+        return this.transaction;
+    }
+    /** @inheritdoc */
+    signImplementation(key) {
+        this.checkDuplicatedKeys(key);
+        const signer = new keyPair_1.KeyPair({ prv: key.key });
+        // Signing the transaction is an operation that relies on all the data being set,
+        // so we set the source here and leave the actual signing for the build step
+        this._multiSignerKeyPairs.push(signer);
+        return this.transaction;
+    }
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx - the transaction data
+     */
+    initBuilder(tx) {
+        this.transaction = tx;
+        this.transaction.loadPreviousSignatures();
+        const txData = tx.toJson();
+        this.fee({ fee: txData.fee.toString() });
+        this.source({ address: txData.from });
+        this.startTime(txData.startTime);
+        this.node({ nodeId: txData.node });
+        this.validDuration(new bignumber_js_1.default(txData.validDuration).toNumber());
+        if (txData.memo) {
+            this.memo(txData.memo);
+        }
+    }
+    /**
+     * Creates a Hedera TransactionID
+     *
+     * @returns {proto.TransactionID} - Created TransactionID
+     */
+    buildTxId() {
+        return new proto.TransactionID({
+            transactionValidStart: this.validStart,
+            accountID: utils_1.buildHederaAccountID(this._source.address),
+        });
+    }
+    // endregion
+    // region Common builder methods
+    /**
+     *  Set the memo
+     *
+     * @param {string} memo - A hedera memo, can be a maximum of 100 bytes
+     * @returns {TransactionBuilder} - This transaction builder
+     */
+    memo(memo) {
+        if (Buffer.from(memo).length > 100) {
+            throw new sdk_core_1.InvalidParameterValueError('Memo must not be longer than 100 bytes');
+        }
+        this._memo = memo;
+        return this;
+    }
+    /**
+     *  Set the node, it may take the format `'<shard>.<realm>.<account>'` or `'<account>'`
+     *
+     * @param {HederaNode} node - A hedera node address
+     * @returns {TransactionBuilder} - This transaction builder
+     */
+    node(node) {
+        if (!utils_1.isValidAddress(node.nodeId)) {
+            throw new sdk_core_1.InvalidParameterValueError('Invalid Hedera node address');
+        }
+        this._node = node;
+        return this;
+    }
+    /**
+     * Set the transaction valid duration
+     *
+     * @param {number} validDuration - The transaction valid duration in seconds
+     * @returns {TransactionBuilder} - This transaction builder
+     */
+    validDuration(validDuration) {
+        this.validateValue(new bignumber_js_1.default(validDuration));
+        this._duration = new proto.Duration({ seconds: Long.fromNumber(validDuration) });
+        return this;
+    }
+    /**
+     * Set the transaction fees
+     *
+     * @param {BaseFee} fee - The maximum gas to pay
+     * @returns {TransactionBuilder} - This transaction builder
+     */
+    fee(fee) {
+        this.validateValue(new bignumber_js_1.default(fee.fee));
+        this._fee = fee;
+        return this;
+    }
+    /**
+     * Set the transaction source
+     *
+     * @param {BaseAddress} address - The source account
+     * @returns {TransactionBuilder} - This transaction builder
+     */
+    source(address) {
+        this.validateAddress(address);
+        this._source = address;
+        return this;
+    }
+    /**
+     * Set an external transaction signature
+     *
+     * @param {string} signature - Hex encoded signature string
+     * @param {KeyPair} keyPair - The public key keypair that was used to create the signature
+     * @returns {TransactionBuilder} - Transaction builder
+     */
+    signature(signature, keyPair) {
+        // if we already have a signature for this key pair, just update it
+        for (const oldSignature of this._signatures) {
+            if (oldSignature.keyPair.getKeys().pub === keyPair.getKeys().pub) {
+                oldSignature.signature = signature;
+                return this;
+            }
+        }
+        // otherwise add the new signature
+        this._signatures.push({ signature, keyPair });
+        return this;
+    }
+    /**
+     * Set the start time
+     *
+     * @param {string} time - String value of the time to set with format <seconds>.<nanos>
+     * @returns {TransactionBuilder} - this
+     */
+    startTime(time) {
+        if (!utils_1.isValidTimeString(time)) {
+            throw new sdk_core_1.InvalidParameterValueError('Invalid value for time parameter');
+        }
+        const timeParts = time.split('.').map((v) => new bignumber_js_1.default(v).toNumber());
+        this._startTime = { seconds: Long.fromNumber(timeParts[0]), nanos: timeParts[1] };
+        return this;
+    }
+    // endregion
+    // region Getters and Setters
+    get validStart() {
+        if (!this._startTime) {
+            this.startTime(utils_1.getCurrentTime());
+        }
+        return this._startTime;
+    }
+    /** @inheritdoc */
+    get transaction() {
+        return this._transaction;
+    }
+    /** @inheritdoc */
+    set transaction(transaction) {
+        this._transaction = transaction;
+    }
+    // endregion
+    // region Validators
+    /** @inheritdoc */
+    validateAddress(address, addressFormat) {
+        if (!utils_1.isValidAddress(address.address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address ' + address.address);
+        }
+    }
+    /** @inheritdoc */
+    validateKey(key) {
+        if (!new keyPair_1.KeyPair({ prv: key.key })) {
+            throw new sdk_core_1.BuildTransactionError('Invalid key');
+        }
+    }
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction) {
+        if (!utils_1.isValidRawTransactionFormat(rawTransaction)) {
+            throw new sdk_core_1.ParseTransactionError('Invalid raw transaction');
+        }
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        this.validateMandatoryFields();
+    }
+    /** @inheritdoc */
+    validateValue(value) {
+        if (value.isLessThan(0)) {
+            throw new sdk_core_1.BuildTransactionError('Value cannot be less than zero');
+        }
+    }
+    validateMandatoryFields() {
+        if (this._fee === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing fee');
+        }
+        if (this._source === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing source');
+        }
+    }
+    /**
+     * Validates that the given key is not already in this._multiSignerKeyPairs
+     *
+     * @param {BaseKey} key - The key to check
+     */
+    checkDuplicatedKeys(key) {
+        this._multiSignerKeyPairs.forEach((_sourceKeyPair) => {
+            if (_sourceKeyPair.getKeys().prv === key.key) {
+                throw new sdk_core_1.SigningError('Repeated sign: ' + key.key);
+            }
+        });
+    }
+}
+exports.TransactionBuilder = TransactionBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../../src/coin/hbar/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport BigNumber from 'bignumber.js';\nimport * as Long from 'long';\nimport * as proto from '@hashgraph/proto';\nimport {\n  BaseAddress,\n  BaseFee,\n  BaseKey,\n  BaseTransactionBuilder,\n  BuildTransactionError,\n  InvalidParameterValueError,\n  ParseTransactionError,\n  SigningError,\n} from '@bitgo/sdk-core';\nimport { Transaction } from './transaction';\nimport {\n  buildHederaAccountID,\n  getCurrentTime,\n  isValidAddress,\n  isValidRawTransactionFormat,\n  isValidTimeString,\n} from './utils';\nimport { KeyPair } from './keyPair';\nimport { HederaNode, SignatureData } from './iface';\n\nexport abstract class TransactionBuilder extends BaseTransactionBuilder {\n  protected _fee: BaseFee;\n  private _transaction: Transaction;\n  protected _source: BaseAddress;\n  protected _startTime: proto.ITimestamp;\n  protected _memo: string;\n  protected _txBody: proto.TransactionBody;\n  protected _node: HederaNode = { nodeId: '0.0.4' };\n  protected _duration: proto.Duration = new proto.Duration({ seconds: Long.fromNumber(120) });\n  protected _multiSignerKeyPairs: KeyPair[];\n  protected _signatures: SignatureData[];\n\n  protected constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._txBody = new proto.TransactionBody();\n    this._txBody.transactionValidDuration = this._duration;\n    this._multiSignerKeyPairs = [];\n    this._signatures = [];\n    this.transaction = new Transaction(_coinConfig);\n  }\n\n  // region Base Builder\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    this._txBody.nodeAccountID = buildHederaAccountID(this._node.nodeId);\n    this._txBody.transactionFee = Long.fromString(this._fee.fee);\n    this._txBody.transactionID = this.buildTxId();\n    this._txBody.memo = this._memo;\n    const hTransaction = this.transaction.hederaTx || new proto.Transaction();\n    hTransaction.bodyBytes = proto.TransactionBody.encode(this._txBody).finish();\n    this.transaction.body(hTransaction);\n    for (const kp of this._multiSignerKeyPairs) {\n      await this.transaction.sign(kp);\n    }\n    for (const { signature, keyPair } of this._signatures) {\n      this.transaction.addSignature(signature, keyPair);\n    }\n    return this.transaction;\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: Uint8Array | string): Transaction {\n    const tx = new Transaction(this._coinConfig);\n    this.validateRawTransaction(rawTransaction);\n    tx.fromRawTransaction(rawTransaction);\n    this.initBuilder(tx);\n    return this.transaction;\n  }\n\n  /** @inheritdoc */\n  protected signImplementation(key: BaseKey): Transaction {\n    this.checkDuplicatedKeys(key);\n    const signer = new KeyPair({ prv: key.key });\n\n    // Signing the transaction is an operation that relies on all the data being set,\n    // so we set the source here and leave the actual signing for the build step\n    this._multiSignerKeyPairs.push(signer);\n    return this.transaction;\n  }\n\n  /**\n   * Initialize the transaction builder fields using the decoded transaction data\n   *\n   * @param {Transaction} tx - the transaction data\n   */\n  initBuilder(tx: Transaction): void {\n    this.transaction = tx;\n    this.transaction.loadPreviousSignatures();\n    const txData = tx.toJson();\n    this.fee({ fee: txData.fee.toString() });\n    this.source({ address: txData.from });\n    this.startTime(txData.startTime);\n    this.node({ nodeId: txData.node });\n    this.validDuration(new BigNumber(txData.validDuration).toNumber());\n    if (txData.memo) {\n      this.memo(txData.memo);\n    }\n  }\n\n  /**\n   * Creates a Hedera TransactionID\n   *\n   * @returns {proto.TransactionID} - Created TransactionID\n   */\n  protected buildTxId(): proto.TransactionID {\n    return new proto.TransactionID({\n      transactionValidStart: this.validStart,\n      accountID: buildHederaAccountID(this._source.address),\n    });\n  }\n  // endregion\n\n  // region Common builder methods\n  /**\n   *  Set the memo\n   *\n   * @param {string} memo - A hedera memo, can be a maximum of 100 bytes\n   * @returns {TransactionBuilder} - This transaction builder\n   */\n  memo(memo: string): this {\n    if (Buffer.from(memo).length > 100) {\n      throw new InvalidParameterValueError('Memo must not be longer than 100 bytes');\n    }\n    this._memo = memo;\n    return this;\n  }\n\n  /**\n   *  Set the node, it may take the format `'<shard>.<realm>.<account>'` or `'<account>'`\n   *\n   * @param {HederaNode} node - A hedera node address\n   * @returns {TransactionBuilder} - This transaction builder\n   */\n  node(node: HederaNode): this {\n    if (!isValidAddress(node.nodeId)) {\n      throw new InvalidParameterValueError('Invalid Hedera node address');\n    }\n    this._node = node;\n    return this;\n  }\n\n  /**\n   * Set the transaction valid duration\n   *\n   * @param {number} validDuration - The transaction valid duration in seconds\n   * @returns {TransactionBuilder} - This transaction builder\n   */\n  validDuration(validDuration: number): this {\n    this.validateValue(new BigNumber(validDuration));\n    this._duration = new proto.Duration({ seconds: Long.fromNumber(validDuration) });\n    return this;\n  }\n\n  /**\n   * Set the transaction fees\n   *\n   * @param {BaseFee} fee - The maximum gas to pay\n   * @returns {TransactionBuilder} - This transaction builder\n   */\n  fee(fee: BaseFee): this {\n    this.validateValue(new BigNumber(fee.fee));\n    this._fee = fee;\n    return this;\n  }\n\n  /**\n   * Set the transaction source\n   *\n   * @param {BaseAddress} address - The source account\n   * @returns {TransactionBuilder} - This transaction builder\n   */\n  source(address: BaseAddress): this {\n    this.validateAddress(address);\n    this._source = address;\n    return this;\n  }\n\n  /**\n   * Set an external transaction signature\n   *\n   * @param {string} signature - Hex encoded signature string\n   * @param {KeyPair} keyPair - The public key keypair that was used to create the signature\n   * @returns {TransactionBuilder} - Transaction builder\n   */\n  signature(signature: string, keyPair: KeyPair): this {\n    // if we already have a signature for this key pair, just update it\n    for (const oldSignature of this._signatures) {\n      if (oldSignature.keyPair.getKeys().pub === keyPair.getKeys().pub) {\n        oldSignature.signature = signature;\n        return this;\n      }\n    }\n\n    // otherwise add the new signature\n    this._signatures.push({ signature, keyPair });\n    return this;\n  }\n\n  /**\n   * Set the start time\n   *\n   * @param {string} time - String value of the time to set with format <seconds>.<nanos>\n   * @returns {TransactionBuilder} - this\n   */\n  startTime(time: string): this {\n    if (!isValidTimeString(time)) {\n      throw new InvalidParameterValueError('Invalid value for time parameter');\n    }\n    const timeParts = time.split('.').map((v) => new BigNumber(v).toNumber());\n    this._startTime = { seconds: Long.fromNumber(timeParts[0]), nanos: timeParts[1] };\n    return this;\n  }\n  // endregion\n\n  // region Getters and Setters\n  private get validStart(): proto.ITimestamp {\n    if (!this._startTime) {\n      this.startTime(getCurrentTime());\n    }\n    return this._startTime;\n  }\n\n  /** @inheritdoc */\n  protected get transaction(): Transaction {\n    return this._transaction;\n  }\n\n  /** @inheritdoc */\n  protected set transaction(transaction: Transaction) {\n    this._transaction = transaction;\n  }\n  // endregion\n\n  // region Validators\n  /** @inheritdoc */\n  validateAddress(address: BaseAddress, addressFormat?: string): void {\n    if (!isValidAddress(address.address)) {\n      throw new BuildTransactionError('Invalid address ' + address.address);\n    }\n  }\n\n  /** @inheritdoc */\n  validateKey(key: BaseKey): void {\n    if (!new KeyPair({ prv: key.key })) {\n      throw new BuildTransactionError('Invalid key');\n    }\n  }\n\n  /** @inheritdoc */\n  validateRawTransaction(rawTransaction: any): void {\n    if (!isValidRawTransactionFormat(rawTransaction)) {\n      throw new ParseTransactionError('Invalid raw transaction');\n    }\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction?: Transaction): void {\n    this.validateMandatoryFields();\n  }\n\n  /** @inheritdoc */\n  validateValue(value: BigNumber): void {\n    if (value.isLessThan(0)) {\n      throw new BuildTransactionError('Value cannot be less than zero');\n    }\n  }\n\n  validateMandatoryFields(): void {\n    if (this._fee === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing fee');\n    }\n    if (this._source === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing source');\n    }\n  }\n\n  /**\n   * Validates that the given key is not already in this._multiSignerKeyPairs\n   *\n   * @param {BaseKey} key - The key to check\n   */\n  private checkDuplicatedKeys(key: BaseKey): void {\n    this._multiSignerKeyPairs.forEach((_sourceKeyPair) => {\n      if (_sourceKeyPair.getKeys().prv === key.key) {\n        throw new SigningError('Repeated sign: ' + key.key);\n      }\n    });\n  }\n  // endregion\n}\n"]}

package/dist/src/coin/hbar/transactionBuilderFactory.d.ts

@@ -0,0 +1,42 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseTransactionBuilderFactory } from '@bitgo/sdk-core';
+import { WalletInitializationBuilder } from './walletInitializationBuilder';
+import { TransferBuilder } from './transferBuilder';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+import { TokenAssociateBuilder } from './tokenAssociateBuilder';
+export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    getWalletInitializationBuilder(tx?: Transaction): WalletInitializationBuilder;
+    /** @inheritDoc */
+    getTransferBuilder(tx?: Transaction): TransferBuilder;
+    /**
+     * Returns a builder to create a token association transaction
+     */
+    getTokenAssociateBuilder(tx?: Transaction): TokenAssociateBuilder;
+    /** @inheritDoc */
+    from(raw: Uint8Array | string): TransactionBuilder;
+    /**
+     * Initialize the builder with the given transaction
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @param {TransactionBuilder} builder - the builder to be initialized
+     * @returns {TransactionBuilder} the builder initialized
+     */
+    private initializeBuilder;
+    /**
+     * Returns a transaction instance from the encoded value
+     *
+     * @param {Uint8Array | string} rawTransaction - encoded transaction
+     * @returns {Transaction} the parsed transaction instance
+     */
+    private parseRawTransaction;
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     *
+     * @param {any} rawTransaction - Transaction in any format
+     */
+    private validateRawTransaction;
+}
+//# sourceMappingURL=transactionBuilderFactory.d.ts.map

package/dist/src/coin/hbar/transactionBuilderFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../../src/coin/hbar/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EACL,6BAA6B,EAI9B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,qBAAa,yBAA0B,SAAQ,6BAA6B;gBAC9D,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IAClB,8BAA8B,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,2BAA2B;IAI7E,kBAAkB;IAClB,kBAAkB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,eAAe;IAIrD;;OAEG;IACH,wBAAwB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,qBAAqB;IAIjE,kBAAkB;IAClB,IAAI,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,GAAG,kBAAkB;IAelD;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAM3B;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;CAK/B"}

package/dist/src/coin/hbar/transactionBuilderFactory.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilderFactory = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const walletInitializationBuilder_1 = require("./walletInitializationBuilder");
+const transferBuilder_1 = require("./transferBuilder");
+const transaction_1 = require("./transaction");
+const utils_1 = require("./utils");
+const tokenAssociateBuilder_1 = require("./tokenAssociateBuilder");
+class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /** @inheritdoc */
+    getWalletInitializationBuilder(tx) {
+        return this.initializeBuilder(tx, new walletInitializationBuilder_1.WalletInitializationBuilder(this._coinConfig));
+    }
+    /** @inheritDoc */
+    getTransferBuilder(tx) {
+        return this.initializeBuilder(tx, new transferBuilder_1.TransferBuilder(this._coinConfig));
+    }
+    /**
+     * Returns a builder to create a token association transaction
+     */
+    getTokenAssociateBuilder(tx) {
+        return this.initializeBuilder(tx, new tokenAssociateBuilder_1.TokenAssociateBuilder(this._coinConfig));
+    }
+    /** @inheritDoc */
+    from(raw) {
+        this.validateRawTransaction(raw);
+        const tx = this.parseRawTransaction(raw);
+        switch (tx.type) {
+            case sdk_core_1.TransactionType.Send:
+                return this.getTransferBuilder(tx);
+            case sdk_core_1.TransactionType.WalletInitialization:
+                return this.getWalletInitializationBuilder(tx);
+            case sdk_core_1.TransactionType.AssociatedTokenAccountInitialization:
+                return this.getTokenAssociateBuilder(tx);
+            default:
+                throw new sdk_core_1.InvalidTransactionError('Invalid transaction ' + tx.txBody.data);
+        }
+    }
+    /**
+     * Initialize the builder with the given transaction
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @param {TransactionBuilder} builder - the builder to be initialized
+     * @returns {TransactionBuilder} the builder initialized
+     */
+    initializeBuilder(tx, builder) {
+        if (tx) {
+            builder.initBuilder(tx);
+        }
+        return builder;
+    }
+    /**
+     * Returns a transaction instance from the encoded value
+     *
+     * @param {Uint8Array | string} rawTransaction - encoded transaction
+     * @returns {Transaction} the parsed transaction instance
+     */
+    parseRawTransaction(rawTransaction) {
+        const tx = new transaction_1.Transaction(this._coinConfig);
+        tx.fromRawTransaction(rawTransaction);
+        return tx;
+    }
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     *
+     * @param {any} rawTransaction - Transaction in any format
+     */
+    validateRawTransaction(rawTransaction) {
+        if (!utils_1.isValidRawTransactionFormat(rawTransaction)) {
+            throw new sdk_core_1.ParseTransactionError('Invalid raw transaction');
+        }
+    }
+}
+exports.TransactionBuilderFactory = TransactionBuilderFactory;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/coin/hbar/transferBuilder.d.ts

@@ -0,0 +1,43 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import * as proto from '@hashgraph/proto';
+import { BaseKey } from '@bitgo/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+export declare class TransferBuilder extends TransactionBuilder {
+    private readonly _txBodyData;
+    private _toAddress;
+    private _amount;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    private buildTransferData;
+    /** @inheritdoc */
+    initBuilder(tx: Transaction): void;
+    /**
+     * Initialize the transfer specific data, getting the recipient account
+     * represented by the element with a positive amount on the transfer element.
+     * The negative amount represents the source account, so it's ignored.
+     *
+     * @param {proto.IAccountAmount[]} transfers - Array of objects which contains accountID and transferred amount
+     */
+    protected initTransfers(transfers: proto.IAccountAmount[]): void;
+    /** @inheritdoc */
+    protected signImplementation(key: BaseKey): Transaction;
+    /**
+     * Set the destination address where the funds will be sent,
+     * it may take the format `'<shard>.<realm>.<account>'` or `'<account>'`
+     *
+     * @param {string} address - The address to transfer funds to
+     * @returns {TransferBuilder} - The builder with the new parameter set
+     */
+    to(address: string): this;
+    /**
+     * Set the amount to be transferred
+     *
+     * @param {string} amount - Amount to transfer in tinyBars (there are 100,000,000 tinyBars in one Hbar)
+     * @returns {TransferBuilder} - The builder with the new parameter set
+     */
+    amount(amount: string): this;
+    validateMandatoryFields(): void;
+}
+//# sourceMappingURL=transferBuilder.d.ts.map

package/dist/src/coin/hbar/transferBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transferBuilder.d.ts","sourceRoot":"","sources":["../../../../src/coin/hbar/transferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EACL,OAAO,EAKR,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI5C,qBAAa,eAAgB,SAAQ,kBAAkB;IACrD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsC;IAClE,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,OAAO,CAAS;gBAEZ,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAM7C,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAM3D,OAAO,CAAC,iBAAiB;IAYzB,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAQlC;;;;;;OAMG;IACH,SAAS,CAAC,aAAa,CAAC,SAAS,EAAE,KAAK,CAAC,cAAc,EAAE,GAAG,IAAI;IAUhE,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW;IAQvD;;;;;;OAMG;IACH,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQzB;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAW5B,uBAAuB,IAAI,IAAI;CAUhC"}

package/dist/src/coin/hbar/transferBuilder.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferBuilder = void 0;
+const Long = __importStar(require("long"));
+const proto = __importStar(require("@hashgraph/proto"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+class TransferBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._txBodyData = new proto.CryptoTransferTransactionBody();
+        this._txBody.cryptoTransfer = this._txBodyData;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        this._txBodyData.transfers = this.buildTransferData();
+        this.transaction.setTransactionType(sdk_core_1.TransactionType.Send);
+        return await super.buildImplementation();
+    }
+    buildTransferData() {
+        return {
+            accountAmounts: [
+                {
+                    accountID: utils_1.buildHederaAccountID(this._source.address),
+                    amount: Long.fromString(this._amount).negate(),
+                },
+                { accountID: utils_1.buildHederaAccountID(this._toAddress), amount: Long.fromString(this._amount) }, // recipient
+            ],
+        };
+    }
+    /** @inheritdoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        const transferData = tx.txBody.cryptoTransfer;
+        if (transferData && transferData.transfers && transferData.transfers.accountAmounts) {
+            this.initTransfers(transferData.transfers.accountAmounts);
+        }
+    }
+    /**
+     * Initialize the transfer specific data, getting the recipient account
+     * represented by the element with a positive amount on the transfer element.
+     * The negative amount represents the source account, so it's ignored.
+     *
+     * @param {proto.IAccountAmount[]} transfers - Array of objects which contains accountID and transferred amount
+     */
+    initTransfers(transfers) {
+        transfers.forEach((transferData) => {
+            const amount = Long.fromValue(transferData.amount);
+            if (amount.isPositive()) {
+                this.to(utils_1.stringifyAccountId(transferData.accountID));
+                this.amount(amount.toString());
+            }
+        });
+    }
+    /** @inheritdoc */
+    signImplementation(key) {
+        if (this._multiSignerKeyPairs.length >= constants_1.DEFAULT_SIGNER_NUMBER) {
+            throw new sdk_core_1.SigningError('A maximum of ' + constants_1.DEFAULT_SIGNER_NUMBER + ' can sign the transaction.');
+        }
+        return super.signImplementation(key);
+    }
+    // region Transfer fields
+    /**
+     * Set the destination address where the funds will be sent,
+     * it may take the format `'<shard>.<realm>.<account>'` or `'<account>'`
+     *
+     * @param {string} address - The address to transfer funds to
+     * @returns {TransferBuilder} - The builder with the new parameter set
+     */
+    to(address) {
+        if (!utils_1.isValidAddress(address)) {
+            throw new sdk_core_1.InvalidParameterValueError('Invalid address');
+        }
+        this._toAddress = address;
+        return this;
+    }
+    /**
+     * Set the amount to be transferred
+     *
+     * @param {string} amount - Amount to transfer in tinyBars (there are 100,000,000 tinyBars in one Hbar)
+     * @returns {TransferBuilder} - The builder with the new parameter set
+     */
+    amount(amount) {
+        if (!utils_1.isValidAmount(amount)) {
+            throw new sdk_core_1.InvalidParameterValueError('Invalid amount');
+        }
+        this._amount = amount;
+        return this;
+    }
+    // endregion
+    // region Validators
+    validateMandatoryFields() {
+        if (this._toAddress === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing to');
+        }
+        if (this._amount === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing amount');
+        }
+        super.validateMandatoryFields();
+    }
+}
+exports.TransferBuilder = TransferBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transferBuilder.js","sourceRoot":"","sources":["../../../../src/coin/hbar/transferBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport * as Long from 'long';\nimport * as proto from '@hashgraph/proto';\nimport {\n  BaseKey,\n  BuildTransactionError,\n  InvalidParameterValueError,\n  SigningError,\n  TransactionType,\n} from '@bitgo/sdk-core';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { Transaction } from './transaction';\nimport { buildHederaAccountID, isValidAddress, isValidAmount, stringifyAccountId } from './utils';\nimport { DEFAULT_SIGNER_NUMBER } from './constants';\n\nexport class TransferBuilder extends TransactionBuilder {\n  private readonly _txBodyData: proto.CryptoTransferTransactionBody;\n  private _toAddress: string;\n  private _amount: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._txBodyData = new proto.CryptoTransferTransactionBody();\n    this._txBody.cryptoTransfer = this._txBodyData;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    this._txBodyData.transfers = this.buildTransferData();\n    this.transaction.setTransactionType(TransactionType.Send);\n    return await super.buildImplementation();\n  }\n\n  private buildTransferData(): proto.ITransferList {\n    return {\n      accountAmounts: [\n        {\n          accountID: buildHederaAccountID(this._source.address),\n          amount: Long.fromString(this._amount).negate(),\n        }, // sender\n        { accountID: buildHederaAccountID(this._toAddress), amount: Long.fromString(this._amount) }, // recipient\n      ],\n    };\n  }\n\n  /** @inheritdoc */\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    const transferData = tx.txBody.cryptoTransfer;\n    if (transferData && transferData.transfers && transferData.transfers.accountAmounts) {\n      this.initTransfers(transferData.transfers.accountAmounts);\n    }\n  }\n\n  /**\n   * Initialize the transfer specific data, getting the recipient account\n   * represented by the element with a positive amount on the transfer element.\n   * The negative amount represents the source account, so it's ignored.\n   *\n   * @param {proto.IAccountAmount[]} transfers - Array of objects which contains accountID and transferred amount\n   */\n  protected initTransfers(transfers: proto.IAccountAmount[]): void {\n    transfers.forEach((transferData) => {\n      const amount = Long.fromValue(transferData.amount!);\n      if (amount.isPositive()) {\n        this.to(stringifyAccountId(transferData.accountID!));\n        this.amount(amount.toString());\n      }\n    });\n  }\n\n  /** @inheritdoc */\n  protected signImplementation(key: BaseKey): Transaction {\n    if (this._multiSignerKeyPairs.length >= DEFAULT_SIGNER_NUMBER) {\n      throw new SigningError('A maximum of ' + DEFAULT_SIGNER_NUMBER + ' can sign the transaction.');\n    }\n    return super.signImplementation(key);\n  }\n\n  // region Transfer fields\n  /**\n   * Set the destination address where the funds will be sent,\n   * it may take the format `'<shard>.<realm>.<account>'` or `'<account>'`\n   *\n   * @param {string} address - The address to transfer funds to\n   * @returns {TransferBuilder} - The builder with the new parameter set\n   */\n  to(address: string): this {\n    if (!isValidAddress(address)) {\n      throw new InvalidParameterValueError('Invalid address');\n    }\n    this._toAddress = address;\n    return this;\n  }\n\n  /**\n   * Set the amount to be transferred\n   *\n   * @param {string} amount - Amount to transfer in tinyBars (there are 100,000,000 tinyBars in one Hbar)\n   * @returns {TransferBuilder} - The builder with the new parameter set\n   */\n  amount(amount: string): this {\n    if (!isValidAmount(amount)) {\n      throw new InvalidParameterValueError('Invalid amount');\n    }\n    this._amount = amount;\n    return this;\n  }\n\n  // endregion\n\n  // region Validators\n  validateMandatoryFields(): void {\n    if (this._toAddress === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing to');\n    }\n    if (this._amount === undefined) {\n      throw new BuildTransactionError('Invalid transaction: missing amount');\n    }\n    super.validateMandatoryFields();\n  }\n  // endregion\n}\n"]}