@allbridge/bridge-core-sdk 0.4.2 → 0.6.0

package/dist/cjs/index.js

@@ -10595,13 +10595,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) {
@@ -10626,18 +10626,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;
   }
 });
 
@@ -61648,6 +61648,7 @@ var src_exports = {};
 __export(src_exports, {
   AllbridgeCoreSdk: () => AllbridgeCoreSdk,
   ChainSymbol: () => ChainSymbol,
+  ChainType: () => ChainType,
   Messenger: () => Messenger,
   TokensInfo: () => TokensInfo,
   production: () => production
@@ -62178,46 +62179,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());
 
@@ -62447,8 +62408,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_randombytes());
+var TronWebLib = __toESM(require_TronWeb_node());
 
 // src/utils/calculation/constants.ts
 var SYSTEM_PRECISION = 3;
@@ -62552,18 +62570,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) {
@@ -62596,7 +62603,7 @@ function formatAddress(address, from, to) {
       );
     }
     case "TRX" /* TRX */: {
-      return buffer.toString();
+      return buffer.toJSON().data;
     }
     default: {
       throw new Error(
@@ -62629,6 +62636,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 = [
@@ -63329,73 +63414,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;
   }
-  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);
+  chainType = "EVM" /* EVM */;
+  async getTokenBalance(data) {
+    return await this.getContract(abi_default, data.tokenAddress).methods.balanceOf(data.account).call();
   }
   async sendTx(params) {
     const {
@@ -63410,7 +63435,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,
@@ -63456,17 +63481,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;
+  }
+  chainType = "TRX" /* TRX */;
+  async getTokenBalance(data) {
+    const contract = await this.getContract(data.tokenAddress);
+    const balance = await contract.balanceOf(data.account).call();
+    return balance.toString();
   }
-  getDecimalsByContractAddress(chainDetailsMap, chainSymbol, contractAddress) {
-    const sourceTokenInfoWithChainDetails = chainDetailsMap[chainSymbol].tokens.find(
-      (value) => value.tokenAddress.toUpperCase() === contractAddress.toUpperCase()
+  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;
   }
 };
 
@@ -63475,39 +63565,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;
   }
 };
 
@@ -66070,6 +66148,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",
@@ -66108,11 +66192,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(
@@ -66225,6 +66312,7 @@ var AllbridgeCoreSdk = class {
 0 && (module.exports = {
   AllbridgeCoreSdk,
   ChainSymbol,
+  ChainType,
   Messenger,
   TokensInfo,
   production