@xchainjs/xchain-thorchain-query 0.1.13 → 0.1.14

package/lib/index.esm.js

@@ -655,35 +655,6 @@ const getChainAsset = (chain) => {
         default:
             throw Error('Unknown chain');
     }
-};
-/**
- *
- * @param chain - input chain string
- * @returns - returns correct chain from string
- */
-const getChain = (chain) => {
-    switch (chain) {
-        case 'AVAX':
-            return AVAXChain;
-        case 'BNB':
-            return BNBChain;
-        case 'BTC':
-            return BTCChain;
-        case 'ETH':
-            return ETHChain;
-        case 'THOR':
-            return THORChain;
-        case 'GAIA':
-            return GAIAChain;
-        case 'BCH':
-            return BCHChain;
-        case 'LTC':
-            return LTCChain;
-        case 'DOGE':
-            return DOGEChain;
-        default:
-            throw Error('Unknown chain');
-    }
 };
 
 const defaultThornodeConfig = {
@@ -758,6 +729,25 @@ class Thornode {
             throw new Error(`THORNode not responding`);
         });
     }
+    /**
+     *
+     * @param txHash - transaction hash
+     * @returns - transaction object
+     */
+    getTxDetail(txHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.transactionsApi) {
+                try {
+                    const txResponse = yield api.txSigners(txHash);
+                    return txResponse.data;
+                }
+                catch (e) {
+                    throw new Error(`THORNode not responding`);
+                }
+            }
+            throw new Error(`THORNode not responding`);
+        });
+    }
     /**
      *
      * @param height - optional thorchain height only
@@ -2240,186 +2230,388 @@ class ThorchainQuery {
     }
 }
 
+var TxType;
+(function (TxType) {
+    TxType["Swap"] = "Swap";
+    TxType["AddLP"] = "AddLP";
+    TxType["WithdrawLP"] = "WithdrawLP";
+    TxType["AddSaver"] = "AddSaver";
+    TxType["WithdrawSaver"] = "WithdrawSaver";
+    TxType["Other"] = "Other";
+    TxType["Unknown"] = "Unknown";
+})(TxType || (TxType = {}));
+var InboundStatus;
+(function (InboundStatus) {
+    InboundStatus["Observed_Consensus"] = "Observed_Consensus";
+    InboundStatus["Observed_Incomplete"] = "Observed_Incomplete";
+    InboundStatus["Unknown"] = "Unknown";
+})(InboundStatus || (InboundStatus = {}));
+var SwapStatus;
+(function (SwapStatus) {
+    SwapStatus["Complete"] = "Complete";
+    SwapStatus["Complete_Refunded"] = "Complete_Refunded";
+    SwapStatus["Complete_Below_Dust"] = "Complete_Below_Dust";
+    SwapStatus["Incomplete"] = "Incomplete";
+})(SwapStatus || (SwapStatus = {}));
+var AddLpStatus;
+(function (AddLpStatus) {
+    AddLpStatus["Complete"] = "Complete";
+    AddLpStatus["Complete_Refunded"] = "Complete_Refunded";
+    AddLpStatus["Complete_Below_Dust"] = "Complete_Below_Dust";
+    AddLpStatus["Incomplete"] = "Incomplete";
+})(AddLpStatus || (AddLpStatus = {}));
+var WithdrawStatus;
+(function (WithdrawStatus) {
+    WithdrawStatus["Complete"] = "Complete";
+    WithdrawStatus["Incomplete"] = "Incomplete";
+    WithdrawStatus["Complete_Refunded"] = "Complete_Refunded";
+})(WithdrawStatus || (WithdrawStatus = {}));
+var AddSaverStatus;
+(function (AddSaverStatus) {
+    AddSaverStatus["Complete"] = "Complete";
+    AddSaverStatus["Complete_Refunded"] = "Complete_Refunded";
+    AddSaverStatus["Complete_Below_Dust"] = "Complete_Below_Dust";
+    AddSaverStatus["Incomplete"] = "Incomplete";
+})(AddSaverStatus || (AddSaverStatus = {}));
 class TransactionStage {
     constructor(thorchainCache, chainAttributes = DefaultChainAttributes) {
         this.thorchainCache = thorchainCache;
         this.chainAttributes = chainAttributes;
     }
-    // Functions follow this logic below
-    // 1. Has TC see it?
-    // 2. If observed, has is there inbound conf counting (for non BFT Chains)? If so, for how long
-    // 3. Has TC processed it?
-    // 4. Is it in the outbound queue? If so, what is the target block and how long will it take for that to happen?
-    // 5. If TC has sent it, how long will outbound conf take?
-    /**
-     *
-     * @param inboundTxHash - Input needed to determine the transaction stage
-     * @param sourceChain - Needed for faster logic
-     * @returns - tx stage or maybe a boolean not sure at this stage
-     */
-    checkTxProgress(inboundTxHash, progress, sourceChain) {
-        var _a, _b;
+    checkTxProgress(inboundTxHash) {
         return __awaiter(this, void 0, void 0, function* () {
-            const transactionProgress = {
-                progress: 0,
-                seconds: 0,
-                errors: [],
-            };
-            if (progress) {
-                transactionProgress.progress = progress;
+            let txData;
+            try {
+                if (inboundTxHash.length < 1)
+                    throw Error('inboundTxHash too short');
+                txData = yield this.thorchainCache.thornode.getTxDetail(inboundTxHash);
+                // console.log(JSON.stringify(txData, null, 2))
+            }
+            catch (error) {
+                return {
+                    txType: TxType.Unknown,
+                };
             }
-            else {
-                progress = 0;
-            }
-            const txData = yield this.thorchainCache.thornode.getTxData(inboundTxHash);
-            const isSynth = yield this.isSynthTransaction(txData);
-            if (isSynth) {
-                progress = 3;
-            }
-            const lastBlock = yield this.thorchainCache.thornode.getLastBlock();
-            if (txData.observed_tx == undefined) {
-                // Check inbound, if nothing check outbound queue
-                progress = 2;
-            }
-            switch (progress) {
-                case 0:
-                    const txObserved = yield this.checkTCRecords(txData, sourceChain);
-                    transactionProgress.seconds = txObserved.seconds;
-                    transactionProgress.progress = 1;
-                    transactionProgress.errors = txObserved.error;
-                    return transactionProgress;
-                case 1:
-                    if (((_b = (_a = txData.observed_tx) === null || _a === void 0 ? void 0 : _a.tx) === null || _b === void 0 ? void 0 : _b.chain) != undefined) {
-                        sourceChain = getChain(txData.observed_tx.tx.chain);
-                        if (sourceChain == (BTCChain || BCHChain || LTCChain)) {
-                            const lastBlockHeight = lastBlock.find((obj) => obj.chain === sourceChain);
-                            const checkConf = yield this.checkConfcounting(sourceChain, lastBlockHeight, txData.observed_tx);
-                            transactionProgress.seconds = checkConf.seconds;
-                            transactionProgress.errors = checkConf.error;
-                        }
-                    }
-                    transactionProgress.progress = 2;
-                    return transactionProgress;
-                case 2:
-                    const tcBlockHeight = lastBlock.find((obj) => obj.thorchain);
-                    const checkOutboundQueue = yield this.checkOutboundQueue(inboundTxHash, tcBlockHeight);
-                    transactionProgress.seconds = checkOutboundQueue.seconds;
-                    transactionProgress.errors = checkOutboundQueue.error;
-                    transactionProgress.progress = 3;
-                    return transactionProgress;
-                case 3:
-                    const tcBlock = lastBlock.find((obj) => obj.thorchain);
-                    const checkOutboundQue = yield this.checkOutboundQueue(inboundTxHash, tcBlock);
-                    transactionProgress.seconds = checkOutboundQue.seconds;
-                    transactionProgress.progress = 4;
-                    return transactionProgress;
-                default:
-                    return transactionProgress;
+            //valid tx
+            const progress = yield this.determineObserved(txData);
+            switch (progress.txType) {
+                case TxType.Swap:
+                    yield this.checkSwapProgress(txData, progress);
+                    break;
+                case TxType.AddLP:
+                    yield this.checkAddLpProgress(txData, progress);
+                    break;
+                case TxType.WithdrawLP:
+                    yield this.checkWithdrawLpProgress(txData, progress);
+                    break;
+                case TxType.AddSaver:
+                    yield this.checkAddSaverProgress(txData, progress);
+                    break;
+                case TxType.WithdrawSaver:
+                    yield this.checkWithdrawSaverProgress(txData, progress);
+                    break;
+                case TxType.Other:
+                    break;
+            }
+            return progress;
+        });
+    }
+    checkSwapProgress(txData, progress) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (progress.inboundObserved) {
+                const memo = (_a = txData.tx.tx.memo) !== null && _a !== void 0 ? _a : '';
+                const memoFields = this.parseSwapMemo(memo);
+                const assetOut = assetFromStringEx(memoFields.asset.toUpperCase());
+                //const assetIn = assetFromStringEx(txData.tx.tx.coins?.[0].asset)
+                const swapStatus = ((_b = txData.out_txs[0].memo) === null || _b === void 0 ? void 0 : _b.match('OUT')) ? SwapStatus.Complete : SwapStatus.Complete_Refunded;
+                // current height of thorchain, neeed for confirmations
+                const chainHeight = yield this.blockHeight(AssetRuneNative);
+                // expected outbound height
+                const outboundHeight = Number((_c = txData.outbound_height) !== null && _c !== void 0 ? _c : txData.finalised_height);
+                const expectedOutBlock = Number((_d = txData.outbound_height) !== null && _d !== void 0 ? _d : txData.finalised_height);
+                const expectedOutDate = yield this.blockToDate(THORChain, txData, outboundHeight); // height held in the scheduled queue
+                const confirmations = chainHeight > outboundHeight ? chainHeight - outboundHeight : 0;
+                const minimumAmountOut = memoFields.limit
+                    ? yield this.getCryptoAmount(memoFields.limit, assetOut)
+                    : yield this.getCryptoAmount('0', assetOut);
+                const affliateFee = memoFields.affiliateFee
+                    ? yield this.getCryptoAmount(memoFields.affiliateFee, assetOut)
+                    : yield this.getCryptoAmount('0', assetOut);
+                // TODO get out tx
+                const swapInfo = {
+                    status: swapStatus,
+                    expectedOutBlock,
+                    expectedOutDate,
+                    expectedAmountOut: minimumAmountOut,
+                    confirmations,
+                    minimumAmountOut,
+                    affliateFee,
+                    toAddress: memoFields.destAddress,
+                };
+                progress.swapInfo = swapInfo;
             }
         });
     }
