@allbridge/bridge-core-sdk 0.4.2 → 0.6.0

package/README.md

@@ -35,6 +35,7 @@ Provides an easy integration with the Allbridge Core Bridge for DApps in the bro
 ```bash
 $ npm install @allbridge/bridge-core-sdk
 ```
+
 ## How to use
 
 ### 1. Initialize SDK instance
@@ -55,18 +56,22 @@ const {bridgeAddress, tokens, chainId, name} = supportedChains[ChainSymbol.ETH];
 const usdtOnEthTokenInfo = tokens.find(tokensInfo => tokensInfo.symbol === 'USDT');
 ```
 
-### 3.1 Approve the transfer of tokens 
+### 3.1 Approve the transfer of tokens
 
-Before sending tokens the bridge has to be authorized to use user's tokens. This is done by calling the `evmApprove` method on SDK instance.
+Before sending tokens the bridge has to be authorized to use user's tokens. This is done by calling the `approve` method
+on SDK instance.
 
 ```js
-const response = await sdk.evmApprove(web3, {
+const response = await sdk.approve(web3, {
   tokenAddress: tokenAddress,
   owner: senderAddress,
-  spender: bridgeAddress,
+  spender: poolAddress,
 });
 ```
 
+**TIP:** To interact with the **Tron** blockchain, use: </br>
+```tronWeb``` instead of ```web3```
+
 ### 3.2 Send Tokens
 
 Initiate the transfer of tokens with `send` method on SDK instance.
@@ -83,6 +88,7 @@ await sdk.send(web3, {
 ```
 
 ### Full example
+
 Swap BUSD on BSC chain to USDT on TRX chain
 
 ```js
@@ -117,11 +123,11 @@ async function runExample() {
   const trxChain = chains[ChainSymbol.TRX];
   const usdtTokenInfo = trxChain.tokens.find(tokenInfo => tokenInfo.symbol === 'USDT');
 
-  // authorize the bridge to transfer tokens from sender's address
-  await sdk.evmApprove(web3, {
+  // authorize a transfer of tokens from sender's address
+  await sdk.approve(web3, {
     tokenAddress: busdTokenInfo.tokenAddress,
     owner: fromAddress,
-    spender: bscChain.bridgeAddress,
+    spender: busdTokenInfo.poolAddress,
   });
 
   // initiate transfer
@@ -141,9 +147,18 @@ runExample();
 
 ## Other operations
 
-### Calculating amount of tokens to be received after fee 
+### Get information about sent transaction
+
+SDK method `getTransferStatus` can be used to get information about tokens transfer.
+
+```js
+const transferStatus = await sdk.getTransferStatus(chainSymbol, txId);
+```
+
+### Calculating amount of tokens to be received after fee
 
-SDK method `getAmountToBeReceived` can be used to calculate the amount of tokens the receiving party will get after applying the bridging fee.
+SDK method `getAmountToBeReceived` can be used to calculate the amount of tokens the receiving party will get after
+applying the bridging fee.
 
 ```js
 const amountToBeReceived = sdk.getAmountToBeReceived(
@@ -155,7 +170,8 @@ const amountToBeReceived = sdk.getAmountToBeReceived(
 
 ### Calculating amount of tokens to send
 
-SDK method `getAmountToSend` can be used to calculate the amount of tokens to send based on the required amount of tokens the receiving party should get.
+SDK method `getAmountToSend` can be used to calculate the amount of tokens to send based on the required amount of
+tokens the receiving party should get.
 
 ```js
 const amountToSend = sdk.getAmountToSend(
@@ -167,7 +183,8 @@ const amountToSend = sdk.getAmountToSend(
 
 ### Getting the amount of gas fee
 
-SDK method `getTxCost` can be used to fetch information about the amount of gas fee required to complete the transfer on the destination chain. Gas fee is paid during the [send](#32-send-tokens) operation in the source chain currency.
+SDK method `getTxCost` can be used to fetch information about the amount of gas fee required to complete the transfer on
+the destination chain. Gas fee is paid during the [send](#32-send-tokens) operation in the source chain currency.
 
 ```js
 const weiValue = await sdk.getTxCost(
@@ -179,7 +196,8 @@ const weiValue = await sdk.getTxCost(
 
 ### Getting the average transfer time
 
-SDK method `getAverageTransferTime` can be used to get the average time in ms it takes to complete a transfer for a given combination of tokens and messenger.
+SDK method `getAverageTransferTime` can be used to get the average time in ms it takes to complete a transfer for a
+given combination of tokens and messenger.
 
 ```js
 const transferTimeMs = sdk.getAverageTransferTime(
@@ -191,4 +209,5 @@ const transferTimeMs = sdk.getAverageTransferTime(
 
 ## Semver
 
-Until bridge-core-sdk reaches a `1.0.0` release, breaking changes will be released with a new minor version. For example `0.3.1`, and `0.3.4` will have the same API, but `0.4.0` will have breaking changes.
+Until bridge-core-sdk reaches a `1.0.0` release, breaking changes will be released with a new minor version. For
+example `0.3.1`, and `0.3.4` will have the same API, but `0.4.0` will have breaking changes.

package/dist/browser/index.js

@@ -12353,13 +12353,13 @@ var require_lib14 = __commonJS({
       return TransactionOrderForkEvent2;
     }(ForkEvent);
     exports.TransactionOrderForkEvent = TransactionOrderForkEvent;
-    var Provider = function() {
-      function Provider2() {
+    var Provider2 = function() {
+      function Provider3() {
         var _newTarget = this.constructor;
-        logger.checkAbstract(_newTarget, Provider2);
+        logger.checkAbstract(_newTarget, Provider3);
         (0, properties_1.defineReadOnly)(this, "_isProvider", true);
       }
-      Provider2.prototype.getFeeData = function() {
+      Provider3.prototype.getFeeData = function() {
         return __awaiter(this, void 0, void 0, function() {
           var _a, block, gasPrice, lastBaseFeePerGas, maxFeePerGas, maxPriorityFeePerGas;
           return __generator(this, function(_b) {
@@ -12384,18 +12384,18 @@ var require_lib14 = __commonJS({
           });
         });
       };
-      Provider2.prototype.addListener = function(eventName, listener) {
+      Provider3.prototype.addListener = function(eventName, listener) {
         return this.on(eventName, listener);
       };
-      Provider2.prototype.removeListener = function(eventName, listener) {
+      Provider3.prototype.removeListener = function(eventName, listener) {
         return this.off(eventName, listener);
       };
-      Provider2.isProvider = function(value) {
+      Provider3.isProvider = function(value) {
         return !!(value && value._isProvider);
       };
-      return Provider2;
+      return Provider3;
     }();
-    exports.Provider = Provider;
+    exports.Provider = Provider2;
   }
 });
 
@@ -50377,46 +50377,6 @@ P.valueOf = function() {
 };
 var Big = _Big_();
 
-// src/chains/index.ts
-var ChainSymbol = /* @__PURE__ */ ((ChainSymbol3) => {
-  ChainSymbol3["GRL"] = "GRL";
-  ChainSymbol3["BSC"] = "BSC";
-  ChainSymbol3["ETH"] = "ETH";
-  ChainSymbol3["SOL"] = "SOL";
-  ChainSymbol3["TRX"] = "TRX";
-  return ChainSymbol3;
-})(ChainSymbol || {});
-var chainProperties = {
-  ["GRL" /* GRL */]: {
-    chainSymbol: "GRL" /* GRL */,
-    chainId: "0x5",
-    name: "Goerli",
-    chainType: "EVM" /* EVM */
-  },
-  ["BSC" /* BSC */]: {
-    chainSymbol: "BSC" /* BSC */,
-    chainId: "0x38",
-    name: "BNB Chain",
-    chainType: "EVM" /* EVM */
-  },
-  ["ETH" /* ETH */]: {
-    chainSymbol: "ETH" /* ETH */,
-    chainId: "0x1",
-    name: "Ethereum",
-    chainType: "EVM" /* EVM */
-  },
-  ["SOL" /* SOL */]: {
-    chainSymbol: "SOL" /* SOL */,
-    name: "Solana",
-    chainType: "SOLANA" /* SOLANA */
-  },
-  ["TRX" /* TRX */]: {
-    chainSymbol: "TRX" /* TRX */,
-    name: "Tron",
-    chainType: "TRX" /* TRX */
-  }
-};
-
 // src/bridge/evm/index.ts
 var import_bn = __toESM(require_bn());
 
@@ -50646,8 +50606,65 @@ var abi_default = [
   }
 ];
 
-// src/bridge/evm/index.ts
+// src/chains/index.ts
+var ChainSymbol = /* @__PURE__ */ ((ChainSymbol3) => {
+  ChainSymbol3["GRL"] = "GRL";
+  ChainSymbol3["BSC"] = "BSC";
+  ChainSymbol3["ETH"] = "ETH";
+  ChainSymbol3["SOL"] = "SOL";
+  ChainSymbol3["TRX"] = "TRX";
+  return ChainSymbol3;
+})(ChainSymbol || {});
+var ChainType = /* @__PURE__ */ ((ChainType2) => {
+  ChainType2["EVM"] = "EVM";
+  ChainType2["SOLANA"] = "SOLANA";
+  ChainType2["TRX"] = "TRX";
+  return ChainType2;
+})(ChainType || {});
+var chainProperties = {
+  ["GRL" /* GRL */]: {
+    chainSymbol: "GRL" /* GRL */,
+    chainId: "0x5",
+    name: "Goerli",
+    chainType: "EVM" /* EVM */
+  },
+  ["BSC" /* BSC */]: {
+    chainSymbol: "BSC" /* BSC */,
+    chainId: "0x38",
+    name: "BNB Chain",
+    chainType: "EVM" /* EVM */
+  },
+  ["ETH" /* ETH */]: {
+    chainSymbol: "ETH" /* ETH */,
+    chainId: "0x1",
+    name: "Ethereum",
+    chainType: "EVM" /* EVM */
+  },
+  ["SOL" /* SOL */]: {
+    chainSymbol: "SOL" /* SOL */,
+    name: "Solana",
+    chainType: "SOLANA" /* SOLANA */
+  },
+  ["TRX" /* TRX */]: {
+    chainSymbol: "TRX" /* TRX */,
+    name: "Tron",
+    chainType: "TRX" /* TRX */
+  }
+};
+
+// src/bridge/models/bridge.model.ts
+var Bridge = class {
+};
+var ApprovalBridge = class extends Bridge {
+  async isNeededApprove(approveData) {
+    const allowance = await this.getAllowance(approveData);
+    return Big(allowance).eq(0);
+  }
+};
+
+// src/bridge/utils.ts
 var import_randombytes = __toESM(require_browser());
+var TronWebLib = __toESM(require_TronWeb_node());
 
 // src/utils/calculation/constants.ts
 var SYSTEM_PRECISION = 3;
@@ -50751,18 +50768,7 @@ function getY(x, a, d) {
   return commonPartBig.times(x).plus(sqrtBig).div(dividerBig).round(0, 0).plus(1);
 }
 
-// src/bridge/models/bridge.model.ts
-var Bridge = class {
-};
-var ApprovalBridge = class extends Bridge {
-  async isNeededApprove(approveData) {
-    const allowance = await this.getAllowance(approveData);
-    return Big(allowance).eq(0);
-  }
-};
-
 // src/bridge/utils.ts
-var TronWebLib = __toESM(require_TronWeb_node());
 function formatAddress(address, from, to) {
   let buffer;
   switch (from) {
@@ -50795,7 +50801,7 @@ function formatAddress(address, from, to) {
       );
     }
     case "TRX" /* TRX */: {
-      return buffer.toString();
+      return buffer.toJSON().data;
     }
     default: {
       throw new Error(
@@ -50828,6 +50834,84 @@ function bufferToSize(buffer, size) {
   buffer.copy(result, size - buffer.length);
   return result;
 }
+function getDecimalsByContractAddress(chainDetailsMap, chainSymbol, contractAddress) {
+  const sourceTokenInfoWithChainDetails = chainDetailsMap[chainSymbol].tokens.find(
+    (value) => value.tokenAddress.toUpperCase() === contractAddress.toUpperCase()
+  );
+  if (!sourceTokenInfoWithChainDetails) {
+    throw new Error("Cannot find source token info");
+  }
+  return sourceTokenInfoWithChainDetails.decimals;
+}
+function getNonce() {
+  return (0, import_randombytes.default)(32);
+}
+async function prepareTxSendParams(bridgeChainType, params, api) {
+  const txSendParams = {};
+  let fromChainId;
+  let toChainType;
+  if (isSendParamsWithChainSymbol(params)) {
+    const chainDetailsMap = (await api.getTokensInfo()).chainDetailsMap();
+    fromChainId = chainDetailsMap[params.fromChainSymbol].allbridgeChainId;
+    toChainType = chainProperties[params.toChainSymbol].chainType;
+    txSendParams.contractAddress = chainDetailsMap[params.fromChainSymbol].bridgeAddress;
+    txSendParams.fromTokenAddress = params.fromTokenAddress;
+    txSendParams.toChainId = chainDetailsMap[params.toChainSymbol].allbridgeChainId;
+    txSendParams.toTokenAddress = params.toTokenAddress;
+    txSendParams.amount = convertFloatAmountToInt(
+      params.amount,
+      getDecimalsByContractAddress(
+        chainDetailsMap,
+        params.fromChainSymbol,
+        txSendParams.fromTokenAddress
+      )
+    ).toFixed();
+  } else {
+    fromChainId = params.sourceChainToken.allbridgeChainId;
+    toChainType = chainProperties[params.destinationChainToken.chainSymbol].chainType;
+    txSendParams.contractAddress = params.sourceChainToken.bridgeAddress;
+    txSendParams.fromTokenAddress = params.sourceChainToken.tokenAddress;
+    txSendParams.toChainId = params.destinationChainToken.allbridgeChainId;
+    txSendParams.toTokenAddress = params.destinationChainToken.tokenAddress;
+    txSendParams.amount = convertFloatAmountToInt(
+      params.amount,
+      params.sourceChainToken.decimals
+    ).toFixed();
+  }
+  txSendParams.messenger = params.messenger;
+  txSendParams.fromAccountAddress = params.fromAccountAddress;
+  let { fee } = params;
+  if (fee == null) {
+    fee = await api.getReceiveTransactionCost({
+      sourceChainId: fromChainId,
+      destinationChainId: txSendParams.toChainId,
+      messenger: txSendParams.messenger
+    });
+  }
+  txSendParams.fee = fee;
+  txSendParams.fromTokenAddress = formatAddress(
+    txSendParams.fromTokenAddress,
+    bridgeChainType,
+    bridgeChainType
+  );
+  txSendParams.toAccountAddress = formatAddress(
+    params.toAccountAddress,
+    toChainType,
+    bridgeChainType
+  );
+  txSendParams.toTokenAddress = formatAddress(
+    txSendParams.toTokenAddress,
+    toChainType,
+    bridgeChainType
+  );
+  return txSendParams;
+}
+function isSendParamsWithChainSymbol(params) {
+  return params.fromChainSymbol !== void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(() => resolve(), ms));
+}
 
 // src/bridge/evm/abi/Abi.json
 var Abi_default = [
@@ -51528,73 +51612,13 @@ var Abi_default = [
 // src/bridge/evm/index.ts
 var MAX_AMOUNT = "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
 var EvmBridge = class extends ApprovalBridge {
-  constructor(api, web3) {
+  constructor(web3) {
     super();
-    this.api = api;
     this.web3 = web3;
+    this.chainType = "EVM" /* EVM */;
   }
-  getTokenBalance(data) {
-    return this.getContract(abi_default, data.tokenAddress).methods.balanceOf(data.account).call();
-  }
-  async send(params) {
-    const txSendParams = {};
-    let fromChainId;
-    let toChainType;
-    if (BridgeService.isSendParamsWithChainSymbol(params)) {
-      const chainDetailsMap = (await this.api.getTokensInfo()).chainDetailsMap();
-      fromChainId = chainDetailsMap[params.fromChainSymbol].allbridgeChainId;
-      toChainType = chainProperties[params.toChainSymbol].chainType;
-      txSendParams.contractAddress = chainDetailsMap[params.fromChainSymbol].bridgeAddress;
-      txSendParams.fromTokenAddress = params.fromTokenAddress;
-      txSendParams.toChainId = chainDetailsMap[params.toChainSymbol].allbridgeChainId;
-      txSendParams.toTokenAddress = params.toTokenAddress;
-      txSendParams.amount = convertFloatAmountToInt(
-        params.amount,
-        this.getDecimalsByContractAddress(
-          chainDetailsMap,
-          params.fromChainSymbol,
-          txSendParams.fromTokenAddress
-        )
-      ).toFixed();
-    } else {
-      fromChainId = params.sourceChainToken.allbridgeChainId;
-      toChainType = chainProperties[params.destinationChainToken.chainSymbol].chainType;
-      txSendParams.contractAddress = params.sourceChainToken.bridgeAddress;
-      txSendParams.fromTokenAddress = params.sourceChainToken.tokenAddress;
-      txSendParams.toChainId = params.destinationChainToken.allbridgeChainId;
-      txSendParams.toTokenAddress = params.destinationChainToken.tokenAddress;
-      txSendParams.amount = convertFloatAmountToInt(
-        params.amount,
-        params.sourceChainToken.decimals
-      ).toFixed();
-    }
-    txSendParams.messenger = params.messenger;
-    txSendParams.fromAccountAddress = params.fromAccountAddress;
-    let { fee } = params;
-    if (fee == null) {
-      fee = await this.api.getReceiveTransactionCost({
-        sourceChainId: fromChainId,
-        destinationChainId: txSendParams.toChainId,
-        messenger: txSendParams.messenger
-      });
-    }
-    txSendParams.fee = fee;
-    txSendParams.fromTokenAddress = formatAddress(
-      txSendParams.fromTokenAddress,
-      "EVM" /* EVM */,
-      "EVM" /* EVM */
-    );
-    txSendParams.toAccountAddress = formatAddress(
-      params.toAccountAddress,
-      toChainType,
-      "EVM" /* EVM */
-    );
-    txSendParams.toTokenAddress = formatAddress(
-      txSendParams.toTokenAddress,
-      toChainType,
-      "EVM" /* EVM */
-    );
-    return this.sendTx(txSendParams);
+  async getTokenBalance(data) {
+    return await this.getContract(abi_default, data.tokenAddress).methods.balanceOf(data.account).call();
   }
   async sendTx(params) {
     const {
@@ -51609,7 +51633,7 @@ var EvmBridge = class extends ApprovalBridge {
       fee
     } = params;
     const bridgeContract = this.getBridgeContract(contractAddress);
-    const nonce = new import_bn.default(EvmBridge.getNonce());
+    const nonce = new import_bn.default(getNonce());
     const swapAndBridgeMethod = bridgeContract.methods.swapAndBridge(
       fromTokenAddress,
       amount,
@@ -51655,17 +51679,82 @@ var EvmBridge = class extends ApprovalBridge {
   getBridgeContract(contractAddress) {
     return this.getContract(Abi_default, contractAddress);
   }
-  static getNonce() {
-    return (0, import_randombytes.default)(32);
+};
+
+// src/bridge/trx/index.ts
+var MAX_AMOUNT2 = "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+var TronBridge = class extends ApprovalBridge {
+  constructor(tronWeb) {
+    super();
+    this.tronWeb = tronWeb;
+    this.chainType = "TRX" /* TRX */;
   }
-  getDecimalsByContractAddress(chainDetailsMap, chainSymbol, contractAddress) {
-    const sourceTokenInfoWithChainDetails = chainDetailsMap[chainSymbol].tokens.find(
-      (value) => value.tokenAddress.toUpperCase() === contractAddress.toUpperCase()
+  async getTokenBalance(data) {
+    const contract = await this.getContract(data.tokenAddress);
+    const balance = await contract.balanceOf(data.account).call();
+    return balance.toString();
+  }
+  async sendTx(params) {
+    const {
+      amount,
+      contractAddress,
+      fromTokenAddress,
+      toChainId,
+      toAccountAddress,
+      toTokenAddress,
+      messenger,
+      fee
+    } = params;
+    const bridgeContract = await this.getContract(contractAddress);
+    const nonce = getNonce().toJSON().data;
+    const swapAndBridgeMethod = bridgeContract.methods.swapAndBridge(
+      fromTokenAddress,
+      amount,
+      toAccountAddress,
+      toChainId,
+      toTokenAddress,
+      nonce,
+      messenger
     );
-    if (!sourceTokenInfoWithChainDetails) {
-      throw new Error("Cannot find source token info");
+    const transactionHash = await swapAndBridgeMethod.send({
+      callValue: fee
+    });
+    await this.verifyTx(transactionHash);
+    return { txId: transactionHash };
+  }
+  async approve(approveData) {
+    const { tokenAddress, spender, owner } = approveData;
+    const tokenContract = await this.getContract(tokenAddress);
+    const transactionHash = await tokenContract.approve(spender, MAX_AMOUNT2).send({ from: owner });
+    await this.verifyTx(transactionHash);
+    return { txId: transactionHash };
+  }
+  async getAllowance(approveData) {
+    const { tokenAddress, spender, owner } = approveData;
+    const tokenContract = await this.getContract(tokenAddress);
+    const allowance = await tokenContract.allowance(owner, spender).call();
+    return allowance.toString();
+  }
+  getContract(contractAddress) {
+    return this.tronWeb.contract().at(contractAddress);
+  }
+  async verifyTx(txId, timeout = 1e4) {
+    const start = Date.now();
+    while (true) {
+      if (Date.now() - start > timeout) {
+        throw new Error("Transaction not found");
+      }
+      const result = await this.tronWeb.trx.getUnconfirmedTransactionInfo(txId);
+      if (!result?.receipt) {
+        await sleep(2e3);
+        continue;
+      }
+      if (result.receipt.result === "SUCCESS") {
+        return result;
+      } else {
+        throw new Error(`Transaction status is ${result.receipt.result}`);
+      }
     }
-    return sourceTokenInfoWithChainDetails.decimals;
   }
 };
 
@@ -51674,39 +51763,27 @@ var BridgeService = class {
   constructor(api) {
     this.api = api;
   }
-  async evmApprove(web3, approveData) {
-    const evmBridge = new EvmBridge(this.api, web3);
-    return evmBridge.approve(approveData);
+  async approve(provider, approveData) {
+    return this.getBridge(provider).approve(approveData);
+  }
+  async send(provider, params) {
+    const bridge = this.getBridge(provider);
+    const txSendParams = await prepareTxSendParams(
+      bridge.chainType,
+      params,
+      this.api
+    );
+    return bridge.sendTx(txSendParams);
   }
-  async send(web3, params) {
-    let chainType;
-    if (BridgeService.isSendParamsWithChainSymbol(params)) {
-      chainType = chainProperties[params.fromChainSymbol].chainType;
+  getBridge(provider) {
+    if (this.isTronWeb(provider)) {
+      return new TronBridge(provider);
     } else {
-      chainType = chainProperties[params.sourceChainToken.chainSymbol].chainType;
-    }
-    switch (chainType) {
-      case "EVM" /* EVM */: {
-        const evmBridge = new EvmBridge(this.api, web3);
-        return evmBridge.send(params);
-      }
-      case "SOLANA" /* SOLANA */: {
-        throw new Error(
-          `Error in send method: method not implemented for SOLANA`
-        );
-      }
-      case "TRX" /* TRX */: {
-        throw new Error(`Error in send method: method not implemented for TRX`);
-      }
-      default: {
-        throw new Error(
-          `Error in send method: unknown chain type ${chainType}, or method not implemented`
-        );
-      }
+      return new EvmBridge(provider);
     }
   }
-  static isSendParamsWithChainSymbol(params) {
-    return params.fromChainSymbol !== void 0;
+  isTronWeb(params) {
+    return params.trx !== void 0;
   }
 };
 
@@ -53625,6 +53702,12 @@ var AllbridgeCoreClient = class {
     const { data } = await this.api.get("/token-info");
     return new TokensInfo(mapChainDetailsMapFromDTO(data));
   }
+  async getTransferStatus(chainSymbol, txId) {
+    const { data } = await this.api.get(
+      `/chain/${chainSymbol}/${txId}`
+    );
+    return data;
+  }
   async getReceiveTransactionCost(args) {
     const { data } = await this.api.post(
       "/receive-fee",
@@ -53661,11 +53744,14 @@ var AllbridgeCoreSdk = class {
   async getTokensInfo() {
     return this.api.getTokensInfo();
   }
-  async evmApprove(web3, approveData) {
-    return this.bridgeService.evmApprove(web3, approveData);
+  async approve(provider, approveData) {
+    return await this.bridgeService.approve(provider, approveData);
+  }
+  async send(provider, params) {
+    return this.bridgeService.send(provider, params);
   }
-  async send(web3, params) {
-    return this.bridgeService.send(web3, params);
+  async getTransferStatus(chainSymbol, txId) {
+    return this.api.getTransferStatus(chainSymbol, txId);
   }
   calculateFeePercentOnSourceChain(amountFloat, sourceChainToken) {
     const amountInt = convertFloatAmountToInt(
@@ -53777,6 +53863,7 @@ var AllbridgeCoreSdk = class {
 export {
   AllbridgeCoreSdk,
   ChainSymbol,
+  ChainType,
   Messenger,
   TokensInfo,
   production