add across cross-chain provider

src/core/blockchain/web3-public-service/web3-public/evm-web3-public/evm-web3-public.ts

@@ -1,3 +1,4 @@
+import { AbiInput } from '@1inch/limit-order-protocol-utils';
 import BigNumber from 'bignumber.js';
 import { RubicSdkError, TimeoutError } from 'src/common/errors';
 import { nativeTokensList } from 'src/common/tokens/constants/native-tokens';
@@ -683,4 +684,22 @@ export class EvmWeb3Public extends Web3Public {
         tokens.splice(nativeTokenIndex, 0, nativeToken);
         return tokens;
     }
+
+    public async getTxDecodedData(hash: string, inputs: AbiInput[], key: string): Promise<string> {
+        const receipt = await this.getTransactionReceipt(hash);
+        let decodedData: { [key: string]: string } = {};
+
+        for (const log of receipt.logs) {
+            try {
+                const data = this.web3.eth.abi.decodeLog(inputs, log.data, log.topics);
+                if (data?.[key]) {
+                    decodedData = data;
+                }
+            } catch {
+                continue;
+            }
+        }
+
+        return decodedData[key]!;
+    }
 }

src/features/cross-chain/calculation-manager/constants/cross-chain-providers.ts

@@ -11,6 +11,7 @@ import { SquidrouterCrossChainProvider } from 'src/features/cross-chain/calculat
 import { SymbiosisCrossChainProvider } from 'src/features/cross-chain/calculation-manager/providers/symbiosis-provider/symbiosis-cross-chain-provider';
 import { XyCrossChainProvider } from 'src/features/cross-chain/calculation-manager/providers/xy-provider/xy-cross-chain-provider';
 
+import { AcrossCrossChainProvider } from '../providers/across-provider/across-cross-chain-provider';
 import { EddyBridgeProvider } from '../providers/eddy-bridge/eddy-bridge-provider';
 import { LayerZeroBridgeProvider } from '../providers/layerzero-bridge/layerzero-bridge-provider';
 import { MesonCrossChainProvider } from '../providers/meson-provider/meson-cross-chain-provider';