-    /** Stage 1  */
-    /**
-     * Check if transaction has been observed by bifrost or THORNode.
-     * If there is source chain info, use that determine the wait time else wait one minute
-     *
-     * @param observed_tx - transaction data based from an input hash
-     * @param sourceChain
-     * @returns
-     */
-    checkTCRecords(txData, sourceChain) {
+    parseSwapMemo(memo) {
+        //SWAP:ASSET:DESTADDR:LIM:AFFILIATE:FEE
+        const parts = memo.split(`:`);
+        const action = parts[0];
+        const asset = parts[1];
+        const destAddress = parts[2];
+        const limit = parts.length > 3 && parts[3].length > 0 ? parts[3] : undefined;
+        const affiliateAddress = parts.length > 4 && parts[4].length > 0 ? parts[4] : undefined;
+        const affiliateFee = parts.length > 5 && parts[5].length > 0 ? parts[5] : undefined;
+        return { action, asset, destAddress, limit, affiliateAddress, affiliateFee };
+    }
+    getCryptoAmount(baseAmt, asset) {
         return __awaiter(this, void 0, void 0, function* () {
-            const stageStatus = {
-                seconds: 0,
-                error: [],
+            const decimals = THORChain === asset.chain ? 8 : Number((yield this.thorchainCache.getPoolForAsset(asset)).pool.nativeDecimal);
+            return new CryptoAmount(baseAmount(baseAmt, decimals), asset);
+        });
+    }
+    determineObserved(txData) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const progress = {
+                txType: TxType.Unknown,
             };
-            if (JSON.stringify(txData.observed_tx) == undefined) {
-                if (sourceChain) {
-                    stageStatus.seconds = this.chainAttributes[sourceChain].avgBlockTimeInSecs;
-                }
-                else {
-                    stageStatus.seconds = 60;
-                    stageStatus.error.push(`No observed tx, wait sixty seconds`);
-                }
+            if (txData.tx) {
+                const memo = (_a = txData.tx.tx.memo) !== null && _a !== void 0 ? _a : '';
+                const parts = memo === null || memo === void 0 ? void 0 : memo.split(`:`);
+                const operation = parts && parts[0] ? parts[0] : '';
+                const assetIn = assetFromStringEx((_b = txData.tx.tx.coins) === null || _b === void 0 ? void 0 : _b[0].asset);
+                const inboundAmount = (_c = txData.tx.tx.coins) === null || _c === void 0 ? void 0 : _c[0].amount;
+                const fromAddress = (_d = txData.tx.tx.from_address) !== null && _d !== void 0 ? _d : 'unknkown';
+                const block = txData.tx.tx.chain == THORChain ? Number(txData.finalised_height) : Number(txData.tx.block_height);
+                const finalizeBlock = txData.tx.tx.chain == THORChain ? Number(txData.finalised_height) : Number(txData.tx.finalise_height);
+                const status = txData.tx.status === 'done' ? InboundStatus.Observed_Consensus : InboundStatus.Observed_Incomplete;
+                if (operation.match(/swap|s|=/gi))
+                    progress.txType = TxType.Swap;
+                if ((operation.match(/add/gi) && parts[1].match(`/`)) || (operation.match(/a|[+]/) && parts[1].match(/[/]/)))
+                    progress.txType = TxType.AddSaver;
+                if ((operation.match(/add/gi) && parts[1].match(`.`)) || (operation.match(/a|[+]/) && parts[1].match(/[.]/)))
+                    progress.txType = TxType.AddLP;
+                if (operation.match(/withdraw|wd|-/gi) && parts[1].match(/[/]/))
+                    progress.txType = TxType.WithdrawSaver;
+                if (operation.match(/withdraw|wd|-/gi) && parts[1].match(/[.]/))
+                    progress.txType = TxType.WithdrawLP;
+                if (operation.match(/out|refund/gi))
+                    progress.txType = TxType.Other;
+                const amount = yield this.getCryptoAmount(inboundAmount, assetIn);
+                // find a date for when it should be competed
+                const dateObserved = yield this.blockToDate(THORChain, txData);
+                const expectedConfirmationDate = txData.tx.tx.chain === THORChain
+                    ? yield this.blockToDate(THORChain, txData)
+                    : yield this.blockToDate(assetIn.chain, txData);
+                progress.inboundObserved = {
+                    status,
+                    date: dateObserved,
+                    block,
+                    expectedConfirmationBlock: finalizeBlock,
+                    expectedConfirmationDate,
+                    amount,
+                    fromAddress,
+                    memo,
+                };
             }
-            return stageStatus;
+            return progress;
         });
     }
