@xchainjs/xchain-thorchain-amm 0.1.0-alpha → 0.1.0-alpha2

package/README.md

@@ -2,7 +2,7 @@
 
 ## Modules
 
-module for to interact with Thorchain AMM
+Thorchain AMM module
 
 
 ## Installation

package/lib/index.esm.js

@@ -674,7 +674,6 @@ class Midgard {
                     throw Error(`Could not find network value name`);
                 }
             }
-            console.log(retVal);
             return retVal;
         });
     }
@@ -697,6 +696,25 @@ class Midgard {
             throw Error(`Midgard not responding`);
         });
     }
+    /**
+     * Gets actions related to a txID
+     * @param txHash transaction id
+     * @returns Type Action array of objects
+     */
+    getActions(txHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const actions = (yield api.getActions('', txHash)).data.actions;
+                    return actions;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
 }
 
 /**
@@ -831,23 +849,23 @@ const calcNetworkFee = (asset, gasRate) => {
         return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
     switch (asset.chain) {
         case Chain.Bitcoin:
-            return new CryptoAmount(baseAmount(gasRate.multipliedBy(250)), AssetBTC);
+            return new CryptoAmount(baseAmount(gasRate.multipliedBy(1000)), AssetBTC);
         case Chain.BitcoinCash:
-            return new CryptoAmount(baseAmount(gasRate.multipliedBy(250)), AssetBCH);
+            return new CryptoAmount(baseAmount(gasRate.multipliedBy(1500)), AssetBCH);
         case Chain.Litecoin:
             return new CryptoAmount(baseAmount(gasRate.multipliedBy(250)), AssetLTC);
         case Chain.Doge:
             // NOTE: UTXO chains estimate fees with a 250 byte size
-            return new CryptoAmount(baseAmount(gasRate.multipliedBy(250)), AssetDOGE);
+            return new CryptoAmount(baseAmount(gasRate.multipliedBy(1000)), AssetDOGE);
         case Chain.Binance:
             //flat fee
             return new CryptoAmount(baseAmount(gasRate), AssetBNB);
         case Chain.Ethereum:
             if (eqAsset(asset, AssetETH)) {
-                return new CryptoAmount(baseAmount(gasRate.multipliedBy(35000)), AssetETH);
+                return new CryptoAmount(baseAmount(gasRate.multipliedBy(80000)), AssetETH);
             }
             else {
-                return new CryptoAmount(baseAmount(gasRate.multipliedBy(70000)), AssetETH);
+                return new CryptoAmount(baseAmount(gasRate.multipliedBy(80000)), AssetETH);
             }
         case Chain.Terra:
             return new CryptoAmount(baseAmount(gasRate), AssetLUNA);
@@ -1710,18 +1728,21 @@ class ThorchainAMM {
      */
     confCounting(inbound) {
         return __awaiter(this, void 0, void 0, function* () {
-            // RUNE, BNB and Synths have near instant finality, so no conf counting required.
-            if (isAssetRuneNative(inbound.asset) || eqAsset(AssetBNB, inbound.asset) || inbound.asset.synth) {
+            // RUNE, BNB and Synths have near instant finality, so no conf counting required. - need to make a BFT only case.
+            if (isAssetRuneNative(inbound.asset) ||
+                inbound.asset.chain == AssetBNB.chain ||
+                inbound.asset.chain == AssetAtom.chain ||
+                inbound.asset.synth) {
                 return this.chainAttributes[Chain.THORChain].avgBlockTimeInSecs;
             }
             // Get the gas asset for the inbound.asset.chain
             const chainGasAsset = getChainAsset(inbound.asset.chain);
-            // check for chain asset, else need to convert asset value to chain asset.
+            // Check for chain asset, else need to convert asset value to chain asset.
             const amountInGasAsset = yield this.allPools.convert(inbound, chainGasAsset);
             // Convert to Asset Amount
             const amountInGasAssetInAsset = amountInGasAsset.assetAmount;
             const confConfig = this.chainAttributes[inbound.asset.chain];
-            // find the requried confs
+            // find the required confs
             const requiredConfs = Math.ceil(amountInGasAssetInAsset.amount().div(confConfig.blockReward).toNumber());
             // convert that into seconds
             return requiredConfs * confConfig.avgBlockTimeInSecs;

package/lib/index.js

@@ -684,7 +684,6 @@ class Midgard {
                     throw Error(`Could not find network value name`);
                 }
             }
-            console.log(retVal);
             return retVal;
         });
     }
@@ -707,6 +706,25 @@ class Midgard {
             throw Error(`Midgard not responding`);
         });
     }