@@ -37,7 +38,8 @@ const proxyProviders = [
     MesonCrossChainProvider,
     OwlToBridgeProvider,
     EddyBridgeProvider,
-    RouterCrossChainProvider
+    RouterCrossChainProvider,
+    AcrossCrossChainProvider
 ] as const;
 
 const nonProxyProviders = [

src/features/cross-chain/calculation-manager/models/cross-chain-trade-type.ts

@@ -21,7 +21,8 @@ export const CROSS_CHAIN_TRADE_TYPE = {
     ARCHON_BRIDGE: 'archon_bridge',
     MESON: 'meson',
     EDDY_BRIDGE: 'eddy_bridge',
-    ROUTER: 'router'
+    ROUTER: 'router',
+    ACROSS: 'across'
 } as const;
 
 export type CrossChainTradeType =

src/features/cross-chain/calculation-manager/providers/across-provider/across-cross-chain-provider.ts

@@ -0,0 +1,158 @@
+import { MaxAmountError, MinAmountError } from 'src/common/errors';
+import { PriceToken, PriceTokenAmount } from 'src/common/tokens';
+import { wrappedAddress } from 'src/common/tokens/constants/wrapped-addresses';
+import { parseError } from 'src/common/utils/errors';
+import { BlockchainName, EvmBlockchainName } from 'src/core/blockchain/models/blockchain-name';
+import { blockchainId } from 'src/core/blockchain/utils/blockchains-info/constants/blockchain-id';
+import { Web3Pure } from 'src/core/blockchain/web3-pure/web3-pure';
+import { getFromWithoutFee } from 'src/features/common/utils/get-from-without-fee';
+
+import { RequiredCrossChainOptions } from '../../models/cross-chain-options';
+import { CROSS_CHAIN_TRADE_TYPE } from '../../models/cross-chain-trade-type';
+import { CrossChainProvider } from '../common/cross-chain-provider';
+import { CalculationResult } from '../common/models/calculation-result';
+import { FeeInfo } from '../common/models/fee-info';
+import { RubicStep } from '../common/models/rubicStep';
+import { ProxyCrossChainEvmTrade } from '../common/proxy-cross-chain-evm-facade/proxy-cross-chain-evm-trade';
+import { AcrossCrossChainTrade } from './across-cross-chain-trade';
+import {
+    AccrossCcrSupportedChains,
+    acrossCcrSupportedChains
+} from './constants/across-ccr-supported-chains';
+import { AcrossAmountLimits, AcrossFeeQuoteRequestParams } from './models/across-fee-quote';
+import { AcrossApiService } from './services/across-api-service';
+
+export class AcrossCrossChainProvider extends CrossChainProvider {
+    public readonly type = CROSS_CHAIN_TRADE_TYPE.ACROSS;
+
+    public isSupportedBlockchain(blockchain: BlockchainName): boolean {
+        return acrossCcrSupportedChains.some(supportedChain => supportedChain === blockchain);
+    }
+
+    public async calculate(
+        from: PriceTokenAmount<EvmBlockchainName>,
+        toToken: PriceToken<EvmBlockchainName>,
+        options: RequiredCrossChainOptions
+    ): Promise<CalculationResult> {
+        const fromBlockchain = from.blockchain as AccrossCcrSupportedChains;
+        const useProxy = false;
+
+        try {
+            const feeInfo = await this.getFeeInfo(
+                fromBlockchain,
+                options.providerAddress,
+                from,
+                useProxy
+            );
+            const fromWithoutFee = getFromWithoutFee(
+                from,
+                feeInfo.rubicProxy?.platformFee?.percent
+            );
+
+            const quoteRequestParams: AcrossFeeQuoteRequestParams = {
+                originChainId: blockchainId[fromBlockchain],
+                destinationChainId: blockchainId[toToken.blockchain],
+                inputToken: from.isNative ? wrappedAddress[from.blockchain]! : from.address,
+                outputToken: toToken.isNative
+                    ? wrappedAddress[toToken.blockchain]!
+                    : toToken.address,
+                amount: fromWithoutFee.stringWeiAmount,
+                skipAmountLimit: true
+            };
+
+            const quote = await AcrossApiService.getFeeQuote(quoteRequestParams);
+            const toAmount = fromWithoutFee.weiAmount.minus(quote.totalRelayFee.total);
+
+            const to = new PriceTokenAmount({
+                ...toToken.asStruct,
+                weiAmount: toAmount
+            });
+
+            const routePath = await this.getRoutePath(from, to);
+
+            const gasData =
+                options.gasCalculation === 'enabled'
+                    ? await AcrossCrossChainTrade.getGasData(
+                          from,
+                          to,
+                          feeInfo,
+                          options.providerAddress,
+                          quoteRequestParams
+                      )
+                    : null;
+
+            const trade = new AcrossCrossChainTrade(
+                {
+                    from,
+                    to,
+                    toTokenAmountMin: to.tokenAmount,
+                    priceImpact: from.calculatePriceImpactPercent(to),
+                    gasData,
+                    feeInfo,
+                    slippage: options.slippageTolerance,
+                    acrossFeeQuoteRequestParams: quoteRequestParams
+                },
+                options.providerAddress,
+                routePath
+            );
+
+            try {
+                this.checkMinMaxAmounts(from, quote.limits);
+            } catch (err) {
+                return {
+                    trade,
+                    tradeType: this.type,
+                    error: err
+                };
+            }
+
+            return {
+                trade,
+                tradeType: this.type
+            };
+        } catch (err) {
+            return {
+                trade: null,
+                tradeType: this.type,
+                error: parseError(err)
+            };
+        }
+    }
+
+    protected async getRoutePath(
+        fromToken: PriceTokenAmount,
+        toToken: PriceTokenAmount
+    ): Promise<RubicStep[]> {
+        return [{ type: 'cross-chain', provider: this.type, path: [fromToken, toToken] }];
+    }
+
+    protected async getFeeInfo(
+        fromBlockchain: AccrossCcrSupportedChains,
+        providerAddress: string,
+        percentFeeToken: PriceTokenAmount,
+        useProxy: boolean
+    ): Promise<FeeInfo> {
+        return ProxyCrossChainEvmTrade.getFeeInfo(
+            fromBlockchain,
+            providerAddress,
+            percentFeeToken,
+            useProxy
+        );
+    }
+
+    private checkMinMaxAmounts(from: PriceTokenAmount, limits: AcrossAmountLimits): void | never {
+        if (from.weiAmount.lt(limits.minDeposit)) {
+            throw new MinAmountError(
+                Web3Pure.fromWei(limits.minDeposit, from.decimals),
+                from.symbol
+            );
+        }
+
+        if (from.weiAmount.gt(limits.maxDeposit)) {
+            throw new MaxAmountError(
+                Web3Pure.fromWei(limits.maxDeposit, from.decimals),
+                from.symbol
+            );
+        }
+    }
+}