-    /** Stage 2
-     *
-     * 1. Find observed_tx.finalise_height and the current observation height (observed_tx.block_height)
-     * 2. If last_observed_in (current observation height) is less then the finalise_height, will need to wait tillast_observed_in = finalise_height before thorchain starts processing the transaction.
-     * 3. If there is a wait, find the block difference (in source chain) then times by block time to find the conf counting wait time
-     *
-     * @param observed_tx - transaction data based from an input hash
-     * @param sourceChain - in tx chain, should be known at this point.
-     * @param lastSourceBlock
-     * @returns - transaction stage
-     */
-    checkConfcounting(sourceChain, lastSourceBlock, observed_tx) {
+    checkAddLpProgress(txData, progress) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const transactionStatus = { seconds: 0, error: [] };
-            if (lastSourceBlock == undefined) {
-                transactionStatus.error.push(`could not find last source block`);
-                return transactionStatus;
-            }
-            if ((observed_tx === null || observed_tx === void 0 ? void 0 : observed_tx.block_height) &&
-                (observed_tx === null || observed_tx === void 0 ? void 0 : observed_tx.finalise_height) &&
-                lastSourceBlock.last_observed_in < observed_tx.finalise_height) {
-                // If observed but not final, need to wait till the finalised block before moving to the next stage, blocks in source chain
-                if (observed_tx.block_height < observed_tx.finalise_height) {
-                    const blocksToWait = observed_tx.finalise_height - (observed_tx === null || observed_tx === void 0 ? void 0 : observed_tx.block_height); // how many source blocks to wait.
-                    transactionStatus.seconds = blocksToWait * this.chainAttributes[sourceChain].avgBlockTimeInSecs;
-                }
+            if (progress.inboundObserved) {
+                const memo = (_a = txData.tx.tx.memo) !== null && _a !== void 0 ? _a : '';
+                const memoFields = this.parseAddLpMemo(memo);
+                const asset = assetFromStringEx(memoFields.asset);
+                const isSymmetric = memoFields.pairedAddress ? true : false;
+                const assetTx = !isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
+                const runeTx = isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
+                const pairedAssetExpectedConfirmationDate = assetTx ? yield this.blockToDate(asset.chain, txData) : undefined;
+                const checkLpPosition = yield this.thorchainCache.thornode.getLiquidityProvider(memoFields.asset, progress.inboundObserved.fromAddress);
+                const status = checkLpPosition ? AddLpStatus.Complete : AddLpStatus.Incomplete;
+                const addLpInfo = {
+                    status,
+                    isSymmetric,
+                    assetTx,
+                    runeTx,
+                    assetConfirmationDate: pairedAssetExpectedConfirmationDate,
+                    pool: asset,
+                };
+                progress.addLpInfo = addLpInfo;
+            }
+        });
+    }
+    checkWithdrawLpProgress(txData, progress) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (progress.inboundObserved) {
+                const memo = (_a = txData.tx.tx.memo) !== null && _a !== void 0 ? _a : '';
+                const memoFields = this.parseWithdrawLpMemo(memo);
+                const asset = assetFromStringEx(memoFields.asset);
+                const lastBlockObj = yield this.thorchainCache.thornode.getLastBlock();
+                const currentHeight = lastBlockObj.find((obj) => obj);
+                // find the date in which the asset should be seen in the wallet
+                const outboundHeight = txData.tx.status === 'done' ? txData.finalised_height : Number(`${txData.outbound_height}`);
+                const expectedConfirmationDate = yield this.blockToDate(THORChain, txData, outboundHeight); // always pass in thorchain
+                // if the TC has process the block that the outbound tx was assigned to then its completed.
+                const status = txData.tx.status === 'done' ? WithdrawStatus.Complete : WithdrawStatus.Incomplete;
+                const outAmount = status === WithdrawStatus.Complete ? JSON.stringify(txData.out_txs).split(`"amount":"`)[1].split(`"`) : '';
+                const outboundBlock = Number((_b = txData.outbound_height) !== null && _b !== void 0 ? _b : txData.finalised_height);
+                const currentTCHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
+                const estimatedWaitTime = outboundBlock > currentTCHeight
+                    ? (outboundBlock - currentTCHeight) * this.chainAttributes[THORChain].avgBlockTimeInSecs
+                    : 0;
+                const withdrawLpInfo = {
+                    status,
+                    withdrawalAmount: new CryptoAmount(baseAmount(outAmount[0]), asset),
+                    expectedConfirmationDate,
+                    thorchainHeight: currentTCHeight,
+                    outboundHeight: outboundBlock,
+                    estimatedWaitTime,
+                };
+                progress.withdrawLpInfo = withdrawLpInfo;
+            }
+        });
+    }
+    checkAddSaverProgress(txData, progress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (progress.inboundObserved) {
+                const assetTx = !isAssetRuneNative(progress.inboundObserved.amount.asset) ? progress.inboundObserved : undefined;
+                const checkSaverVaults = yield this.thorchainCache.thornode.getSaver(txData.tx.tx.coins[0].asset, `${assetTx === null || assetTx === void 0 ? void 0 : assetTx.fromAddress}`);
+                const status = checkSaverVaults ? AddSaverStatus.Complete : AddSaverStatus.Incomplete;
+                const addSaverInfo = {
+                    status: status,
+                    assetTx,
+                    saverPos: checkSaverVaults,
+                };
+                progress.addSaverInfo = addSaverInfo;
             }
-            return transactionStatus;
         });
     }
