@bitgo-beta/sdk-coin-iota 1.0.1-beta.44 → 1.0.1-beta.441

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

@@ -1,8 +1,178 @@
-import { BaseKey, BaseTransaction } from '@bitgo-beta/sdk-core';
-import { TxData } from './iface';
-export declare class Transaction extends BaseTransaction {
-    canSign(key: BaseKey): boolean;
+import { BaseKey, BaseTransaction, PublicKey, TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { Transaction as IotaTransaction } from '@iota/iota-sdk/transactions';
+import { TxData, TransactionObjectInput, TransactionExplanation } from './iface';
+/**
+ * Base class for IOTA transactions.
+ * Manages transaction state, gas data, signatures, and building/serialization.
+ */
+export declare abstract class Transaction extends BaseTransaction {
+    protected _rebuildRequired: boolean;
+    protected _type: TransactionType;
+    protected _iotaTransaction: IotaTransaction;
+    private _gasBudget?;
+    private _gasPaymentObjects?;
+    private _gasPrice?;
+    private _gasSponsor?;
+    private _sender;
+    private _txDataBytes?;
+    private _isSimulateTx;
+    private _signature?;
+    private _serializedSignature?;
+    private _gasSponsorSignature?;
+    private _serializedGasSponsorSignature?;
+    protected constructor(coinConfig: Readonly<CoinConfig>);
+    get gasBudget(): number | undefined;
+    set gasBudget(value: number | undefined);
+    get gasPaymentObjects(): TransactionObjectInput[] | undefined;
+    set gasPaymentObjects(value: TransactionObjectInput[] | undefined);
+    get gasPrice(): number | undefined;
+    set gasPrice(value: number | undefined);
+    get gasSponsor(): string | undefined;
+    set gasSponsor(value: string | undefined);
+    get sender(): string;
+    set sender(value: string);
+    /**
+     * Indicates whether this is a simulate transaction (dry run) or a real transaction.
+     * Simulate transactions use maximum gas values for estimation purposes.
+     */
+    get isSimulateTx(): boolean;
+    set isSimulateTx(value: boolean);
+    /**
+     * Marks that the transaction needs to be rebuilt before it can be signed or broadcast.
+     */
+    private markRebuildRequired;
+    /**
+     * Validates transaction data when switching from simulate to real transaction mode.
+     */
+    private validateTxDataForRealTransaction;
+    /**
+     * Returns the signable payload for this transaction.
+     * This is the Blake2b hash of the transaction data with intent message.
+     * @throws Error if transaction is in simulate mode or not built
+     */
+    get signablePayload(): Buffer;
+    /**
+     * Returns the transaction digest (ID).
+     * @throws Error if transaction is not built or needs rebuilding
+     */
+    get id(): string;
+    /**
+     * Ensures the transaction is built and doesn't need rebuilding.
+     * @throws Error if transaction is not built or rebuild is required
+     */
+    private ensureTransactionIsBuilt;
+    /**
+     * Adds a signature from the transaction sender.
+     */
+    addSignature(publicKey: PublicKey, signature: Buffer): void;
+    /**
+     * Adds a signature from the gas sponsor (if different from sender).
+     */
+    addGasSponsorSignature(publicKey: PublicKey, signature: Buffer): void;
+    /**
+     * Checks if this transaction can be signed.
+     * Only real transactions (not simulate) can be signed.
+     */
+    canSign(_key: BaseKey): boolean;
+    /**
+     * Returns the transaction fee (gas budget).
+     */
+    getFee(): string | undefined;
+    get serializedGasSponsorSignature(): string | undefined;
+    get serializedSignature(): string | undefined;
+    /**
+     * Serializes all signatures for the transaction.
+     * Includes both sender signature and gas sponsor signature if present.
+     */
+    serializeSignatures(): void;
+    /**
+     * Converts the transaction to broadcast format (base64 encoded).
+     */
+    toBroadcastFormat(): Promise<string>;
+    /**
+     * Builds the transaction bytes.
+     * If in simulate mode, builds a dry run transaction with max gas values.
+     * Otherwise, builds a real transaction with actual gas data.
+     */
+    build(): Promise<Uint8Array<ArrayBufferLike>>;
     toJson(): TxData;
-    toBroadcastFormat(): string;
+    parseFromJSON(txData: TxData): void;
+    /**
+     * Parses transaction data from its broadcast format (base64 or raw bytes).
+     * Extracts sender, gas data, and gas sponsor information.
+     */
+    parseFromBroadcastTx(tx: string | Uint8Array): void;
+    /**
+     * Parses the sender address from transaction data.
+     */
+    private parseSender;
+    /**
+     * Parses gas-related data from transaction data.
+     */
+    private parseGasData;
+    /**
+     * @inheritDoc
+     */
+    explainTransaction(): any;
+    /**
+     * Updates the simulate transaction flag based on gas data availability.
+     * If all gas data is present, switches to real transaction mode.
+     */
+    protected updateIsSimulateTx(): void;
+    protected abstract messageWithIntent(message: Uint8Array): Uint8Array;
+    protected abstract populateTxInputsAndCommands(): void;
+    protected abstract validateTxDataImplementation(): void;
+    abstract addInputsAndOutputs(): void;
+    protected abstract explainTransactionImplementation(json: TxData, explanationResult: TransactionExplanation): TransactionExplanation;
+    /**
+     * Builds a dry run (simulate) transaction with maximum gas values.
+     * Used for gas estimation without committing the transaction.
+     */
+    private buildDryRunTransaction;
+    /**
+     * Builds a real transaction with actual gas data.
+     * Only builds if necessary (first time or rebuild required).
+     */
+    private buildRealTransaction;
+    /**
+     * Sets gas data on the IOTA transaction object.
+     */
+    private setGasDataOnTransaction;
+    /**
+     * Populates the IOTA transaction with inputs, commands, and gas sponsor if applicable.
+     */
+    private populateTxData;
+    /**
+     * Checks if the transaction has a gas sponsor different from the sender.
+     */
+    private hasDifferentGasSponsor;
+    /**
+     * Sets up a gas-sponsored transaction by building the transaction kind
+     * and setting the gas owner.
+     */
+    private setupGasSponsoredTransaction;
+    /**
+     * Serializes a signature into IOTA's expected format.
+     * Format: [signature_scheme_flag (1 byte), signature, public_key]
+     * Currently hardcoded to EDDSA (0x00) as IOTA only supports this scheme.
+     */
+    private serializeSignature;
+    /**
+     * Validates all transaction data required for a real (non-simulate) transaction.
+     */
+    private validateTxData;
+    /**
+     * Validates common transaction data (sender, gas data).
+     */
+    private validateCommonTxData;
+    /**
+     * Validates sender and gas sponsor signatures if present.
+     */
+    private validateSignatures;
+    /**
+     * Checks if a signature has valid public key and signature data.
+     */
+    private isValidSignature;
 }
 //# sourceMappingURL=transaction.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEjC,qBAAa,WAAY,SAAQ,eAAe;IAC9C,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAG9B,MAAM,IAAI,MAAM;IAGhB,iBAAiB,IAAI,MAAM;CAG5B"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/transaction.js

@@ -1,17 +1,401 @@
 "use strict";
+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 transactions_1 = require("@iota/iota-sdk/transactions");
+const utils_1 = require("@iota/iota-sdk/utils");
+const blake2b_1 = __importDefault(require("@bitgo-beta/blake2b"));
+const constants_1 = require("./constants");
+const utils_2 = __importDefault(require("./utils"));
+/**
+ * Base class for IOTA transactions.
+ * Manages transaction state, gas data, signatures, and building/serialization.
+ */
 class Transaction extends sdk_core_1.BaseTransaction {
-    canSign(key) {
-        throw new Error('Method not implemented.');
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._sender = '';
+        this._rebuildRequired = false;
+        this._isSimulateTx = true;
+    }
+    // Gas budget getter/setter - marks rebuild required when changed
+    get gasBudget() {
+        return this._gasBudget;
+    }
+    set gasBudget(value) {
+        this._gasBudget = value;
+        this.markRebuildRequired();
+    }
+    // Gas payment objects getter/setter - marks rebuild required when changed
+    get gasPaymentObjects() {
+        return this._gasPaymentObjects;
+    }
+    set gasPaymentObjects(value) {
+        this._gasPaymentObjects = value;
+        this.markRebuildRequired();
+    }
+    // Gas price getter/setter - marks rebuild required when changed
+    get gasPrice() {
+        return this._gasPrice;
+    }
+    set gasPrice(value) {
+        this._gasPrice = value;
+        this.markRebuildRequired();
+    }
+    // Gas sponsor getter/setter - marks rebuild required when changed
+    get gasSponsor() {
+        return this._gasSponsor;
+    }
+    set gasSponsor(value) {
+        this._gasSponsor = value;
+        this.markRebuildRequired();
+    }
+    // Transaction sender getter/setter - marks rebuild required when changed
+    get sender() {
+        return this._sender;
+    }
+    set sender(value) {
+        this._sender = value;
+        this.markRebuildRequired();
+    }
+    /**
+     * Indicates whether this is a simulate transaction (dry run) or a real transaction.
+     * Simulate transactions use maximum gas values for estimation purposes.
+     */
+    get isSimulateTx() {
+        return this._isSimulateTx;
+    }
+    set isSimulateTx(value) {
+        if (!value) {
+            this.validateTxDataForRealTransaction();
+            this.markRebuildRequired();
+        }
+        this._isSimulateTx = value;
+    }
+    /**
+     * Marks that the transaction needs to be rebuilt before it can be signed or broadcast.
+     */
+    markRebuildRequired() {
+        this._rebuildRequired = true;
+    }
+    /**
+     * Validates transaction data when switching from simulate to real transaction mode.
+     */
+    validateTxDataForRealTransaction() {
+        try {
+            this.validateTxData();
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Tx data validation failed: ${errorMessage}. {Cause: ${error}}`);
+        }
+    }
+    /**
+     * Returns the signable payload for this transaction.
+     * This is the Blake2b hash of the transaction data with intent message.
+     * @throws Error if transaction is in simulate mode or not built
+     */
+    get signablePayload() {
+        if (this.isSimulateTx) {
+            throw new Error('Cannot sign a simulate tx');
+        }
+        this.ensureTransactionIsBuilt();
+        const intentMessage = this.messageWithIntent(this._txDataBytes);
+        return Buffer.from((0, blake2b_1.default)(32).update(intentMessage).digest('binary'));
+    }
+    /**
+     * Returns the transaction digest (ID).
+     * @throws Error if transaction is not built or needs rebuilding
+     */
+    get id() {
+        this.ensureTransactionIsBuilt();
+        return transactions_1.TransactionDataBuilder.getDigestFromBytes(this._txDataBytes);
+    }
+    /**
+     * Ensures the transaction is built and doesn't need rebuilding.
+     * @throws Error if transaction is not built or rebuild is required
+     */
+    ensureTransactionIsBuilt() {
+        if (this._txDataBytes === undefined || this._rebuildRequired) {
+            throw new Error('Tx not built or a rebuild is required');
+        }
+    }
+    /**
+     * Adds a signature from the transaction sender.
+     */
+    addSignature(publicKey, signature) {
+        this._signature = { publicKey, signature };
+    }
+    /**
+     * Adds a signature from the gas sponsor (if different from sender).
+     */
+    addGasSponsorSignature(publicKey, signature) {
+        this._gasSponsorSignature = { publicKey, signature };
+    }
+    /**
+     * Checks if this transaction can be signed.
+     * Only real transactions (not simulate) can be signed.
+     */
+    canSign(_key) {
+        return !this.isSimulateTx;
+    }
+    /**
+     * Returns the transaction fee (gas budget).
+     */
+    getFee() {
+        return this.gasBudget?.toString();
+    }
+    get serializedGasSponsorSignature() {
+        return this._serializedGasSponsorSignature;
+    }
+    get serializedSignature() {
+        return this._serializedSignature;
+    }
+    /**
+     * Serializes all signatures for the transaction.
+     * Includes both sender signature and gas sponsor signature if present.
+     */
+    serializeSignatures() {
+        this._signatures = [];
+        if (this._signature) {
+            this._serializedSignature = this.serializeSignature(this._signature);
+            this._signatures.push(this._serializedSignature);
+        }
+        if (this._gasSponsorSignature) {
+            this._serializedGasSponsorSignature = this.serializeSignature(this._gasSponsorSignature);
+            this._signatures.push(this._serializedGasSponsorSignature);
+        }
+    }
+    /**
+     * Converts the transaction to broadcast format (base64 encoded).
+     */
+    async toBroadcastFormat() {
+        const txDataBytes = await this.build();
+        return (0, utils_1.toBase64)(txDataBytes);
+    }
+    /**
+     * Builds the transaction bytes.
+     * If in simulate mode, builds a dry run transaction with max gas values.
+     * Otherwise, builds a real transaction with actual gas data.
+     */
+    async build() {
+        if (this.isSimulateTx) {
+            return this.buildDryRunTransaction();
+        }
+        return this.buildRealTransaction();
     }
     toJson() {
-        throw new Error('Method not implemented.');
+        return {
+            sender: this.sender,
+            gasBudget: this.gasBudget,
+            gasPrice: this.gasPrice,
+            gasPaymentObjects: this.gasPaymentObjects,
+            gasSponsor: this.gasSponsor,
+            type: this.type,
+        };
+    }
+    parseFromJSON(txData) {
+        this.sender = txData.sender;
+        this.gasBudget = txData.gasBudget;
+        this.gasPrice = txData.gasPrice;
+        this.gasPaymentObjects = txData.gasPaymentObjects;
+        if (txData.gasSponsor !== undefined) {
+            this.gasSponsor = txData.gasSponsor;
+        }
+    }
+    /**
+     * Parses transaction data from its broadcast format (base64 or raw bytes).
+     * Extracts sender, gas data, and gas sponsor information.
+     */
+    parseFromBroadcastTx(tx) {
+        const txData = transactions_1.Transaction.from(tx).getData();
+        this.parseSender(txData);
+        this.parseGasData(txData);
+    }
+    /**
+     * Parses the sender address from transaction data.
+     */
+    parseSender(txData) {
+        if (txData.sender) {
+            this.sender = txData.sender;
+        }
+    }
+    /**
+     * Parses gas-related data from transaction data.
+     */
+    parseGasData(txData) {
+        const gasData = txData.gasData;
+        if (!gasData) {
+            this.gasBudget = undefined;
+            this.gasPrice = undefined;
+            this.gasPaymentObjects = undefined;
+            this.gasSponsor = undefined;
+            return;
+        }
+        this.gasBudget = gasData.budget ? Number(gasData.budget) : undefined;
+        this.gasPrice = gasData.price ? Number(gasData.price) : undefined;
+        this.gasPaymentObjects =
+            gasData.payment && gasData.payment.length > 0
+                ? gasData.payment.map((payment) => payment)
+                : undefined;
+        this.gasSponsor = gasData.owner || undefined;
+    }
+    /**
+     * @inheritDoc
+     */
+    explainTransaction() {
+        const result = this.toJson();
+        const displayOrder = ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'type'];
+        const outputs = [];
+        const explanationResult = {
+            displayOrder,
+            id: this.id,
+            outputs,
+            outputAmount: '0',
+            changeOutputs: [],
+            changeAmount: '0',
+            fee: { fee: this.gasBudget ? this.gasBudget.toString() : '' },
+            sender: this.sender,
+            sponsor: this.gasSponsor,
+            type: this.type,
+        };
+        return this.explainTransactionImplementation(result, explanationResult);
+    }
+    /**
+     * Updates the simulate transaction flag based on gas data availability.
+     * If all gas data is present, switches to real transaction mode.
+     */
+    updateIsSimulateTx() {
+        const hasAllGasData = this.gasBudget && this.gasPrice && this.gasPaymentObjects && this.gasPaymentObjects.length > 0;
+        this.isSimulateTx = !hasAllGasData;
+    }
+    /**
+     * Builds a dry run (simulate) transaction with maximum gas values.
+     * Used for gas estimation without committing the transaction.
+     */
+    async buildDryRunTransaction() {
+        this.validateTxDataImplementation();
+        await this.populateTxData();
+        const txDataBuilder = new transactions_1.TransactionDataBuilder(this._iotaTransaction.getData());
+        return txDataBuilder.build({
+            overrides: {
+                gasData: {
+                    budget: constants_1.MAX_GAS_BUDGET.toString(),
+                    price: constants_1.MAX_GAS_PRICE.toString(),
+                    payment: [],
+                },
+            },
+        });
+    }
+    /**
+     * Builds a real transaction with actual gas data.
+     * Only builds if necessary (first time or rebuild required).
+     */
+    async buildRealTransaction() {
+        if (this._txDataBytes === undefined || this._rebuildRequired) {
+            this.validateTxData();
+            await this.populateTxData();
+            this.setGasDataOnTransaction();
+            this._txDataBytes = await this._iotaTransaction.build();
+            this._rebuildRequired = false;
+        }
+        this.serializeSignatures();
+        return this._txDataBytes;
+    }
+    /**
+     * Sets gas data on the IOTA transaction object.
+     */
+    setGasDataOnTransaction() {
+        this._iotaTransaction.setGasPrice(this.gasPrice);
+        this._iotaTransaction.setGasBudget(this.gasBudget);
+        this._iotaTransaction.setGasPayment(this.gasPaymentObjects.slice(0, constants_1.MAX_GAS_PAYMENT_OBJECTS - 1));
+    }
+    /**
+     * Populates the IOTA transaction with inputs, commands, and gas sponsor if applicable.
+     */
+    async populateTxData() {
+        this._iotaTransaction = new transactions_1.Transaction();
+        this.populateTxInputsAndCommands();
+        // If gas sponsor is different from sender, set up sponsored transaction
+        if (this.hasDifferentGasSponsor()) {
+            await this.setupGasSponsoredTransaction();
+        }
+        this._iotaTransaction.setSender(this.sender);
+    }
+    /**
+     * Checks if the transaction has a gas sponsor different from the sender.
+     */
+    hasDifferentGasSponsor() {
+        return Boolean(this.gasSponsor && this._sender !== this.gasSponsor);
+    }
+    /**
+     * Sets up a gas-sponsored transaction by building the transaction kind
+     * and setting the gas owner.
+     */
+    async setupGasSponsoredTransaction() {
+        const transactionKind = await this._iotaTransaction.build({ onlyTransactionKind: true });
+        this._iotaTransaction = transactions_1.Transaction.fromKind(transactionKind);
+        this._iotaTransaction.setGasOwner(this._gasSponsor);
+    }
+    /**
+     * Serializes a signature into IOTA's expected format.
+     * Format: [signature_scheme_flag (1 byte), signature, public_key]
+     * Currently hardcoded to EDDSA (0x00) as IOTA only supports this scheme.
+     */
+    serializeSignature(signature) {
+        const SIGNATURE_SCHEME_EDDSA = 0x00;
+        const pubKey = Buffer.from(signature.publicKey.pub, 'hex');
+        const serializedSignature = new Uint8Array(1 + signature.signature.length + pubKey.length);
+        serializedSignature.set([SIGNATURE_SCHEME_EDDSA]);
+        serializedSignature.set(signature.signature, 1);
+        serializedSignature.set(pubKey, 1 + signature.signature.length);
+        return (0, utils_1.toBase64)(serializedSignature);
+    }
+    /**
+     * Validates all transaction data required for a real (non-simulate) transaction.
+     */
+    validateTxData() {
+        this.validateTxDataImplementation();
+        this.validateCommonTxData();
+        this.validateSignatures();
+    }
+    /**
+     * Validates common transaction data (sender, gas data).
+     */
+    validateCommonTxData() {
+        if (!this.sender) {
+            throw new sdk_core_1.InvalidTransactionError('Transaction sender is required');
+        }
+        if (!this.gasPrice) {
+            throw new sdk_core_1.InvalidTransactionError('Gas price is required');
+        }
+        if (!this.gasBudget) {
+            throw new sdk_core_1.InvalidTransactionError('Gas budget is required');
+        }
+        if (!this.gasPaymentObjects || this.gasPaymentObjects.length === 0) {
+            throw new sdk_core_1.InvalidTransactionError('Gas payment objects are required');
+        }
+    }
+    /**
+     * Validates sender and gas sponsor signatures if present.
+     */
+    validateSignatures() {
+        if (this._signature && !this.isValidSignature(this._signature)) {
+            throw new sdk_core_1.InvalidTransactionError('Invalid sender signature');
+        }
+        if (this._gasSponsorSignature && !this.isValidSignature(this._gasSponsorSignature)) {
+            throw new sdk_core_1.InvalidTransactionError('Invalid gas sponsor signature');
+        }
     }
-    toBroadcastFormat() {
-        throw new Error('Method not implemented.');
+    /**
+     * Checks if a signature has valid public key and signature data.
+     */
+    isValidSignature(signature) {
+        return utils_2.default.isValidPublicKey(signature.publicKey.pub) && utils_2.default.isValidSignature((0, utils_1.toBase64)(signature.signature));
     }
 }
 exports.Transaction = Transaction;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3RyYW5zYWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1EQUFnRTtBQUdoRSxNQUFhLFdBQVksU0FBUSwwQkFBZTtJQUM5QyxPQUFPLENBQUMsR0FBWTtRQUNsQixNQUFNLElBQUksS0FBSyxDQUFDLHlCQUF5QixDQUFDLENBQUM7SUFDN0MsQ0FBQztJQUNELE1BQU07UUFDSixNQUFNLElBQUksS0FBSyxDQUFDLHlCQUF5QixDQUFDLENBQUM7SUFDN0MsQ0FBQztJQUNELGlCQUFpQjtRQUNmLE1BQU0sSUFBSSxLQUFLLENBQUMseUJBQXlCLENBQUMsQ0FBQztJQUM3QyxDQUFDO0NBQ0Y7QUFWRCxrQ0FVQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VLZXksIEJhc2VUcmFuc2FjdGlvbiB9IGZyb20gJ0BiaXRnby1iZXRhL3Nkay1jb3JlJztcbmltcG9ydCB7IFR4RGF0YSB9IGZyb20gJy4vaWZhY2UnO1xuXG5leHBvcnQgY2xhc3MgVHJhbnNhY3Rpb24gZXh0ZW5kcyBCYXNlVHJhbnNhY3Rpb24ge1xuICBjYW5TaWduKGtleTogQmFzZUtleSk6IGJvb2xlYW4ge1xuICAgIHRocm93IG5ldyBFcnJvcignTWV0aG9kIG5vdCBpbXBsZW1lbnRlZC4nKTtcbiAgfVxuICB0b0pzb24oKTogVHhEYXRhIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ01ldGhvZCBub3QgaW1wbGVtZW50ZWQuJyk7XG4gIH1cbiAgdG9Ccm9hZGNhc3RGb3JtYXQoKTogc3RyaW5nIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ01ldGhvZCBub3QgaW1wbGVtZW50ZWQuJyk7XG4gIH1cbn1cbiJdfQ==
+//# 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  PublicKey,\n  Signature,\n  TransactionRecipient,\n  TransactionType,\n} from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport {\n  TransactionData as IotaTransactionData,\n  Transaction as IotaTransaction,\n  TransactionDataBuilder as IotaTransactionDataBuilder,\n} from '@iota/iota-sdk/transactions';\nimport { TxData, TransactionObjectInput, TransactionExplanation } from './iface';\nimport { toBase64 } from '@iota/iota-sdk/utils';\nimport blake2b from '@bitgo-beta/blake2b';\nimport { MAX_GAS_BUDGET, MAX_GAS_PAYMENT_OBJECTS, MAX_GAS_PRICE } from './constants';\nimport utils from './utils';\n\n/**\n * Base class for IOTA transactions.\n * Manages transaction state, gas data, signatures, and building/serialization.\n */\nexport abstract class Transaction extends BaseTransaction {\n  // Transaction state management\n  protected _rebuildRequired: boolean;\n  protected _type: TransactionType;\n  protected _iotaTransaction: IotaTransaction;\n\n  // Gas and payment data\n  private _gasBudget?: number;\n  private _gasPaymentObjects?: TransactionObjectInput[];\n  private _gasPrice?: number;\n  private _gasSponsor?: string;\n\n  // Transaction identifiers and data\n  private _sender: string;\n  private _txDataBytes?: Uint8Array<ArrayBufferLike>;\n  private _isSimulateTx: boolean;\n\n  // Signature data\n  private _signature?: Signature;\n  private _serializedSignature?: string;\n  private _gasSponsorSignature?: Signature;\n  private _serializedGasSponsorSignature?: string;\n\n  protected constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._sender = '';\n    this._rebuildRequired = false;\n    this._isSimulateTx = true;\n  }\n\n  // Gas budget getter/setter - marks rebuild required when changed\n  get gasBudget(): number | undefined {\n    return this._gasBudget;\n  }\n\n  set gasBudget(value: number | undefined) {\n    this._gasBudget = value;\n    this.markRebuildRequired();\n  }\n\n  // Gas payment objects getter/setter - marks rebuild required when changed\n  get gasPaymentObjects(): TransactionObjectInput[] | undefined {\n    return this._gasPaymentObjects;\n  }\n\n  set gasPaymentObjects(value: TransactionObjectInput[] | undefined) {\n    this._gasPaymentObjects = value;\n    this.markRebuildRequired();\n  }\n\n  // Gas price getter/setter - marks rebuild required when changed\n  get gasPrice(): number | undefined {\n    return this._gasPrice;\n  }\n\n  set gasPrice(value: number | undefined) {\n    this._gasPrice = value;\n    this.markRebuildRequired();\n  }\n\n  // Gas sponsor getter/setter - marks rebuild required when changed\n  get gasSponsor(): string | undefined {\n    return this._gasSponsor;\n  }\n\n  set gasSponsor(value: string | undefined) {\n    this._gasSponsor = value;\n    this.markRebuildRequired();\n  }\n\n  // Transaction sender getter/setter - marks rebuild required when changed\n  get sender(): string {\n    return this._sender;\n  }\n\n  set sender(value: string) {\n    this._sender = value;\n    this.markRebuildRequired();\n  }\n\n  /**\n   * Indicates whether this is a simulate transaction (dry run) or a real transaction.\n   * Simulate transactions use maximum gas values for estimation purposes.\n   */\n  get isSimulateTx(): boolean {\n    return this._isSimulateTx;\n  }\n\n  set isSimulateTx(value: boolean) {\n    if (!value) {\n      this.validateTxDataForRealTransaction();\n      this.markRebuildRequired();\n    }\n    this._isSimulateTx = value;\n  }\n\n  /**\n   * Marks that the transaction needs to be rebuilt before it can be signed or broadcast.\n   */\n  private markRebuildRequired(): void {\n    this._rebuildRequired = true;\n  }\n\n  /**\n   * Validates transaction data when switching from simulate to real transaction mode.\n   */\n  private validateTxDataForRealTransaction(): void {\n    try {\n      this.validateTxData();\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : 'Unknown error';\n      throw new Error(`Tx data validation failed: ${errorMessage}. {Cause: ${error}}`);\n    }\n  }\n\n  /**\n   * Returns the signable payload for this transaction.\n   * This is the Blake2b hash of the transaction data with intent message.\n   * @throws Error if transaction is in simulate mode or not built\n   */\n  get signablePayload(): Buffer {\n    if (this.isSimulateTx) {\n      throw new Error('Cannot sign a simulate tx');\n    }\n    this.ensureTransactionIsBuilt();\n\n    const intentMessage = this.messageWithIntent(this._txDataBytes as Uint8Array<ArrayBufferLike>);\n    return Buffer.from(blake2b(32).update(intentMessage).digest('binary'));\n  }\n\n  /**\n   * Returns the transaction digest (ID).\n   * @throws Error if transaction is not built or needs rebuilding\n   */\n  get id(): string {\n    this.ensureTransactionIsBuilt();\n    return IotaTransactionDataBuilder.getDigestFromBytes(this._txDataBytes as Uint8Array<ArrayBufferLike>);\n  }\n\n  /**\n   * Ensures the transaction is built and doesn't need rebuilding.\n   * @throws Error if transaction is not built or rebuild is required\n   */\n  private ensureTransactionIsBuilt(): void {\n    if (this._txDataBytes === undefined || this._rebuildRequired) {\n      throw new Error('Tx not built or a rebuild is required');\n    }\n  }\n\n  /**\n   * Adds a signature from the transaction sender.\n   */\n  addSignature(publicKey: PublicKey, signature: Buffer): void {\n    this._signature = { publicKey, signature };\n  }\n\n  /**\n   * Adds a signature from the gas sponsor (if different from sender).\n   */\n  addGasSponsorSignature(publicKey: PublicKey, signature: Buffer): void {\n    this._gasSponsorSignature = { publicKey, signature };\n  }\n\n  /**\n   * Checks if this transaction can be signed.\n   * Only real transactions (not simulate) can be signed.\n   */\n  canSign(_key: BaseKey): boolean {\n    return !this.isSimulateTx;\n  }\n\n  /**\n   * Returns the transaction fee (gas budget).\n   */\n  getFee(): string | undefined {\n    return this.gasBudget?.toString();\n  }\n\n  get serializedGasSponsorSignature(): string | undefined {\n    return this._serializedGasSponsorSignature;\n  }\n\n  get serializedSignature(): string | undefined {\n    return this._serializedSignature;\n  }\n\n  /**\n   * Serializes all signatures for the transaction.\n   * Includes both sender signature and gas sponsor signature if present.\n   */\n  serializeSignatures(): void {\n    this._signatures = [];\n\n    if (this._signature) {\n      this._serializedSignature = this.serializeSignature(this._signature);\n      this._signatures.push(this._serializedSignature);\n    }\n\n    if (this._gasSponsorSignature) {\n      this._serializedGasSponsorSignature = this.serializeSignature(this._gasSponsorSignature);\n      this._signatures.push(this._serializedGasSponsorSignature);\n    }\n  }\n\n  /**\n   * Converts the transaction to broadcast format (base64 encoded).\n   */\n  async toBroadcastFormat(): Promise<string> {\n    const txDataBytes = await this.build();\n    return toBase64(txDataBytes);\n  }\n\n  /**\n   * Builds the transaction bytes.\n   * If in simulate mode, builds a dry run transaction with max gas values.\n   * Otherwise, builds a real transaction with actual gas data.\n   */\n  async build(): Promise<Uint8Array<ArrayBufferLike>> {\n    if (this.isSimulateTx) {\n      return this.buildDryRunTransaction();\n    }\n    return this.buildRealTransaction();\n  }\n\n  toJson(): TxData {\n    return {\n      sender: this.sender,\n      gasBudget: this.gasBudget,\n      gasPrice: this.gasPrice,\n      gasPaymentObjects: this.gasPaymentObjects,\n      gasSponsor: this.gasSponsor,\n      type: this.type,\n    };\n  }\n\n  parseFromJSON(txData: TxData): void {\n    this.sender = txData.sender;\n    this.gasBudget = txData.gasBudget;\n    this.gasPrice = txData.gasPrice;\n    this.gasPaymentObjects = txData.gasPaymentObjects;\n    if (txData.gasSponsor !== undefined) {\n      this.gasSponsor = txData.gasSponsor;\n    }\n  }\n\n  /**\n   * Parses transaction data from its broadcast format (base64 or raw bytes).\n   * Extracts sender, gas data, and gas sponsor information.\n   */\n  parseFromBroadcastTx(tx: string | Uint8Array): void {\n    const txData = IotaTransaction.from(tx).getData();\n\n    this.parseSender(txData);\n    this.parseGasData(txData);\n  }\n\n  /**\n   * Parses the sender address from transaction data.\n   */\n  private parseSender(txData: ReturnType<IotaTransaction['getData']>): void {\n    if (txData.sender) {\n      this.sender = txData.sender;\n    }\n  }\n\n  /**\n   * Parses gas-related data from transaction data.\n   */\n  private parseGasData(txData: ReturnType<IotaTransaction['getData']>): void {\n    const gasData = txData.gasData;\n\n    if (!gasData) {\n      this.gasBudget = undefined;\n      this.gasPrice = undefined;\n      this.gasPaymentObjects = undefined;\n      this.gasSponsor = undefined;\n      return;\n    }\n\n    this.gasBudget = gasData.budget ? Number(gasData.budget) : undefined;\n    this.gasPrice = gasData.price ? Number(gasData.price) : undefined;\n\n    this.gasPaymentObjects =\n      gasData.payment && gasData.payment.length > 0\n        ? gasData.payment.map((payment) => payment as TransactionObjectInput)\n        : undefined;\n\n    this.gasSponsor = gasData.owner || undefined;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  explainTransaction(): any {\n    const result = this.toJson();\n    const displayOrder = ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'type'];\n    const outputs: TransactionRecipient[] = [];\n\n    const explanationResult: TransactionExplanation = {\n      displayOrder,\n      id: this.id,\n      outputs,\n      outputAmount: '0',\n      changeOutputs: [],\n      changeAmount: '0',\n      fee: { fee: this.gasBudget ? this.gasBudget.toString() : '' },\n      sender: this.sender,\n      sponsor: this.gasSponsor,\n      type: this.type,\n    };\n\n    return this.explainTransactionImplementation(result, explanationResult);\n  }\n\n  /**\n   * Updates the simulate transaction flag based on gas data availability.\n   * If all gas data is present, switches to real transaction mode.\n   */\n  protected updateIsSimulateTx(): void {\n    const hasAllGasData =\n      this.gasBudget && this.gasPrice && this.gasPaymentObjects && this.gasPaymentObjects.length > 0;\n\n    this.isSimulateTx = !hasAllGasData;\n  }\n\n  // Abstract methods to be implemented by child classes\n  protected abstract messageWithIntent(message: Uint8Array): Uint8Array;\n  protected abstract populateTxInputsAndCommands(): void;\n  protected abstract validateTxDataImplementation(): void;\n  abstract addInputsAndOutputs(): void;\n  protected abstract explainTransactionImplementation(\n    json: TxData,\n    explanationResult: TransactionExplanation\n  ): TransactionExplanation;\n\n  /**\n   * Builds a dry run (simulate) transaction with maximum gas values.\n   * Used for gas estimation without committing the transaction.\n   */\n  private async buildDryRunTransaction(): Promise<Uint8Array<ArrayBufferLike>> {\n    this.validateTxDataImplementation();\n    await this.populateTxData();\n\n    const txDataBuilder = new IotaTransactionDataBuilder(this._iotaTransaction.getData() as IotaTransactionData);\n    return txDataBuilder.build({\n      overrides: {\n        gasData: {\n          budget: MAX_GAS_BUDGET.toString(),\n          price: MAX_GAS_PRICE.toString(),\n          payment: [],\n        },\n      },\n    });\n  }\n\n  /**\n   * Builds a real transaction with actual gas data.\n   * Only builds if necessary (first time or rebuild required).\n   */\n  private async buildRealTransaction(): Promise<Uint8Array<ArrayBufferLike>> {\n    if (this._txDataBytes === undefined || this._rebuildRequired) {\n      this.validateTxData();\n      await this.populateTxData();\n      this.setGasDataOnTransaction();\n      this._txDataBytes = await this._iotaTransaction.build();\n      this._rebuildRequired = false;\n    }\n\n    this.serializeSignatures();\n    return this._txDataBytes;\n  }\n\n  /**\n   * Sets gas data on the IOTA transaction object.\n   */\n  private setGasDataOnTransaction(): void {\n    this._iotaTransaction.setGasPrice(this.gasPrice!);\n    this._iotaTransaction.setGasBudget(this.gasBudget!);\n    this._iotaTransaction.setGasPayment(\n      this.gasPaymentObjects!.slice(0, MAX_GAS_PAYMENT_OBJECTS - 1) as TransactionObjectInput[]\n    );\n  }\n\n  /**\n   * Populates the IOTA transaction with inputs, commands, and gas sponsor if applicable.\n   */\n  private async populateTxData(): Promise<void> {\n    this._iotaTransaction = new IotaTransaction();\n    this.populateTxInputsAndCommands();\n\n    // If gas sponsor is different from sender, set up sponsored transaction\n    if (this.hasDifferentGasSponsor()) {\n      await this.setupGasSponsoredTransaction();\n    }\n\n    this._iotaTransaction.setSender(this.sender);\n  }\n\n  /**\n   * Checks if the transaction has a gas sponsor different from the sender.\n   */\n  private hasDifferentGasSponsor(): boolean {\n    return Boolean(this.gasSponsor && this._sender !== this.gasSponsor);\n  }\n\n  /**\n   * Sets up a gas-sponsored transaction by building the transaction kind\n   * and setting the gas owner.\n   */\n  private async setupGasSponsoredTransaction(): Promise<void> {\n    const transactionKind = await this._iotaTransaction.build({ onlyTransactionKind: true });\n    this._iotaTransaction = IotaTransaction.fromKind(transactionKind);\n    this._iotaTransaction.setGasOwner(this._gasSponsor!);\n  }\n\n  /**\n   * Serializes a signature into IOTA's expected format.\n   * Format: [signature_scheme_flag (1 byte), signature, public_key]\n   * Currently hardcoded to EDDSA (0x00) as IOTA only supports this scheme.\n   */\n  private serializeSignature(signature: Signature): string {\n    const SIGNATURE_SCHEME_EDDSA = 0x00;\n    const pubKey = Buffer.from(signature.publicKey.pub, 'hex');\n    const serializedSignature = new Uint8Array(1 + signature.signature.length + pubKey.length);\n\n    serializedSignature.set([SIGNATURE_SCHEME_EDDSA]);\n    serializedSignature.set(signature.signature, 1);\n    serializedSignature.set(pubKey, 1 + signature.signature.length);\n\n    return toBase64(serializedSignature);\n  }\n\n  /**\n   * Validates all transaction data required for a real (non-simulate) transaction.\n   */\n  private validateTxData(): void {\n    this.validateTxDataImplementation();\n    this.validateCommonTxData();\n    this.validateSignatures();\n  }\n\n  /**\n   * Validates common transaction data (sender, gas data).\n   */\n  private validateCommonTxData(): void {\n    if (!this.sender) {\n      throw new InvalidTransactionError('Transaction sender is required');\n    }\n\n    if (!this.gasPrice) {\n      throw new InvalidTransactionError('Gas price is required');\n    }\n\n    if (!this.gasBudget) {\n      throw new InvalidTransactionError('Gas budget is required');\n    }\n\n    if (!this.gasPaymentObjects || this.gasPaymentObjects.length === 0) {\n      throw new InvalidTransactionError('Gas payment objects are required');\n    }\n  }\n\n  /**\n   * Validates sender and gas sponsor signatures if present.\n   */\n  private validateSignatures(): void {\n    if (this._signature && !this.isValidSignature(this._signature)) {\n      throw new InvalidTransactionError('Invalid sender signature');\n    }\n\n    if (this._gasSponsorSignature && !this.isValidSignature(this._gasSponsorSignature)) {\n      throw new InvalidTransactionError('Invalid gas sponsor signature');\n    }\n  }\n\n  /**\n   * Checks if a signature has valid public key and signature data.\n   */\n  private isValidSignature(signature: Signature): boolean {\n    return utils.isValidPublicKey(signature.publicKey.pub) && utils.isValidSignature(toBase64(signature.signature));\n  }\n}\n"]}