+    /**
+     * Gets actions related to a txID
+     * @param txHash transaction id
+     * @returns Type Action array of objects
+     */
+    getActions(txHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const actions = (yield api.getActions('', txHash)).data.actions;
+                    return actions;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
 }
 
 /**
@@ -841,23 +859,23 @@ const calcNetworkFee = (asset, gasRate) => {
         return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainUtil.AssetRuneNative);
     switch (asset.chain) {
         case xchainUtil.Chain.Bitcoin:
-            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(250)), xchainUtil.AssetBTC);
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(1000)), xchainUtil.AssetBTC);
         case xchainUtil.Chain.BitcoinCash:
-            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(250)), xchainUtil.AssetBCH);
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(1500)), xchainUtil.AssetBCH);
         case xchainUtil.Chain.Litecoin:
             return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(250)), xchainUtil.AssetLTC);
         case xchainUtil.Chain.Doge:
             // NOTE: UTXO chains estimate fees with a 250 byte size
-            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(250)), xchainUtil.AssetDOGE);
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(1000)), xchainUtil.AssetDOGE);
         case xchainUtil.Chain.Binance:
             //flat fee
             return new CryptoAmount(xchainUtil.baseAmount(gasRate), xchainUtil.AssetBNB);
         case xchainUtil.Chain.Ethereum:
             if (xchainUtil.eqAsset(asset, xchainUtil.AssetETH)) {
-                return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(35000)), xchainUtil.AssetETH);
+                return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(80000)), xchainUtil.AssetETH);
             }
             else {
-                return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(70000)), xchainUtil.AssetETH);
+                return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(80000)), xchainUtil.AssetETH);
             }
         case xchainUtil.Chain.Terra:
             return new CryptoAmount(xchainUtil.baseAmount(gasRate), lib$1.AssetLUNA);
@@ -1720,18 +1738,21 @@ class ThorchainAMM {
      */
     confCounting(inbound) {
         return __awaiter(this, void 0, void 0, function* () {
-            // RUNE, BNB and Synths have near instant finality, so no conf counting required.
-            if (lib$2.isAssetRuneNative(inbound.asset) || xchainUtil.eqAsset(xchainUtil.AssetBNB, inbound.asset) || inbound.asset.synth) {
+            // RUNE, BNB and Synths have near instant finality, so no conf counting required. - need to make a BFT only case.
+            if (lib$2.isAssetRuneNative(inbound.asset) ||
+                inbound.asset.chain == xchainUtil.AssetBNB.chain ||
+                inbound.asset.chain == lib.AssetAtom.chain ||
+                inbound.asset.synth) {
                 return this.chainAttributes[xchainUtil.Chain.THORChain].avgBlockTimeInSecs;
             }
             // Get the gas asset for the inbound.asset.chain
             const chainGasAsset = getChainAsset(inbound.asset.chain);
-            // check for chain asset, else need to convert asset value to chain asset.
+            // Check for chain asset, else need to convert asset value to chain asset.
             const amountInGasAsset = yield this.allPools.convert(inbound, chainGasAsset);
             // Convert to Asset Amount
             const amountInGasAssetInAsset = amountInGasAsset.assetAmount;
             const confConfig = this.chainAttributes[inbound.asset.chain];
-            // find the requried confs
+            // find the required confs
             const requiredConfs = Math.ceil(amountInGasAssetInAsset.amount().div(confConfig.blockReward).toNumber());
             // convert that into seconds
             return requiredConfs * confConfig.avgBlockTimeInSecs;

package/lib/xchain-thorchain-amm/src/thorchain-amm.d.ts

@@ -61,7 +61,7 @@ export declare class ThorchainAMM {
      * @param interfaceID - id if the calling interface (optional)
      * @returns {SwapSubmitted} - Tx Hash, URL of BlockExplorer and expected wait time.
      */
-    protected doSwap(wallet: Wallet, params: EstimateSwapParams, destinationAddress: string, affiliateAddress?: string, interfaceID?: number): Promise<SwapSubmitted>;
+    doSwap(wallet: Wallet, params: EstimateSwapParams, destinationAddress: string, affiliateAddress?: string, interfaceID?: number): Promise<SwapSubmitted>;
     /**
      * Basic Checks for swap information
      * @param params

package/lib/xchain-thorchain-amm/src/utils/midgard.d.ts

@@ -1,5 +1,5 @@
 import { Network } from '@xchainjs/xchain-client';
-import { InboundAddressesItem, PoolDetail } from '@xchainjs/xchain-midgard';
+import { Action, InboundAddressesItem, PoolDetail } from '@xchainjs/xchain-midgard';
 import { Chain } from '@xchainjs/xchain-util';
 import { CryptoAmount } from '../crypto-amount';
 import { InboundDetail, MidgardConfig } from '../types';
@@ -41,4 +41,10 @@ export declare class Midgard {
      * @returns
      */
     getLatestBlockHeight(): Promise<number>;
+    /**
+     * Gets actions related to a txID
+     * @param txHash transaction id
+     * @returns Type Action array of objects
+     */
+    getActions(txHash: string): Promise<Action[]>;
 }

package/lib/xchain-thorchain-amm/src/utils/thornode.d.ts

@@ -25,6 +25,7 @@ export declare class Thornode {
     private transactionsApi;
     private queueApi;
     private networkApi;
+    private midgard;
     constructor(network?: Network, config?: ThornodeConfig, chainAttributes?: Record<Chain, ChainAttributes>);
     /**
      * Returns the oubound transactions held by THORChain due to outbound delay
@@ -47,10 +48,18 @@ export declare class Thornode {
      */
     checkTx(inboundTxHash: string, sourceChain?: Chain): Promise<TxStatus>;
     /** Stage 1  */
-    private checkObservedTx;
+    private checkTxDefined;
     /** Stage 2, THORNode has seen it. See if observed only (conf counting) or it has been processed by THORChain  */
     private checkObservedOnly;
-    /** Stage 3 */
+    /**
+     * Stage 3
+     * @param txStatus
+     * @param txData
+     * @param scheduledQueue
+     * @param scheduledQueueItem
+     * @param lastBlockHeight
+     * @returns
+     */
     private checkOutboundQueue;
     /** Stage 4 */
     private checkOutboundTx;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-thorchain-amm",
-  "version": "0.1.0-alpha",
+  "version": "0.1.0-alpha2",
   "description": "module that exposes estimating & swappping cryptocurrency assets on thorchain",
   "keywords": [
     "THORChain",