-    /** Stage 3 */
+    checkWithdrawSaverProgress(txData, progress) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (progress.inboundObserved) {
+                const memo = (_a = txData.tx.tx.memo) !== null && _a !== void 0 ? _a : '';
+                const memoFields = this.parseWithdrawLpMemo(memo);
+                const asset = assetFromStringEx(memoFields.asset);
+                const lastBlockObj = yield this.thorchainCache.thornode.getLastBlock();
+                const currentHeight = lastBlockObj.find((obj) => obj);
+                // find the date in which the asset should be seen in the wallet
+                const outboundHeight = txData.tx.status === 'done' ? txData.finalised_height : Number(`${txData.outbound_height}`);
+                const expectedConfirmationDate = yield this.blockToDate(THORChain, txData, outboundHeight); // always pass in thorchain
+                const outAmount = txData.out_txs ? JSON.stringify(txData.out_txs).split(`"amount":"`)[1].split(`"`) : '';
+                const outboundBlock = Number(txData.outbound_height);
+                const finalisedHeight = Number(txData.finalised_height);
+                const currentTCHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
+                const estimatedWaitTime = outboundBlock > currentTCHeight
+                    ? (outboundBlock - currentTCHeight) * this.chainAttributes[THORChain].avgBlockTimeInSecs +
+                        this.chainAttributes[asset.chain].avgBlockTimeInSecs
+                    : 0;
+                // if the TC has process the block that the outbound tx was assigned to then its completed.
+                const status = txData.out_txs ? WithdrawStatus.Complete : WithdrawStatus.Incomplete;
+                const withdrawSaverInfo = {
+                    status,
+                    withdrawalAmount: new CryptoAmount(baseAmount(outAmount[0]), asset),
+                    expectedConfirmationDate,
+                    thorchainHeight: currentTCHeight,
+                    finalisedHeight,
+                    outboundBlock,
+                    estimatedWaitTime,
+                };
+                progress.withdrawSaverInfo = withdrawSaverInfo;
+            }
+        });
+    }
+    parseAddLpMemo(memo) {
+        //ADD:POOL:PAIREDADDR:AFFILIATE:FEE
+        const parts = memo.split(`:`);
+        const action = parts[0];
+        const asset = parts[1];
+        //optional fields
+        const pairedAddress = parts.length > 2 && parts[2].length > 0 ? parts[2] : undefined;
+        const affiliateAddress = parts.length > 3 && parts[3].length > 0 ? parts[3] : undefined;
+        const affiliateFee = parts.length > 4 && parts[4].length > 0 ? parts[4] : undefined;
+        return { action, asset, pairedAddress, affiliateAddress, affiliateFee };
+    }
+    parseWithdrawLpMemo(memo) {
+        //ADD:POOL:PAIREDADDR:AFFILIATE:FEE
+        const parts = memo.split(`:`);
+        const action = parts[0];
+        const asset = parts[1];
+        //optional fields
+        const pairedAddress = parts.length > 2 && parts[2].length > 0 ? parts[2] : undefined;
+        const affiliateAddress = parts.length > 3 && parts[3].length > 0 ? parts[3] : undefined;
+        const affiliateFee = parts.length > 4 && parts[4].length > 0 ? parts[4] : undefined;
+        return { action, asset, pairedAddress, affiliateAddress, affiliateFee };
+    }
     /**
-     * Regardless of the transaction size, if the network is under load, Txs will need to wait. Given a size of a transaction AND the current network load, THORNode can assign a future block for the outgoing transaction.
-     * A user needs to wait for that block to be reached before a TX is sent.
-     *
-     * Steps.
-     * 1. See if there is an outbound queue. If none, outTx has been sent.
-     * 2. Find the targetblock the oubound Tx will be sent in for the given inbound Tx hash.
-     * 3. Compare that against the current TC height to see the block different then times the TC block time to get seconds.
-     *
-     * @param inboundTxHash
-     * @param lastBlockHeight
-     * @returns
+     * Private function to return the date stamp from block height and chain
+     * @param chain - input chain
+     * @param txData - txResponse
+     * @returns date()
      */
