@bitgo-beta/sdk-coin-xtz 1.4.3-alpha.401 → 1.4.3-alpha.403

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

@@ -0,0 +1,119 @@
+import { BaseKey, BaseTransaction } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { IndexedSignature, ParsedTransaction } from './iface';
+import { KeyPair } from './keyPair';
+/**
+ * Tezos transaction model.
+ */
+export declare class Transaction extends BaseTransaction {
+    private _parsedTransaction?;
+    private _encodedTransaction?;
+    private _source;
+    private _delegate?;
+    private _forwarderDestination?;
+    private _publicKeyToReveal?;
+    private _owners;
+    /**
+     * Public constructor.
+     *
+     * @param {Readonly<CoinConfig>} coinConfig
+     */
+    constructor(coinConfig: Readonly<CoinConfig>);
+    /**
+     * Initialize the transaction fields based on another serialized transaction.
+     *
+     * @param serializedTransaction Transaction in broadcast format.
+     */
+    initFromSerializedTransaction(serializedTransaction: string): Promise<void>;
+    /**
+     * Initialize the transaction fields based on another parsed transaction.
+     *
+     * @param {ParsedTransaction} parsedTransaction A Tezos transaction object
+     * @param {string} transactionId The transaction id of the parsedTransaction if it is signed
+     */
+    initFromParsedTransaction(parsedTransaction: ParsedTransaction, transactionId?: string): Promise<void>;
+    /**
+     * Record the most important fields from an origination operation.
+     *
+     * @param {Operation} operation An operation object from a Tezos transaction
+     * @param {number} index The origination operation index in the transaction. Used to calculate the
+     *      originated address
+     */
+    private recordOriginationOpFields;
+    /**
+     * Record the most important fields from a reveal operation.
+     *
+     * @param {RevealOp} operation A reveal operation object from a Tezos transaction
+     */
+    private recordRevealOpFields;
+    /**
+     * Record the most important fields for a Transaction operation.
+     *
+     * @param {TransactionOp} operation A transaction object from a Tezos operation
+     */
+    private recordTransactionOpFields;
+    /**
+     * Sign the transaction with the provided key. It does not check if the signer is allowed to sign
+     * it or not.
+     *
+     * @param {KeyPair} keyPair The key to sign the transaction with
+     */
+    sign(keyPair: KeyPair): Promise<void>;
+    /**
+     * Update the list of signatures for a multisig transaction operation.
+     *
+     * @param {IndexedSignature[]} signatures List of signatures and the index they should be put on
+     *    in the multisig transfer
+     * @param {number} index The transfer index to add the signatures to
+     */
+    addTransferSignature(signatures: IndexedSignature[], index: number): Promise<void>;
+    /** @inheritdoc */
+    canSign(key: BaseKey): boolean;
+    /** @inheritdoc */
+    toJson(): ParsedTransaction;
+    /** @inheritdoc */
+    toBroadcastFormat(): string;
+    /**
+     * Get the transaction source if it is available.
+     *
+     * @returns {string} Source of the transaction
+     */
+    get source(): string;
+    /**
+     * Get the transaction delegation address if it is available.
+     *
+     * @returns {string} transaction delegation address
+     */
+    get delegate(): string | undefined;
+    /**
+     * Get the public key revealed by the transaction if it exists
+     *
+     * @returns {string} public key
+     */
+    get publicKeyToReveal(): string | undefined;
+    /**
+     * Get the destination of an address initialization transaction if it exists
+     *
+     * @returns {string} forwarder destination
+     */
+    get forwarderDestination(): string | undefined;
+    get owners(): string[];
+    /**
+     * Get the signatures for the given multisig transfer,
+     *
+     * @param {number} transferIndex The transfer script index in the Tezos transaction
+     * @returns {IndexedSignature[]} A list of signatures with their index inside the multisig transfer
+     *      script
+     */
+    getTransferSignatures(transferIndex?: number): IndexedSignature[];
+    /**
+     * Get the list of index per tezos transaction type. This is useful to locate specific operations
+     * within the transaction and verify or sign them.
+     *
+     * @returns {{[p: string]: number[]}} List of indexes where the key is the transaction kind
+     */
+    getIndexesByTransactionType(): {
+        [kind: string]: number[];
+    };
+}
+//# sourceMappingURL=transaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,eAAe,EAIhB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAG7D,OAAO,EAAE,gBAAgB,EAAiB,iBAAiB,EAA2B,MAAM,SAAS,CAAC;AACtG,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUpC;;GAEG;AACH,qBAAa,WAAY,SAAQ,eAAe;IAC9C,OAAO,CAAC,kBAAkB,CAAC,CAAoB;IAC/C,OAAO,CAAC,mBAAmB,CAAC,CAAS;IACrC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,qBAAqB,CAAC,CAAS;IACvC,OAAO,CAAC,kBAAkB,CAAC,CAAS;IACpC,OAAO,CAAC,OAAO,CAAW;IAE1B;;;;OAIG;gBACS,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK5C;;;;OAIG;IACG,6BAA6B,CAAC,qBAAqB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBjF;;;;;OAKG;IACG,yBAAyB,CAAC,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwC5G;;;;;;OAMG;YACW,yBAAyB;IAwBvC;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAU5B;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;IA6BjC;;;;;OAKG;IACG,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB3C;;;;;;OAMG;IACG,oBAAoB,CAAC,UAAU,EAAE,gBAAgB,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQxF,kBAAkB;IAClB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAK9B,kBAAkB;IAClB,MAAM,IAAI,iBAAiB;IAO3B,kBAAkB;IAClB,iBAAiB,IAAI,MAAM;IAO3B;;;;OAIG;IACH,IAAI,MAAM,IAAI,MAAM,CAKnB;IAED;;;;OAIG;IACH,IAAI,QAAQ,IAAI,MAAM,GAAG,SAAS,CAEjC;IAED;;;;OAIG;IACH,IAAI,iBAAiB,IAAI,MAAM,GAAG,SAAS,CAE1C;IAED;;;;OAIG;IACH,IAAI,oBAAoB,IAAI,MAAM,GAAG,SAAS,CAE7C;IAED,IAAI,MAAM,IAAI,MAAM,EAAE,CAErB;IAED;;;;;;OAMG;IACH,qBAAqB,CAAC,aAAa,SAAI,GAAG,gBAAgB,EAAE;IAO5D;;;;;OAKG;IACH,2BAA2B,IAAI;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE;CAW5D"}

