@witnet/sdk 1.0.0-beta.0

package/dist/src/lib/crypto/transmitters.js

@@ -0,0 +1,416 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransmitterMultiSig = exports.Transmitter = void 0;
+const promisePoller = require('promise-poller').default;
+const protobufjs_1 = require("protobufjs");
+const protoRoot = protobufjs_1.Root.fromJSON(require("../../../witnet/witnet.proto.json"));
+const rpc_1 = require("../rpc");
+const utils_1 = require("../utils");
+const types_1 = require("./types");
+class Transmitter {
+    constructor(protoTypeName, payload, ledger, changePkh) {
+        this._signatures = [];
+        this._transactions = [];
+        this._protoBuf = protoRoot.lookupType(protoTypeName);
+        this._payload = payload;
+        this.ledger = ledger;
+        if (!ledger.provider.network) {
+            throw TypeError(`${this.constructor.name}: ledger's provider is not initialized.`);
+        }
+        this.changePkh = changePkh || ledger.changePkh;
+        if (!ledger.getSigner(this.changePkh)) {
+            throw TypeError(`${this.constructor.name}: ledger holds no Signer for change address ${this.changePkh}.`);
+        }
+    }
+    get payload() {
+        return this._payload.prepared ? this._payload : undefined;
+    }
+    get provider() {
+        return this.ledger.provider;
+    }
+    get network() {
+        return this.provider.network || "mainnet";
+    }
+    get transactions() {
+        return this._transactions;
+    }
+    get type() {
+        return this._payload.constructor.name.split(/([a-z](?=[A-Z]))/g).slice(0, -1).join("");
+    }
+    get _from() {
+        if (this._signatures.length > 0) {
+            return this._signatures
+                .map(ks => {
+                const pkh = types_1.PublicKey.fromProtobuf(ks.public_key).hash().toBech32(this.network);
+                return this.ledger.getSigner(pkh)?.pkh || this.ledger.pkh;
+            })
+                // avoid repetitions
+                .filter((pkh, index, array) => index === array.indexOf(pkh));
+        }
+        else {
+            return undefined;
+        }
+    }
+    get _prepared() {
+        return (this._payload.prepared
+            && !!this._signatures
+            && this._signatures.length > 0);
+    }
+    async sendTransaction(target) {
+        let receipt = this._getInflightReceipt();
+        if (!receipt || target) {
+            // if inflight not yet prepared, or prepared but not yet transmitted,
+            // prepare a new inflight either with specified params (if any),
+            // or previously prepared inflight (if known).
+            receipt = await this.signTransaction(target || receipt);
+        }
+        if (receipt?.status && receipt.status !== "signed" && !receipt?.error) {
+            // if current inflight was already transmitted and it's not yet known to fail ...
+            return receipt;
+        }
+        // if we reach this point is because an inflight transaction is 
+        // ready to be transmitted
+        rpc_1.JsonRpcProvider.receipts[receipt.hash].status = "pending";
+        delete rpc_1.JsonRpcProvider.receipts[receipt.hash].error;
+        return this.provider
+            .sendRawTransaction(this._toJSON(false))
+            .catch(err => {
+            const error = new types_1.TransmissionError(this._getInflightTransmission(), err);
+            rpc_1.JsonRpcProvider.receipts[receipt.hash].error = error;
+            throw error;
+        })
+            .then(accepted => {
+            if (accepted) {
+                rpc_1.JsonRpcProvider.receipts[receipt.hash].status = "relayed";
+                return rpc_1.JsonRpcProvider.receipts[receipt.hash];
+            }
+            else {
+                const error = new types_1.TransmissionError(this._getInflightTransmission(), Error(`Rejected for unknown reasons`));
+                rpc_1.JsonRpcProvider.receipts[receipt.hash].error = error;
+                throw error;
+            }
+        });
+    }
+    async signTransaction(target, reloadUtxos = false) {
+        target = await this._payload.validateTarget(target);
+        if (!target) {
+            // e.g. if called from this.send() with no params
+            throw TypeError(`${this.constructor.name}: cannot sign a transaction if no params were previously specified.`);
+        }
+        const inflight = this._getInflightReceipt();
+        if (inflight) {
+            // console.log("sign.pendingReceipt =>", inflight)
+            if (!inflight?.status || inflight.status === "signed") {
+                // recover input utxos if previously signed params were not even attempted to be sent
+                if (!reloadUtxos)
+                    this._recoverInputUtxos();
+            }
+            else if (inflight.status === "pending" && !inflight.error) {
+                // throw exception if a formerly signed transaction is still waiting to be relayed by a provider
+                throw Error(`${this.constructor.name}: in-flight tx being relayed: ${inflight.hash}`);
+            }
+        }
+        // clean current signatures, so new UTXOs can be consumed and therefore a new transaction hash be incepted
+        this._cleanSignatures(target);
+        // if not yet prepared, try to cover transaction expenses with existing utxos on signers:
+        if (!this._payload.prepared) {
+            await this._payload.consumeUtxos(this.ledger, reloadUtxos)
+                .catch((err) => {
+                throw Error(`${this.constructor.name}: cannot consume UTXOs from ${this.ledger.constructor.name} ${this.ledger.pkh}: ${err}.`);
+            });
+        }
+        if (!this._payload.prepared) {
+            // throws exeception if not enough utxos were found to cover transaction expenses:
+            throw Error(`${this.constructor.name}: insufficient funds on ${this.ledger.constructor.name} ${this.ledger.pkh}.`);
+        }
+        // double-check weight does not exceeds block limit...
+        if (this._payload.weight > this._payload.maxWeight) {
+            throw Error(`${this.constructor.name}: transaction weight exceeded block limit: ${this._payload.weight} > ${this._payload.maxWeight}.`);
+        }
+        // signing the transaction payload generates the transaction hash, and the receipt
+        return this._upsertTransactionReceipt(this._signTransactionPayload(), target, "signed");
+    }
+    async confirmTransaction(hash, options) {
+        let receipt = rpc_1.JsonRpcProvider.receipts[hash];
+        if (!receipt || receipt.hash !== hash) {
+            throw new Error(`${this.constructor.name}: transaction not found: ${hash}`);
+        }
+        else if (["signed", "pending"].includes(receipt.status)) {
+            throw new Error(`${this.constructor.name}: transaction status "${receipt.status}": ${hash}`);
+        }
+        else if (receipt.status === "removed") {
+            throw new types_1.MempoolError(receipt, `${this.constructor.name}: transaction removed from mempool: ${hash}`);
+        }
+        else if (receipt.status === "relayed" && options?.onStatusChange)
+            try {
+                options.onStatusChange(receipt);
+            }
+            catch { }
+        ;
+        const globalTimer = (start, ms) => {
+            return new Promise((_, reject) => {
+                setTimeout(() => reject(`${this.constructor.name}: polling timeout after ${Math.floor((Date.now() - start) / 1000)} secs).`), ms);
+            });
+        };
+        const [confirmations, interval, timeout, globalTimeout] = [
+            options?.confirmations || 0,
+            10000,
+            5000,
+            (options?.timeoutSecs || 600) * 1000,
+        ];
+        return Promise.race([
+            globalTimer(Date.now(), globalTimeout)
+                .catch((reason) => { throw new types_1.TimeoutError(globalTimeout, receipt, reason); }),
+            promisePoller({
+                taskFn: () => this.provider.getTransaction(hash),
+                shouldContinue: (error, report) => {
+                    const status = receipt.status;
+                    receipt.error = error;
+                    if (error instanceof Error && error.message.indexOf("not found") >= 0) {
+                        receipt.status = "removed";
+                    }
+                    else
+                        switch (receipt.status) {
+                            case "relayed":
+                                if (report?.blockHash && (0, utils_1.isHexString)(report.blockHash)) {
+                                    receipt.confirmations = report.confirmations;
+                                    receipt.blockHash = report.blockHash,
+                                        receipt.blockEpoch = report.blockEpoch,
+                                        receipt.blockTimestamp = report.blockTimestamp;
+                                    receipt.status = (report.confirmed
+                                        ? "finalized"
+                                        : (report?.confirmations >= confirmations ? "confirmed" : "mined"));
+                                }
+                                break;
+                            case "mined":
+                                if (!report?.blockHash || report.blockHash !== receipt.blockHash) {
+                                    delete receipt.blockHash;
+                                    delete receipt.blockEpoch;
+                                    delete receipt.blockMiner;
+                                    delete receipt.blockTimestamp;
+                                    receipt.status = "relayed";
+                                }
+                                else {
+                                    receipt.status = (report.confirmed
+                                        ? "finalized"
+                                        : (report?.confirmations >= confirmations ? "confirmed" : "mined"));
+                                    if (report.confirmations !== receipt.confirmations) {
+                                        receipt.confirmations = report.confirmations;
+                                        if (receipt.status === "mined" && options?.onCheckpoint)
+                                            try {
+                                                options.onCheckpoint(receipt);
+                                            }
+                                            catch { }
+                                        ;
+                                    }
+                                }
+                                break;
+                        }
+                    ;
+                    if (status !== receipt.status) {
+                        receipt.timestamp = Math.floor(Date.now() / 1000);
+                        if (!["confirmed", "finalized"].includes(receipt.status) && options?.onStatusChange)
+                            try {
+                                options.onStatusChange(receipt);
+                            }
+                            catch { }
+                        ;
+                    }
+                    rpc_1.JsonRpcProvider.receipts[hash] = receipt;
+                    return ["relayed", "mined"].includes(receipt.status);
+                },
+                interval, timeout,
+            }).then(async () => {
+                if (receipt.status === "removed" && receipt.type !== "Unstake") {
+                    // TRANSACTION REMOVED FROM MEMPOOL //
+                    // 1. Try to recover input utxos belonging to ledger's addresses:
+                    try {
+                        const inputs = receipt.tx[receipt.type].body.inputs;
+                        const signatures = receipt.tx[receipt.type].signatures;
+                        const utxos = [];
+                        if (inputs.length === signatures.length) {
+                            inputs.forEach((metadata, index) => ({
+                                ...metadata,
+                                signer: types_1.PublicKey.fromProtobuf(signatures[index].public_key).hash().toBech32(this.network),
+                            }));
+                        }
+                        this.ledger.addUtxos(...utxos);
+                    }
+                    catch (err) {
+                        console.error(`${this.constructor.name}: warning: cannot recover input UTXOS from tx ${hash}: ${err}`);
+                    }
+                    // 2. Throw MempoolError
+                    throw new types_1.MempoolError(receipt, `${this.constructor.name}: transaction removed from mempool: ${hash}`);
+                }
+                else {
+                    // TRANSACTION EITHER CONFIRMED OR FINALIZED //
+                    // 1. Try to load value transfer outputs into the ledger's local cache: 
+                    try {
+                        const utxos = [];
+                        if (["Stake", "Unstake"].includes(receipt.type)) {
+                            let vto = (receipt.type === "Stake"
+                                ? receipt.tx[receipt.type].body?.output
+                                : receipt.tx[receipt.type].body?.withdrawal);
+                            if (vto) {
+                                utxos.push({
+                                    output_pointer: `${receipt.hash}:0`,
+                                    timelock: vto.time_lock,
+                                    utxo_mature: true,
+                                    value: vto.value,
+                                    signer: vto.pkh,
+                                });
+                            }
+                        }
+                        else {
+                            const outputs = receipt.tx[receipt.type].body?.outputs || [];
+                            outputs.forEach((vto, index) => utxos.push({
+                                output_pointer: `${receipt.hash}:${index}`,
+                                timelock: vto.time_lock,
+                                utxo_mature: true,
+                                value: vto.value,
+                                signer: vto.pkh,
+                            }));
+                        }
+                        // console.log("output utxos before =>", utxos)
+                        // console.log("output utxos after  =>", this.ledger.addUtxos(...utxos))
+                        this.ledger.addUtxos(...utxos);
+                    }
+                    catch (err) {
+                        console.error(`${this.constructor.name}: warning: cannot recover output UTXOs from ${hash}: ${err}`);
+                    }
+                    // 2. Add blockMiner address to the transaction receipt: 
+                    if (receipt?.blockHash && (0, utils_1.isHexString)(receipt.blockHash)) {
+                        const block = await this.provider.getBlock(receipt.blockHash || "");
+                        rpc_1.JsonRpcProvider.receipts[hash].blockMiner = types_1.PublicKey
+                            .fromProtobuf(block.block_sig.public_key)
+                            .hash()
+                            .toBech32(this.network);
+                    }
+                    if (options?.onStatusChange)
+                        try {
+                            options.onStatusChange(receipt);
+                        }
+                        catch { }
+                    ;
+                    // 3. Return transaction receipt:
+                    return rpc_1.JsonRpcProvider.receipts[hash];
+                }
+            })
+        ]);
+    }
+    _cleanSignatures(newTarget) {
+        this._payload.resetTarget(newTarget);
+        this._signatures = [];
+    }
+    _getInflightBytecode() {
+        const obj = this._toProtobuf();
+        const err = this._protoBuf.verify(obj);
+        if (!err) {
+            const message = this._protoBuf.fromObject(obj);
+            return this._protoBuf.encode(message).finish();
+        }
+        else {
+            return undefined;
+        }
+    }
+    _getInflightReceipt() {
+        const hash = this._payload.hash;
+        if (hash) {
+            return rpc_1.JsonRpcProvider.receipts[hash];
+        }
+        else {
+            return undefined;
+        }
+    }
+    _getInflightTransmission() {
+        return {
+            bytecode: this._getInflightBytecode(),
+            hash: this._payload.hash,
+            message: this._toJSON(true),
+        };
+    }
+    _recoverInputUtxos() { }
+    _recoverOutputUtxos() { }
+    _upsertTransactionReceipt(hash, target, status) {
+        rpc_1.JsonRpcProvider.receipts[hash] = {
+            ...this._payload.intoReceipt(target, this.network),
+            hash,
+            change: this._payload.change,
+            fees: this._payload.fees,
+            from: this._from,
+            status,
+            timestamp: Math.floor(Date.now() / 1000),
+            tx: this._toJSON(true),
+            type: this.type,
+            value: this._payload.value,
+            weight: this._payload.weight,
+        };
+        return rpc_1.JsonRpcProvider.receipts[hash];
+    }
+}
+exports.Transmitter = Transmitter;
+class TransmitterMultiSig extends Transmitter {
+    constructor(protoTypeName, payload, ledger, changePkh) {
+        super(protoTypeName, payload, ledger, changePkh);
+        this._payload = payload;
+    }
+    /// Recover formerly consumed UTXOs by a failing transaction back to their respective signer's UTXO pool
+    _recoverInputUtxos() {
+        if (this._payload.inputs) {
+            this.ledger.addUtxos(...this._payload.inputs);
+        }
+    }
+    /// Recover self-targeted outputs as expendable utxos on their respective signer's memoized cache
+    _recoverOutputUtxos() {
+        if (this._payload.hash && this._payload.outputs) {
+            const utxos = [];
+            this._payload.outputs.forEach((vto, index) => {
+                if (this.ledger.getSigner(vto.pkh))
+                    utxos.push({
+                        signer: vto.pkh,
+                        output_pointer: `${this._payload.hash}:${index}`,
+                        timelock: vto.time_lock,
+                        value: vto.value,
+                    });
+            });
+            this.ledger.addUtxos(...utxos);
+        }
+    }
+    _signTransactionPayload() {
+        const hash = this._payload.hash;
+        if (!hash) {
+            throw Error(`${this.constructor.name}: internal error: unable to hashify payload: ${this._payload.toJSON(true, this.network)}}.`);
+        }
+        else {
+            this._payload.inputs.forEach(utxo => {
+                const signer = this.ledger.getSigner(utxo.signer);
+                if (!signer)
+                    throw Error(`${this.constructor.name}: internal error: cannot find Signer ${utxo.signer} in ${this.ledger.constructor.name} ${this.ledger.pkh}.`);
+                else {
+                    // console.log(`...signer ${signer.pkh} signing hash ${hash}...`)
+                    this._signatures.push(signer.signHash(hash));
+                }
+            });
+            return hash;
+        }
+    }
+    _toJSON(humanize) {
+        return {
+            [this.type]: {
+                body: this._payload.toJSON(humanize, this.network),
+                signatures: this._signatures,
+            },
+        };
+    }
+    _toProtobuf() {
+        const body = this._payload.toProtobuf();
+        if (body && this._signatures) {
+            return {
+                body,
+                signatures: this._signatures,
+            };
+        }
+    }
+}
+exports.TransmitterMultiSig = TransmitterMultiSig;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transmitters.js","sourceRoot":"","sources":["../../../../src/lib/crypto/transmitters.ts"],"names":[],"mappings":"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","sourcesContent":["const promisePoller = require('promise-poller').default;\r\n\r\nimport { Root as ProtoRoot, Type as ProtoType } from \"protobufjs\"\r\nconst protoRoot = ProtoRoot.fromJSON(require(\"../../../witnet/witnet.proto.json\")) \r\n\r\nimport { TransactionReport, UtxoMetadata, ValueTransferOutput } from \"../rpc/types\"\r\nimport { JsonRpcProvider } from \"../rpc\"\r\nimport { Hash, Network } from \"../types\"\r\nimport { isHexString } from \"../utils\";\r\n\r\nimport { \r\n    ILedger,\r\n    IJsonRpcProvider, \r\n    ITransmitter, \r\n    ITransactionPayload, \r\n    ITransactionPayloadMultiSig, \r\n} from \"./interfaces\"\r\n\r\nimport { \r\n    KeyedSignature, \r\n    PublicKey, \r\n    PublicKeyHashString, \r\n    MempoolError,\r\n    TransactionCallback, \r\n    TransactionReceipt, \r\n    TransactionStatus, \r\n    TimeoutError,\r\n    Transmission,\r\n    TransmissionError,\r\n    Utxo,\r\n} from \"./types\"\r\n\r\nexport abstract class Transmitter<Specs, Payload extends ITransactionPayload<Specs>> implements ITransmitter {\r\n    \r\n    public readonly ledger: ILedger;\r\n    public readonly changePkh: PublicKeyHashString;\r\n    \r\n    protected _payload: Payload;\r\n    protected _protoBuf: ProtoType;\r\n    protected _signatures: Array<KeyedSignature> = []\r\n    protected _transactions: Array<Hash> = []\r\n\r\n    constructor (protoTypeName: string, payload: Payload, ledger: ILedger, changePkh?: PublicKeyHashString) {\r\n        this._protoBuf = protoRoot.lookupType(protoTypeName)\r\n        this._payload = payload;\r\n        this.ledger = ledger\r\n        if (!ledger.provider.network) {\r\n            throw TypeError(`${this.constructor.name}: ledger's provider is not initialized.`)\r\n        }\r\n        this.changePkh = changePkh || ledger.changePkh\r\n        if (!ledger.getSigner(this.changePkh)) {\r\n            throw TypeError(`${this.constructor.name}: ledger holds no Signer for change address ${this.changePkh}.`)\r\n        }\r\n    }\r\n\r\n    public get payload(): Payload | undefined {\r\n        return this._payload.prepared ? this._payload : undefined\r\n    }\r\n\r\n    public get provider(): IJsonRpcProvider {\r\n        return this.ledger.provider\r\n    }\r\n\r\n    public get network(): Network {\r\n        return this.provider.network || \"mainnet\"\r\n    }\r\n\r\n    public get transactions(): Array<Hash> {\r\n        return this._transactions\r\n    }\r\n\r\n    public get type(): string {\r\n        return this._payload.constructor.name.split(/([a-z](?=[A-Z]))/g).slice(0, -1).join(\"\")\r\n    }\r\n\r\n    protected get _from(): Array<PublicKeyHashString> | undefined {\r\n        if (this._signatures.length > 0) {\r\n            return this._signatures\r\n                .map(ks => {\r\n                    const pkh = PublicKey.fromProtobuf(ks.public_key).hash().toBech32(this.network)\r\n                    return this.ledger.getSigner(pkh)?.pkh || this.ledger.pkh\r\n                })\r\n                // avoid repetitions\r\n                .filter((pkh, index, array) => index === array.indexOf(pkh))\r\n        \r\n        } else {\r\n            return undefined\r\n        }\r\n    }\r\n\r\n    protected get _prepared(): boolean {\r\n        return (\r\n            this._payload.prepared\r\n                && !!this._signatures\r\n                && this._signatures.length > 0\r\n        )\r\n    }\r\n\r\n    public async sendTransaction(target?: any): Promise<TransactionReceipt> {\r\n        let receipt = this._getInflightReceipt()\r\n        if (!receipt || target) {\r\n            // if inflight not yet prepared, or prepared but not yet transmitted,\r\n            // prepare a new inflight either with specified params (if any),\r\n            // or previously prepared inflight (if known).\r\n            receipt = await this.signTransaction(target || receipt)\r\n        }\r\n        if (receipt?.status && receipt.status !== \"signed\" && !receipt?.error) {\r\n            // if current inflight was already transmitted and it's not yet known to fail ...\r\n            return receipt\r\n        }\r\n        // if we reach this point is because an inflight transaction is \r\n        // ready to be transmitted\r\n        JsonRpcProvider.receipts[receipt.hash].status = \"pending\"\r\n        delete JsonRpcProvider.receipts[receipt.hash].error\r\n        return this.provider\r\n            .sendRawTransaction(this._toJSON(false))\r\n            .catch(err => {\r\n                const error = new TransmissionError(this._getInflightTransmission(), err)\r\n                JsonRpcProvider.receipts[receipt.hash].error = error\r\n                throw error\r\n            })\r\n            .then(accepted => {\r\n                if (accepted) {\r\n                    JsonRpcProvider.receipts[receipt.hash].status = \"relayed\"\r\n                    return JsonRpcProvider.receipts[receipt.hash]\r\n                    \r\n                } else {\r\n                    const error = new TransmissionError(this._getInflightTransmission(), Error(`Rejected for unknown reasons`))\r\n                    JsonRpcProvider.receipts[receipt.hash].error = error\r\n                    throw error\r\n                }\r\n            })\r\n    }\r\n\r\n    public async signTransaction(target?: Specs, reloadUtxos = false): Promise<TransactionReceipt> {\r\n        target = await this._payload.validateTarget(target)\r\n        if (!target) {\r\n            // e.g. if called from this.send() with no params\r\n            throw TypeError(`${this.constructor.name}: cannot sign a transaction if no params were previously specified.`)\r\n        }\r\n        \r\n        const inflight = this._getInflightReceipt()\r\n        if (inflight) {\r\n            // console.log(\"sign.pendingReceipt =>\", inflight)\r\n            if (!inflight?.status || inflight.status === \"signed\") {\r\n                // recover input utxos if previously signed params were not even attempted to be sent\r\n                if (!reloadUtxos) this._recoverInputUtxos()\r\n            \r\n            } else if (inflight.status === \"pending\" && !inflight.error) {\r\n                // throw exception if a formerly signed transaction is still waiting to be relayed by a provider\r\n                throw Error(`${this.constructor.name}: in-flight tx being relayed: ${inflight.hash}`)\r\n            }\r\n        } \r\n        \r\n        // clean current signatures, so new UTXOs can be consumed and therefore a new transaction hash be incepted\r\n        this._cleanSignatures(target)\r\n        \r\n        // if not yet prepared, try to cover transaction expenses with existing utxos on signers:\r\n        if (!this._payload.prepared) {\r\n            await this._payload.consumeUtxos(this.ledger, reloadUtxos)\r\n            .catch((err: any) => {\r\n                throw Error(\r\n                    `${this.constructor.name}: cannot consume UTXOs from ${this.ledger.constructor.name} ${this.ledger.pkh}: ${err}.`\r\n                )\r\n            })  \r\n        }\r\n        \r\n        if (!this._payload.prepared) {\r\n            // throws exeception if not enough utxos were found to cover transaction expenses:\r\n            throw Error(\r\n                `${this.constructor.name}: insufficient funds on ${this.ledger.constructor.name} ${this.ledger.pkh}.`\r\n            )\r\n        } \r\n\r\n        // double-check weight does not exceeds block limit...\r\n        if (this._payload.weight > this._payload.maxWeight) {\r\n            throw Error(\r\n                `${this.constructor.name}: transaction weight exceeded block limit: ${this._payload.weight} > ${this._payload.maxWeight}.`\r\n            )\r\n        }\r\n\r\n        // signing the transaction payload generates the transaction hash, and the receipt\r\n        return this._upsertTransactionReceipt(this._signTransactionPayload(), target, \"signed\")    \r\n    }\r\n\r\n    public async confirmTransaction(\r\n        hash: Hash, \r\n        options?: {\r\n            confirmations?: number,\r\n            timeoutSecs?: number,\r\n            onCheckpoint?: TransactionCallback,\r\n            onStatusChange?: TransactionCallback,\r\n        }\r\n    ): Promise<TransactionReceipt> {\r\n\r\n        let receipt = JsonRpcProvider.receipts[hash]\r\n        if (!receipt || receipt.hash !== hash) {\r\n            throw new Error(`${this.constructor.name}: transaction not found: ${hash}`)\r\n        \r\n        } else if ([\"signed\", \"pending\"].includes(receipt.status)) {\r\n            throw new Error(`${this.constructor.name}: transaction status \"${receipt.status}\": ${hash}`)\r\n        \r\n        } else if (receipt.status === \"removed\") {\r\n            throw new MempoolError(receipt, `${this.constructor.name}: transaction removed from mempool: ${hash}`)\r\n        \r\n        } else if (receipt.status === \"relayed\" && options?.onStatusChange) try {\r\n            options.onStatusChange(receipt)\r\n        } catch {};\r\n\r\n        const globalTimer = (start: number, ms: number) => {\r\n            return new Promise((_, reject) => {\r\n                setTimeout(\r\n                    () => reject(`${this.constructor.name}: polling timeout after ${Math.floor((Date.now() - start) / 1000)} secs).`), \r\n                    ms\r\n                );\r\n            });\r\n        }\r\n\r\n        const [confirmations, interval, timeout, globalTimeout] = [\r\n            options?.confirmations || 0,\r\n            10000,\r\n            5000,\r\n            (options?.timeoutSecs || 600) * 1000,\r\n        ];\r\n\r\n        return Promise.race([\r\n            globalTimer(Date.now(), globalTimeout)\r\n                .catch((reason: any) => { throw new TimeoutError(globalTimeout, receipt, reason) }),\r\n            \r\n            promisePoller({\r\n                taskFn: () => this.provider.getTransaction(hash),\r\n                shouldContinue: (error: any, report: TransactionReport) => {\r\n                    const status = receipt.status\r\n                    receipt.error = error\r\n                    if (error instanceof Error && error.message.indexOf(\"not found\") >= 0) {\r\n                        receipt.status = \"removed\"\r\n                    \r\n                    } else switch (receipt.status) {\r\n                        case \"relayed\":\r\n                            if (report?.blockHash && isHexString(report.blockHash)) {\r\n                                receipt.confirmations = report.confirmations\r\n                                receipt.blockHash = report.blockHash,\r\n                                receipt.blockEpoch = report.blockEpoch,\r\n                                receipt.blockTimestamp = report.blockTimestamp\r\n                                receipt.status = (\r\n                                    report.confirmed \r\n                                        ? \"finalized\" \r\n                                        : (report?.confirmations >= confirmations ? \"confirmed\" : \"mined\")\r\n                                );\r\n                            }\r\n                            break;\r\n\r\n                        case \"mined\":\r\n                            if (!report?.blockHash || report.blockHash !== receipt.blockHash) {\r\n                                delete receipt.blockHash\r\n                                delete receipt.blockEpoch\r\n                                delete receipt.blockMiner\r\n                                delete receipt.blockTimestamp\r\n                                receipt.status = \"relayed\"\r\n                            \r\n                            } else {\r\n                                receipt.status = (\r\n                                    report.confirmed \r\n                                        ? \"finalized\" \r\n                                        : (report?.confirmations >= confirmations ? \"confirmed\" : \"mined\")\r\n                                );\r\n                                if (report.confirmations !== receipt.confirmations) {    \r\n                                    receipt.confirmations = report.confirmations\r\n                                    if (receipt.status === \"mined\" && options?.onCheckpoint) try {\r\n                                        options.onCheckpoint(receipt)\r\n                                    } catch {};\r\n                                }\r\n                            }\r\n                            break;\r\n                    };\r\n\r\n                    if (status !== receipt.status) {\r\n                        receipt.timestamp = Math.floor(Date.now() / 1000) \r\n                        if (![\"confirmed\", \"finalized\"].includes(receipt.status) && options?.onStatusChange) try {\r\n                            options.onStatusChange(receipt)\r\n                        } catch {};\r\n                    }\r\n                    JsonRpcProvider.receipts[hash] = receipt\r\n                    return [\"relayed\", \"mined\"].includes(receipt.status)\r\n                },\r\n                interval, timeout, \r\n            \r\n            }).then(async () => {\r\n                if (receipt.status === \"removed\" && receipt.type !== \"Unstake\") {\r\n                    // TRANSACTION REMOVED FROM MEMPOOL //\r\n                    // 1. Try to recover input utxos belonging to ledger's addresses:\r\n                    try {\r\n                        const inputs: Array<UtxoMetadata> = receipt.tx[receipt.type].body.inputs\r\n                        const signatures: Array<KeyedSignature> = receipt.tx[receipt.type].signatures\r\n                        const utxos: Array<Utxo> = []\r\n                        if (inputs.length === signatures.length) {\r\n                            inputs.forEach((metadata, index) => ({\r\n                                ...metadata,\r\n                                signer: PublicKey.fromProtobuf(signatures[index].public_key).hash().toBech32(this.network),\r\n                            }))\r\n                        }\r\n                        this.ledger.addUtxos(...utxos)\r\n                    } catch (err) {\r\n                        console.error(`${this.constructor.name}: warning: cannot recover input UTXOS from tx ${hash}: ${err}`)\r\n                    }\r\n                    // 2. Throw MempoolError\r\n                    throw new MempoolError(receipt, `${this.constructor.name}: transaction removed from mempool: ${hash}`);\r\n                \r\n                } else {\r\n                    // TRANSACTION EITHER CONFIRMED OR FINALIZED //\r\n                    // 1. Try to load value transfer outputs into the ledger's local cache: \r\n                    try {\r\n                        const utxos: Array<Utxo> = []\r\n                        if ([\"Stake\", \"Unstake\"].includes(receipt.type)) {\r\n                            let vto: ValueTransferOutput = (\r\n                                receipt.type === \"Stake\"\r\n                                    ? receipt.tx[receipt.type].body?.output\r\n                                    : receipt.tx[receipt.type].body?.withdrawal\r\n                            );\r\n                            if (vto) {\r\n                                utxos.push({\r\n                                    output_pointer: `${receipt.hash}:0`,\r\n                                    timelock: vto.time_lock,\r\n                                    utxo_mature: true,\r\n                                    value: vto.value,\r\n                                    signer: vto.pkh,\r\n                                })\r\n                            }\r\n                        } else {\r\n                            const outputs: Array<ValueTransferOutput> = receipt.tx[receipt.type].body?.outputs || []\r\n                            outputs.forEach((vto, index) => utxos.push({\r\n                                output_pointer: `${receipt.hash}:${index}`,\r\n                                timelock: vto.time_lock,\r\n                                utxo_mature: true,\r\n                                value: vto.value,\r\n                                signer: vto.pkh,\r\n                            }))\r\n                        }\r\n                        // console.log(\"output utxos before =>\", utxos)\r\n                        // console.log(\"output utxos after  =>\", this.ledger.addUtxos(...utxos))\r\n                        this.ledger.addUtxos(...utxos)\r\n                    } catch (err) {\r\n                        console.error(`${this.constructor.name}: warning: cannot recover output UTXOs from ${hash}: ${err}`)\r\n                    }\r\n                    // 2. Add blockMiner address to the transaction receipt: \r\n                    if (receipt?.blockHash && isHexString(receipt.blockHash)) {\r\n                        const block = await this.provider.getBlock(receipt.blockHash || \"\")\r\n                        JsonRpcProvider.receipts[hash].blockMiner = PublicKey\r\n                            .fromProtobuf(block.block_sig.public_key)\r\n                            .hash()\r\n                            .toBech32(this.network);\r\n                    }\r\n                    if (options?.onStatusChange) try {\r\n                        options.onStatusChange(receipt)\r\n                    } catch {};\r\n                    // 3. Return transaction receipt:\r\n                    return JsonRpcProvider.receipts[hash]\r\n                }\r\n            })\r\n        ])\r\n    }\r\n\r\n    protected _cleanSignatures(newTarget: Specs): any {\r\n        this._payload.resetTarget(newTarget)\r\n        this._signatures = []\r\n    }\r\n\r\n    protected _getInflightBytecode(): Uint8Array | undefined {\r\n        const obj = this._toProtobuf()\r\n        const err = this._protoBuf.verify(obj)\r\n        if (!err) {\r\n            const message = this._protoBuf.fromObject(obj)\r\n            return this._protoBuf.encode(message).finish()\r\n        } else {\r\n            return undefined\r\n        }\r\n    }\r\n\r\n    protected _getInflightReceipt(): TransactionReceipt | undefined {\r\n        const hash = this._payload.hash\r\n        if (hash) {\r\n            return JsonRpcProvider.receipts[hash]\r\n        } else {\r\n            return undefined\r\n        }\r\n    }\r\n\r\n    protected _getInflightTransmission(): Transmission {\r\n        return {\r\n            bytecode: this._getInflightBytecode(),\r\n            hash: this._payload.hash,\r\n            message: this._toJSON(true),\r\n        }\r\n    }\r\n\r\n    protected _recoverInputUtxos(): any {}\r\n    protected _recoverOutputUtxos(): any {}\r\n\r\n    protected _upsertTransactionReceipt(hash: Hash, target: Specs, status: TransactionStatus): TransactionReceipt {\r\n        JsonRpcProvider.receipts[hash] = {\r\n            ...this._payload.intoReceipt(target, this.network),\r\n            hash,\r\n            change: this._payload.change,\r\n            fees: this._payload.fees,\r\n            from: this._from,\r\n            status,\r\n            timestamp: Math.floor(Date.now() / 1000),\r\n            tx: this._toJSON(true),\r\n            type: this.type,\r\n            value: this._payload.value,\r\n            weight: this._payload.weight,\r\n        }\r\n        return JsonRpcProvider.receipts[hash]\r\n    }\r\n\r\n    protected abstract _signTransactionPayload(): Hash;\r\n    protected abstract _toJSON(_humanize: boolean): any;\r\n    protected abstract _toProtobuf(): any;\r\n}\r\n\r\n\r\nexport abstract class TransmitterMultiSig<Specs, Payload extends ITransactionPayloadMultiSig<Specs>> \r\n    extends Transmitter<Specs, Payload> \r\n{\r\n    constructor (protoTypeName: string, payload: Payload, ledger: ILedger, changePkh?: PublicKeyHashString) {\r\n        super(protoTypeName, payload, ledger, changePkh)\r\n        this._payload = payload;\r\n    }\r\n\r\n    /// Recover formerly consumed UTXOs by a failing transaction back to their respective signer's UTXO pool\r\n    protected _recoverInputUtxos(): any {\r\n        if (this._payload.inputs) {    \r\n            this.ledger.addUtxos(...this._payload.inputs)\r\n        }\r\n    }\r\n\r\n    /// Recover self-targeted outputs as expendable utxos on their respective signer's memoized cache\r\n    protected _recoverOutputUtxos(): any {\r\n        if (this._payload.hash && this._payload.outputs) {\r\n            const utxos: Array<Utxo> = []\r\n            this._payload.outputs.forEach((vto, index) => {    \r\n                if (this.ledger.getSigner(vto.pkh)) utxos.push({\r\n                    signer: vto.pkh,\r\n                    output_pointer: `${this._payload.hash}:${index}`,\r\n                    timelock: vto.time_lock,\r\n                    value: vto.value,\r\n                })\r\n            })\r\n            this.ledger.addUtxos(...utxos)\r\n        }\r\n    }\r\n\r\n    protected _signTransactionPayload(): Hash {\r\n        const hash = this._payload.hash\r\n        if (!hash) {\r\n            throw Error(\r\n                `${this.constructor.name}: internal error: unable to hashify payload: ${this._payload.toJSON(true, this.network)}}.`\r\n            )\r\n        } else {\r\n            this._payload.inputs.forEach(utxo => { \r\n                const signer = this.ledger.getSigner(utxo.signer)\r\n                if (!signer) throw Error(\r\n                    `${this.constructor.name}: internal error: cannot find Signer ${utxo.signer} in ${this.ledger.constructor.name} ${this.ledger.pkh}.`    \r\n                ); else {\r\n                    // console.log(`...signer ${signer.pkh} signing hash ${hash}...`)\r\n                    this._signatures.push(signer.signHash(hash)) \r\n                }\r\n            })\r\n            return hash\r\n        }\r\n    }\r\n\r\n    protected _toJSON(humanize: boolean): any {\r\n        return { \r\n            [this.type]: { \r\n                body: this._payload.toJSON(humanize, this.network),\r\n                signatures: this._signatures,\r\n            },\r\n        }\r\n    }\r\n\r\n    protected _toProtobuf(): any {\r\n        const body = this._payload.toProtobuf()\r\n        if (body && this._signatures) {\r\n            return {\r\n                body,\r\n                signatures: this._signatures,\r\n            }\r\n        }\r\n    }\r\n}\r\n"]}