-    checkOutboundQueue(inboundTxHash, lastBlockHeight) {
+    blockToDate(chain, txData, outboundBlock) {
         return __awaiter(this, void 0, void 0, function* () {
-            const stageStatus = { seconds: 0, error: [] };
-            const scheduledQueueItem = (yield this.thorchainCache.thornode.getscheduledQueue()).find((item) => item.in_hash === inboundTxHash);
-            const scheduledQueueLength = (yield this.thorchainCache.thornode.getscheduledQueue()).length;
-            if (scheduledQueueLength > 0 && scheduledQueueItem == undefined) {
-                stageStatus.error.push(`Scheduled queue count ${scheduledQueueLength}`);
-                stageStatus.error.push(`Could not find tx in outbound queue`);
+            const lastBlockObj = yield this.thorchainCache.thornode.getLastBlock();
+            const time = new Date();
+            let blockDifference;
+            const currentHeight = lastBlockObj.find((obj) => obj.chain == chain);
+            const chainHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.last_observed_in}`);
+            const recordedChainHeight = Number(`${txData.tx.block_height}`);
+            // If outbound time is required
+            if (outboundBlock) {
+                const currentHeight = lastBlockObj.find((obj) => obj);
+                const thorchainHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
+                if (outboundBlock > thorchainHeight) {
+                    blockDifference = outboundBlock - thorchainHeight;
+                    time.setSeconds(time.getSeconds() + blockDifference * this.chainAttributes[chain].avgBlockTimeInSecs);
+                    console.log(time);
+                }
+                else {
+                    blockDifference = thorchainHeight - outboundBlock; // already processed find the date it was completed
+                    time.setSeconds(time.getSeconds() - blockDifference * this.chainAttributes[chain].avgBlockTimeInSecs);
+                    return time;
+                }
+            }
+            // find out how long ago it was processed for all chains
+            if (chain == THORChain) {
+                const currentHeight = lastBlockObj.find((obj) => obj);
+                const thorchainHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`); // current height of the TC
+                const finalisedHeight = Number(`${txData.finalised_height}`); // height tx was completed in
+                blockDifference = thorchainHeight - finalisedHeight;
+                time.setSeconds(time.getSeconds() - blockDifference * this.chainAttributes[chain].avgBlockTimeInSecs); // note if using data from a tx that was before a thorchain halt this calculation becomes inaccurate...
             }
             else {
-                if ((scheduledQueueItem === null || scheduledQueueItem === void 0 ? void 0 : scheduledQueueItem.height) && (lastBlockHeight === null || lastBlockHeight === void 0 ? void 0 : lastBlockHeight.thorchain)) {
-                    stageStatus.seconds =
-                        (scheduledQueueItem.height - (lastBlockHeight === null || lastBlockHeight === void 0 ? void 0 : lastBlockHeight.thorchain)) * this.chainAttributes[THORChain].avgBlockTimeInSecs;
-                }
+                // set the time for all other chains
+                blockDifference = chainHeight - recordedChainHeight;
+                time.setSeconds(time.getSeconds() - blockDifference * this.chainAttributes[chain].avgBlockTimeInSecs);
             }
-            return stageStatus;
+            return time;
         });
     }
     /**
-     * Checks too see if the transaction is synth from the memo
-     * @param txData  - input txData
-     * @returns - boolean
+     * Returns current block height of an asset's native chain
+     * @param chain
+     * @returns
      */