package/dist/src/lib/transaction.js

@@ -0,0 +1,329 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const local_forging_1 = require("@taquito/local-forging");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const multisigUtils_1 = require("./multisigUtils");
+const Utils = __importStar(require("./utils"));
+/**
+ * Tezos transaction model.
+ */
+class Transaction extends sdk_core_1.BaseTransaction {
+    /**
+     * Public constructor.
+     *
+     * @param {Readonly<CoinConfig>} coinConfig
+     */
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._owners = [];
+    }
+    /**
+     * Initialize the transaction fields based on another serialized transaction.
+     *
+     * @param serializedTransaction Transaction in broadcast format.
+     */
+    async initFromSerializedTransaction(serializedTransaction) {
+        this._encodedTransaction = serializedTransaction;
+        try {
+            const parsedTransaction = await local_forging_1.localForger.parse(serializedTransaction);
+            await this.initFromParsedTransaction(parsedTransaction);
+        }
+        catch (e) {
+            // If it throws, it is possible the serialized transaction is signed, which is not supported
+            // by local-forging. Try extracting the last 64 bytes and parse it again.
+            const unsignedSerializedTransaction = serializedTransaction.slice(0, -128);
+            const signature = serializedTransaction.slice(-128);
+            if (Utils.isValidSignature(signature)) {
+                throw new sdk_core_1.ParseTransactionError('Invalid transaction');
+            }
+            // TODO: encode the signature and save it in _signature
+            const parsedTransaction = await local_forging_1.localForger.parse(unsignedSerializedTransaction);
+            const transactionId = await Utils.calculateTransactionId(serializedTransaction);
+            await this.initFromParsedTransaction(parsedTransaction, transactionId);
+        }
+    }
+    /**
+     * Initialize the transaction fields based on another parsed transaction.
+     *
+     * @param {ParsedTransaction} parsedTransaction A Tezos transaction object
+     * @param {string} transactionId The transaction id of the parsedTransaction if it is signed
+     */
+    async initFromParsedTransaction(parsedTransaction, transactionId) {
+        if (!this._encodedTransaction) {
+            this._encodedTransaction = await local_forging_1.localForger.forge(parsedTransaction);
+        }
+        if (transactionId) {
+            // If the transaction id is passed, save it and clean up the entries since they will be
+            // recalculated
+            this._id = transactionId;
+            this._inputs = [];
+            this._outputs = [];
+        }
+        else {
+            this._id = '';
+        }
+        this._parsedTransaction = parsedTransaction;
+        let operationIndex = 0;
+        for (const operation of parsedTransaction.contents) {
+            if (this._source && this._source !== operation.source) {
+                throw new sdk_core_1.InvalidTransactionError('Source must be the same for every operation but it changed from ' + this._source + ' to ' + operation.source);
+            }
+            else {
+                this._source = operation.source;
+            }
+            switch (operation.kind) {
+                case local_forging_1.CODEC.OP_ORIGINATION:
+                    await this.recordOriginationOpFields(operation, operationIndex);
+                    operationIndex++;
+                    break;
+                case local_forging_1.CODEC.OP_REVEAL:
+                    this.recordRevealOpFields(operation);
+                    break;
+                case local_forging_1.CODEC.OP_TRANSACTION:
+                    this.recordTransactionOpFields(operation);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Record the most important fields from an origination operation.
+     *
+     * @param {Operation} operation An operation object from a Tezos transaction
+     * @param {number} index The origination operation index in the transaction. Used to calculate the
+     *      originated address
+     */
+    async recordOriginationOpFields(operation, index) {
+        const originationData = (0, multisigUtils_1.getOriginationDataFromOperation)(operation);
+        if (originationData.forwarderDestination) {
+            this._type = sdk_core_1.TransactionType.AddressInitialization;
+            this._forwarderDestination = originationData.forwarderDestination;
+        }
+        else {
+            this._type = sdk_core_1.TransactionType.WalletInitialization;
+            this._owners = (0, multisigUtils_1.getOwnersPublicKeys)(operation);
+        }
+        this._delegate = operation.delegate;
+        this._outputs.push({
+            // Kt addresses can only be calculated for signed transactions with an id
+            address: this._id ? await Utils.calculateOriginatedAddress(this._id, index) : '',
+            // Balance
+            value: operation.balance,
+        });
+        this._inputs.push({
+            address: operation.source,
+            // Balance + fees + max gas + max storage are paid by the source account
+            value: new bignumber_js_1.default(operation.balance).plus(operation.fee).toString(),
+        });
+    }
+    /**
+     * Record the most important fields from a reveal operation.
+     *
+     * @param {RevealOp} operation A reveal operation object from a Tezos transaction
+     */
+    recordRevealOpFields(operation) {
+        this._type = sdk_core_1.TransactionType.AccountUpdate;
+        this._publicKeyToReveal = operation.public_key;
+        this._inputs.push({
+            address: operation.source,
+            // Balance + fees + max gas + max storage are paid by the source account
+            value: operation.fee,
+        });
+    }
+    /**
+     * Record the most important fields for a Transaction operation.
+     *
+     * @param {TransactionOp} operation A transaction object from a Tezos operation
+     */
+    recordTransactionOpFields(operation) {
+        if (operation.parameters) {
+            this._type = sdk_core_1.TransactionType.Send;
+        }
+        else {
+            this._type = sdk_core_1.TransactionType.SingleSigSend;
+        }
+        const transferData = (0, multisigUtils_1.getMultisigTransferDataFromOperation)(operation);
+        // Fees are paid by the source account, along with the amount in the transaction
+        this._inputs.push({
+            address: operation.source,
+            value: new bignumber_js_1.default(transferData.fee.fee).toFixed(0),
+        });
+        if (transferData.coin === 'mutez') {
+            this._outputs.push({
+                // Kt addresses can only be calculated for signed transactions with an id
+                address: transferData.to,
+                // Balance
+                value: transferData.amount,
+            });
+            // The funds being transferred from the wallet
+            this._inputs.push({
+                address: transferData.from,
+                // Balance + fees + max gas + max storage are paid by the source account
+                value: transferData.amount,
+            });
+        }
+    }
+    /**
+     * Sign the transaction with the provided key. It does not check if the signer is allowed to sign
+     * it or not.
+     *
+     * @param {KeyPair} keyPair The key to sign the transaction with
+     */
+    async sign(keyPair) {
+        // TODO: fail if the transaction is already signed
+        // Check if there is a transaction to sign
+        if (!this._parsedTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        // Get the transaction body to sign
+        const encodedTransaction = await local_forging_1.localForger.forge(this._parsedTransaction);
+        const signedTransaction = await Utils.sign(keyPair, encodedTransaction);
+        this._encodedTransaction = signedTransaction.sbytes;
+        // The transaction id can only be calculated for signed transactions
+        this._id = await Utils.calculateTransactionId(this._encodedTransaction);
+        await this.initFromParsedTransaction(this._parsedTransaction, this._id);
+        this._signatures.push(signedTransaction.sig);
+    }
+    /**
+     * Update the list of signatures for a multisig transaction operation.
+     *
+     * @param {IndexedSignature[]} signatures List of signatures and the index they should be put on
+     *    in the multisig transfer
+     * @param {number} index The transfer index to add the signatures to
+     */
+    async addTransferSignature(signatures, index) {
+        if (!this._parsedTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        (0, multisigUtils_1.updateMultisigTransferSignatures)(this._parsedTransaction.contents[index], signatures);
+        this._encodedTransaction = await local_forging_1.localForger.forge(this._parsedTransaction);
+    }
+    /** @inheritdoc */
+    canSign(key) {
+        // TODO: check the key belongs to the _source account in _parsedTransaction
+        return true;
+    }
+    /** @inheritdoc */
+    toJson() {
+        if (!this._parsedTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        return this._parsedTransaction;
+    }
+    /** @inheritdoc */
+    toBroadcastFormat() {
+        if (!this._encodedTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Missing encoded transaction');
+        }
+        return this._encodedTransaction;
+    }
+    /**
+     * Get the transaction source if it is available.
+     *
+     * @returns {string} Source of the transaction
+     */
+    get source() {
+        if (!this._source) {
+            throw new sdk_core_1.InvalidTransactionError('Transaction not initialized');
+        }
+        return this._source;
+    }
+    /**
+     * Get the transaction delegation address if it is available.
+     *
+     * @returns {string} transaction delegation address
+     */
+    get delegate() {
+        return this._delegate;
+    }
+    /**
+     * Get the public key revealed by the transaction if it exists
+     *
+     * @returns {string} public key
+     */
+    get publicKeyToReveal() {
+        return this._publicKeyToReveal;
+    }
+    /**
+     * Get the destination of an address initialization transaction if it exists
+     *
+     * @returns {string} forwarder destination
+     */
+    get forwarderDestination() {
+        return this._forwarderDestination;
+    }
+    get owners() {
+        return this._owners;
+    }
+    /**
+     * Get the signatures for the given multisig transfer,
+     *
+     * @param {number} transferIndex The transfer script index in the Tezos transaction
+     * @returns {IndexedSignature[]} A list of signatures with their index inside the multisig transfer
+     *      script
+     */
+    getTransferSignatures(transferIndex = 0) {
+        if (!this._parsedTransaction) {
+            return [];
+        }
+        return (0, multisigUtils_1.getMultisigTransferSignatures)(this._parsedTransaction.contents[transferIndex]);
+    }
+    /**
+     * Get the list of index per tezos transaction type. This is useful to locate specific operations
+     * within the transaction and verify or sign them.
+     *
+     * @returns {{[p: string]: number[]}} List of indexes where the key is the transaction kind
+     */
+    getIndexesByTransactionType() {
+        if (!this._parsedTransaction) {
+            return {};
+        }
+        const indexes = {};
+        for (let i = 0; i < this._parsedTransaction.contents.length; i++) {
+            const kind = this._parsedTransaction.contents[i].kind;
+            indexes[kind] = indexes[kind] ? indexes[kind].concat([i]) : [i];
+        }
+        return indexes;
+    }
+}
+exports.Transaction = Transaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BaseKey,\n  BaseTransaction,\n  InvalidTransactionError,\n  ParseTransactionError,\n  TransactionType,\n} from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { CODEC, localForger } from '@taquito/local-forging';\nimport BigNumber from 'bignumber.js';\nimport { IndexedSignature, OriginationOp, ParsedTransaction, RevealOp, TransactionOp } from './iface';\nimport { KeyPair } from './keyPair';\nimport {\n  getMultisigTransferDataFromOperation,\n  getMultisigTransferSignatures,\n  getOriginationDataFromOperation,\n  getOwnersPublicKeys,\n  updateMultisigTransferSignatures,\n} from './multisigUtils';\nimport * as Utils from './utils';\n\n/**\n * Tezos transaction model.\n */\nexport class Transaction extends BaseTransaction {\n  private _parsedTransaction?: ParsedTransaction; // transaction in JSON format\n  private _encodedTransaction?: string; // transaction in hex format\n  private _source: string;\n  private _delegate?: string;\n  private _forwarderDestination?: string;\n  private _publicKeyToReveal?: string;\n  private _owners: string[];\n\n  /**\n   * Public constructor.\n   *\n   * @param {Readonly<CoinConfig>} coinConfig\n   */\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._owners = [];\n  }\n\n  /**\n   * Initialize the transaction fields based on another serialized transaction.\n   *\n   * @param serializedTransaction Transaction in broadcast format.\n   */\n  async initFromSerializedTransaction(serializedTransaction: string): Promise<void> {\n    this._encodedTransaction = serializedTransaction;\n    try {\n      const parsedTransaction = await localForger.parse(serializedTransaction);\n      await this.initFromParsedTransaction(parsedTransaction);\n    } catch (e) {\n      // If it throws, it is possible the serialized transaction is signed, which is not supported\n      // by local-forging. Try extracting the last 64 bytes and parse it again.\n      const unsignedSerializedTransaction = serializedTransaction.slice(0, -128);\n      const signature = serializedTransaction.slice(-128);\n      if (Utils.isValidSignature(signature)) {\n        throw new ParseTransactionError('Invalid transaction');\n      }\n      // TODO: encode the signature and save it in _signature\n      const parsedTransaction = await localForger.parse(unsignedSerializedTransaction);\n      const transactionId = await Utils.calculateTransactionId(serializedTransaction);\n      await this.initFromParsedTransaction(parsedTransaction, transactionId);\n    }\n  }\n\n  /**\n   * Initialize the transaction fields based on another parsed transaction.\n   *\n   * @param {ParsedTransaction} parsedTransaction A Tezos transaction object\n   * @param {string} transactionId The transaction id of the parsedTransaction if it is signed\n   */\n  async initFromParsedTransaction(parsedTransaction: ParsedTransaction, transactionId?: string): Promise<void> {\n    if (!this._encodedTransaction) {\n      this._encodedTransaction = await localForger.forge(parsedTransaction);\n    }\n    if (transactionId) {\n      // If the transaction id is passed, save it and clean up the entries since they will be\n      // recalculated\n      this._id = transactionId;\n      this._inputs = [];\n      this._outputs = [];\n    } else {\n      this._id = '';\n    }\n    this._parsedTransaction = parsedTransaction;\n    let operationIndex = 0;\n    for (const operation of parsedTransaction.contents) {\n      if (this._source && this._source !== operation.source) {\n        throw new InvalidTransactionError(\n          'Source must be the same for every operation but it changed from ' + this._source + ' to ' + operation.source\n        );\n      } else {\n        this._source = operation.source;\n      }\n      switch (operation.kind) {\n        case CODEC.OP_ORIGINATION:\n          await this.recordOriginationOpFields(operation as OriginationOp, operationIndex);\n          operationIndex++;\n          break;\n        case CODEC.OP_REVEAL:\n          this.recordRevealOpFields(operation as RevealOp);\n          break;\n        case CODEC.OP_TRANSACTION:\n          this.recordTransactionOpFields(operation as TransactionOp);\n          break;\n        default:\n          break;\n      }\n    }\n  }\n\n  /**\n   * Record the most important fields from an origination operation.\n   *\n   * @param {Operation} operation An operation object from a Tezos transaction\n   * @param {number} index The origination operation index in the transaction. Used to calculate the\n   *      originated address\n   */\n  private async recordOriginationOpFields(operation: OriginationOp, index: number): Promise<void> {\n    const originationData = getOriginationDataFromOperation(operation);\n    if (originationData.forwarderDestination) {\n      this._type = TransactionType.AddressInitialization;\n      this._forwarderDestination = originationData.forwarderDestination;\n    } else {\n      this._type = TransactionType.WalletInitialization;\n      this._owners = getOwnersPublicKeys(operation);\n    }\n\n    this._delegate = operation.delegate;\n    this._outputs.push({\n      // Kt addresses can only be calculated for signed transactions with an id\n      address: this._id ? await Utils.calculateOriginatedAddress(this._id, index) : '',\n      // Balance\n      value: operation.balance,\n    });\n    this._inputs.push({\n      address: operation.source,\n      // Balance + fees + max gas + max storage are paid by the source account\n      value: new BigNumber(operation.balance).plus(operation.fee).toString(),\n    });\n  }\n\n  /**\n   * Record the most important fields from a reveal operation.\n   *\n   * @param {RevealOp} operation A reveal operation object from a Tezos transaction\n   */\n  private recordRevealOpFields(operation: RevealOp): void {\n    this._type = TransactionType.AccountUpdate;\n    this._publicKeyToReveal = operation.public_key;\n    this._inputs.push({\n      address: operation.source,\n      // Balance + fees + max gas + max storage are paid by the source account\n      value: operation.fee,\n    });\n  }\n\n  /**\n   * Record the most important fields for a Transaction operation.\n   *\n   * @param {TransactionOp} operation A transaction object from a Tezos operation\n   */\n  private recordTransactionOpFields(operation: TransactionOp): void {\n    if (operation.parameters) {\n      this._type = TransactionType.Send;\n    } else {\n      this._type = TransactionType.SingleSigSend;\n    }\n    const transferData = getMultisigTransferDataFromOperation(operation);\n    // Fees are paid by the source account, along with the amount in the transaction\n    this._inputs.push({\n      address: operation.source,\n      value: new BigNumber(transferData.fee.fee).toFixed(0),\n    });\n\n    if (transferData.coin === 'mutez') {\n      this._outputs.push({\n        // Kt addresses can only be calculated for signed transactions with an id\n        address: transferData.to,\n        // Balance\n        value: transferData.amount,\n      });\n      // The funds being transferred from the wallet\n      this._inputs.push({\n        address: transferData.from,\n        // Balance + fees + max gas + max storage are paid by the source account\n        value: transferData.amount,\n      });\n    }\n  }\n\n  /**\n   * Sign the transaction with the provided key. It does not check if the signer is allowed to sign\n   * it or not.\n   *\n   * @param {KeyPair} keyPair The key to sign the transaction with\n   */\n  async sign(keyPair: KeyPair): Promise<void> {\n    // TODO: fail if the transaction is already signed\n    // Check if there is a transaction to sign\n    if (!this._parsedTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    // Get the transaction body to sign\n    const encodedTransaction = await localForger.forge(this._parsedTransaction);\n\n    const signedTransaction = await Utils.sign(keyPair, encodedTransaction);\n    this._encodedTransaction = signedTransaction.sbytes;\n\n    // The transaction id can only be calculated for signed transactions\n    this._id = await Utils.calculateTransactionId(this._encodedTransaction);\n    await this.initFromParsedTransaction(this._parsedTransaction, this._id);\n\n    this._signatures.push(signedTransaction.sig);\n  }\n\n  /**\n   * Update the list of signatures for a multisig transaction operation.\n   *\n   * @param {IndexedSignature[]} signatures List of signatures and the index they should be put on\n   *    in the multisig transfer\n   * @param {number} index The transfer index to add the signatures to\n   */\n  async addTransferSignature(signatures: IndexedSignature[], index: number): Promise<void> {\n    if (!this._parsedTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    updateMultisigTransferSignatures(this._parsedTransaction.contents[index] as TransactionOp, signatures);\n    this._encodedTransaction = await localForger.forge(this._parsedTransaction);\n  }\n\n  /** @inheritdoc */\n  canSign(key: BaseKey): boolean {\n    // TODO: check the key belongs to the _source account in _parsedTransaction\n    return true;\n  }\n\n  /** @inheritdoc */\n  toJson(): ParsedTransaction {\n    if (!this._parsedTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n    return this._parsedTransaction;\n  }\n\n  /** @inheritdoc */\n  toBroadcastFormat(): string {\n    if (!this._encodedTransaction) {\n      throw new InvalidTransactionError('Missing encoded transaction');\n    }\n    return this._encodedTransaction;\n  }\n\n  /**\n   * Get the transaction source if it is available.\n   *\n   * @returns {string} Source of the transaction\n   */\n  get source(): string {\n    if (!this._source) {\n      throw new InvalidTransactionError('Transaction not initialized');\n    }\n    return this._source;\n  }\n\n  /**\n   * Get the transaction delegation address if it is available.\n   *\n   * @returns {string} transaction delegation address\n   */\n  get delegate(): string | undefined {\n    return this._delegate;\n  }\n\n  /**\n   * Get the public key revealed by the transaction if it exists\n   *\n   * @returns {string} public key\n   */\n  get publicKeyToReveal(): string | undefined {\n    return this._publicKeyToReveal;\n  }\n\n  /**\n   * Get the destination of an address initialization transaction if it exists\n   *\n   * @returns {string} forwarder destination\n   */\n  get forwarderDestination(): string | undefined {\n    return this._forwarderDestination;\n  }\n\n  get owners(): string[] {\n    return this._owners;\n  }\n\n  /**\n   * Get the signatures for the given multisig transfer,\n   *\n   * @param {number} transferIndex The transfer script index in the Tezos transaction\n   * @returns {IndexedSignature[]} A list of signatures with their index inside the multisig transfer\n   *      script\n   */\n  getTransferSignatures(transferIndex = 0): IndexedSignature[] {\n    if (!this._parsedTransaction) {\n      return [];\n    }\n    return getMultisigTransferSignatures(this._parsedTransaction.contents[transferIndex] as TransactionOp);\n  }\n\n  /**\n   * Get the list of index per tezos transaction type. This is useful to locate specific operations\n   * within the transaction and verify or sign them.\n   *\n   * @returns {{[p: string]: number[]}} List of indexes where the key is the transaction kind\n   */\n  getIndexesByTransactionType(): { [kind: string]: number[] } {\n    if (!this._parsedTransaction) {\n      return {};\n    }\n    const indexes = {};\n    for (let i = 0; i < this._parsedTransaction.contents.length; i++) {\n      const kind = this._parsedTransaction.contents[i].kind;\n      indexes[kind] = indexes[kind] ? indexes[kind].concat([i]) : [i];\n    }\n    return indexes;\n  }\n}\n"]}

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

@@ -0,0 +1,171 @@
+import { BaseKey, BaseTransactionBuilder, TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import BigNumber from 'bignumber.js';
+import { Address } from './address';
+import { Fee, IndexedData, Key } from './iface';
+import { Transaction } from './transaction';
+import { TransferBuilder } from './transferBuilder';
+interface DataToSignOverride extends IndexedData {
+    dataToSign: string;
+}
+/**
+ * Tezos transaction builder.
+ */
+export declare class TransactionBuilder extends BaseTransactionBuilder {
+    private _serializedTransaction;
+    private _transaction;
+    private _type;
+    private _blockHeader;
+    private _counter;
+    private _fee;
+    private _sourceAddress;
+    private _sourceKeyPair?;
+    private _publicKeyToReveal;
+    private _initialBalance;
+    private _initialDelegate;
+    private _walletOwnerPublicKeys;
+    private _multisigSignerKeyPairs;
+    private _dataToSignOverride;
+    private _transfers;
+    private _forwarderDestination;
+    /**
+     * Public constructor.
+     *
+     * @param {CoinConfig} _coinConfig - coin configuration
+     */
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    /** @inheritdoc */
+    protected signImplementation(key: Key): Transaction;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    /**
+     * Set the transaction branch id.
+     *
+     * @param {string} blockId A block hash to use as branch reference
+     */
+    branch(blockId: string): void;
+    /**
+     * The type of transaction being built.
+     *
+     * @param {TransactionType} type - type of the transaction
+     */
+    type(type: TransactionType): void;
+    /**
+     * Set the transaction fees. Low fees may get a transaction rejected or never picked up by bakers.
+     *
+     * @param {Fee} fee Baker fees. May also include the maximum gas and storage fees to pay
+     */
+    fee(fee: Fee): void;
+    /**
+     * Set the transaction initiator. This account will pay for the transaction fees, but it will not
+     * be added as an owner of a wallet in a init transaction, unless manually set as one of the
+     * owners.
+     *
+     * @param {string} source A Tezos address
+     */
+    source(source: string): void;
+    /**
+     * Set an amount of mutez to transfer in this transaction this transaction. This is different than
+     * the amount to transfer from a multisig wallet.
+     *
+     * @param {string} amount Amount in mutez (1/1000000 Tezies)
+     */
+    initialBalance(amount: string): void;
+    /**
+     * Set the transaction counter to prevent submitting repeated transactions.
+     *
+     * @param {string} counter The counter to use
+     */
+    counter(counter: string): void;
+    /**
+     * Set the destination address of a forwarder contract
+     * Used in forwarder contract deployment as destination address
+     *
+     * @param {string} contractAddress - contract address to use
+     */
+    forwarderDestination(contractAddress: string): void;
+    /**
+     * The public key to reveal.
+     *
+     * @param {string} publicKey A Tezos public key
+     */
+    publicKeyToReveal(publicKey: string): void;
+    /**
+     * Build a reveal operation for the source account with default fees.
+     *
+     * @returns {RevealOp} A Tezos reveal operation
+     */
+    private buildPublicKeyRevelationOperation;
+    /**
+     * Set one of the owners of the multisig wallet.
+     *
+     * @param {string} publicKey A Tezos public key
+     */
+    owner(publicKey: string): void;
+    /**
+     * Set an initial delegate to initialize this wallet to. This is different than the delegation to
+     * set while doing a separate delegation transaction.
+     *
+     * @param {string} delegate The address to delegate the funds to
+     */
+    initialDelegate(delegate: string): void;
+    /**
+     * Build an origination operation for a generic multisig contract.
+     *
+     * @returns {Operation} A Tezos origination operation
+     */
+    private buildWalletInitializationOperations;
+    /**
+     * Initialize a new TransferBuilder to for a singlesig or multisig transaction.
+     *
+     * @param {string} amount Amount in mutez to be transferred
+     * @returns {TransferBuilder} A transfer builder
+     */
+    transfer(amount: string): TransferBuilder;
+    /**
+     * Calculate the signatures for the multisig transaction.
+     *
+     * @param {string} packedData The string in hexadecimal to sign
+     * @returns {Promise<string[]>} List of signatures for packedData
+     */
+    private getSignatures;
+    /**
+     * Override the data to sign for a specific transfer. Used for offline signing to pass the
+     * respective dataToSign for transfer at a particular index.
+     *
+     * @param {DataToSignOverride} data - data to override
+     */
+    overrideDataToSign(data: DataToSignOverride): void;
+    /**
+     * Build a transaction operation for a generic multisig contract.
+     *
+     * @returns {Promise<TransactionOp[]>} A Tezos transaction operation
+     */
+    private buildSendTransactionContent;
+    /**
+     * Build a transaction operation for a forwarder contract
+     *
+     * @returns {OriginationOp} a Tezos transaction operation
+     */
+    private buildForwarderDeploymentContent;
+    /** @inheritdoc */
+    validateValue(value: BigNumber): void;
+    /** @inheritdoc */
+    validateAddress(address: Address): void;
+    /** @inheritdoc */
+    validateKey(key: BaseKey): void;
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction: any): void;
+    /** @inheritdoc */
+    validateTransaction(transaction: Transaction): void;
+    /** @inheritdoc */
+    displayName(): string;
+    /** @inheritdoc */
+    protected get transaction(): Transaction;
+    /** @inheritdoc */
+    protected set transaction(transaction: Transaction);
+}
+export {};
+//# sourceMappingURL=transactionBuilder.d.ts.map