-    isSynthTransaction(txData) {
-        var _a;
+    blockHeight(asset) {
         return __awaiter(this, void 0, void 0, function* () {
-            const memo = (_a = txData.observed_tx) === null || _a === void 0 ? void 0 : _a.tx.memo;
-            const synth = (memo === null || memo === void 0 ? void 0 : memo.split(`:`)[1].match(`/`)) ? true : false;
-            return synth;
+            const lastBlockObj = yield this.thorchainCache.thornode.getLastBlock();
+            const currentHeight = lastBlockObj.find((obj) => obj.chain == asset.chain);
+            let blockHeight;
+            if (asset.chain === THORChain || asset.synth) {
+                const currentHeight = lastBlockObj.find((obj) => obj);
+                blockHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.thorchain}`);
+            }
+            else {
+                blockHeight = Number(`${currentHeight === null || currentHeight === void 0 ? void 0 : currentHeight.last_observed_in}`);
+            }
+            return blockHeight;
         });
     }
 }
 
-export { CryptoAmount, LiquidityPool, Midgard, ThorchainCache, ThorchainQuery, Thornode, TransactionStage, calcNetworkFee, getDoubleSwap, getLiquidityProtectionData, getLiquidityUnits, getPoolShare, getSingleSwap, getSlipOnLiquidity };
+export { AddLpStatus, AddSaverStatus, CryptoAmount, InboundStatus, LiquidityPool, Midgard, SwapStatus, ThorchainCache, ThorchainQuery, Thornode, TransactionStage, TxType, WithdrawStatus, calcNetworkFee, getDoubleSwap, getLiquidityProtectionData, getLiquidityUnits, getPoolShare, getSingleSwap, getSlipOnLiquidity };