@cryptorubic/web3 0.8.16-alpha-usdt-zero-bridge.0 → 0.8.16-alpha-usdt-zero-bridge.2

package/src/lib/adapter/adapters/bitcoin-adapter.d.ts

@@ -1,18 +0,0 @@
-import { BitcoinBlockchainName, BlockchainName, HttpClient, ICustomLogger, PriceTokenAmount, Token, TokenAmount } from '@cryptorubic/core';
-import BigNumber from 'bignumber.js';
-import { AbstractAdapter } from './abstract-adapter';
-import { BasicTransactionOptions } from './models/basic-transaction-options';
-import { BtcWallet } from './models/btc-wallet-provider';
-export declare class BitcoinAdapter extends AbstractAdapter<BtcWallet, BtcWallet, BitcoinBlockchainName> {
-    private readonly httpClient;
-    constructor(httpClient: HttpClient, logger?: ICustomLogger);
-    getBalance(userAddress: string): Promise<BigNumber>;
-    getPublicKey(userAddress: string): Promise<string | null>;
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
-    read<T>(args: unknown): Promise<T>;
-    write(args: unknown): Promise<string>;
-    getPublicKeyFromWallet(): Promise<string>;
-    transfer(recipient: string, amount: string, fromAddress: string, memo?: string, options?: BasicTransactionOptions): Promise<string>;
-    sendPsbtTransaction(psbt: string, userAddress: string, inputIndexes: number[], options?: BasicTransactionOptions): Promise<string>;
-}

package/src/lib/adapter/adapters/evm-adapter.d.ts

@@ -1,59 +0,0 @@
-import { Abi, MulticallResponse, MulticallParameters, PublicActions, PublicClient, WalletClient, WalletActions, BlockNumber, BlockTag, GetBlockReturnType } from 'viem';
-import { AbstractAdapter } from './abstract-adapter';
-import { EvmBlockchainName, ICustomLogger, Token, TokenAmount, PriceTokenAmount } from '@cryptorubic/core';
-import BigNumber from 'bignumber.js';
-import { EvmAdapterOptions } from './models/evm-adapter-options';
-import { EvmTransactionConfig } from '../../utils/models/evm-transaction-config';
-import { ApproveAdapter } from './models/approve-adapter';
-import { AllowanceInfo } from './models/common-types';
-import { GasPrice } from './models/gas-price';
-export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicClient, WalletClient & WalletActions, EvmBlockchainName> implements ApproveAdapter<EvmTransactionConfig> {
-    needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
-    handlePreswap(contractAddress: string, walletAddress: string, tokenAmount: TokenAmount): Promise<void>;
-    constructor(adapterOptions: EvmAdapterOptions, logger?: ICustomLogger);
-    protected createPublicClient(rpcList: string[]): (PublicActions & PublicClient) | null;
-    read<T>(address: string, abi: Abi, method: string, methodArgs?: unknown[]): Promise<T>;
-    writeContract(address: string, abi: Abi, method: string, value?: string, methodArgs?: unknown[]): Promise<string>;
-    write(address: string, to: string, value: string, data: string): Promise<string>;
-    multicallByContract<T>(contracts: MulticallParameters, allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    multicallByAddress<T>(address: string, abi: Abi, method: string, methodArgs?: unknown[][], allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    static encodeMethodCall(contractAddress: string, contractAbi: Abi, method: string, parameters?: unknown[], value?: string): EvmTransactionConfig;
-    simulateTransaction(config: EvmTransactionConfig, from: string, timeout?: number): Promise<string>;
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<EvmBlockchainName>[]>;
-    getGasPrice(): Promise<string>;
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string, amount?: BigNumber): Promise<boolean>;
-    /**
-     * @param walletAddress
-     * @param tokenAddress
-     * @returns wei amount
-     */
-    getBalance(walletAddress: string, tokenAddress?: string): Promise<BigNumber>;
-    getTransactionCount(walletAddress: string): Promise<number>;
-    getAllowance(fromTokenAddress: string, walletAddress: string, spenderAddress: string): Promise<AllowanceInfo>;
-    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): EvmTransactionConfig;
-    needApprove(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
-    approve(fromAddress: string, tokenAddress: string, spenderAddress: string, amount?: string): Promise<string>;
-    needPermit2Approve(token: TokenAmount, permit2Address: string, walletAddress: string, spenderAddress: string): Promise<boolean>;
-    encodePermit2Approve(tokenAddress: string, spenderAddress: string, permit2Address: string, expiration: string, amount: string): EvmTransactionConfig;
-    approveOnPermit2(fromAddress: string, tokenAddress: string, permit2Address: string, spenderAddress: string, deadline?: BigNumber, amount?: BigNumber): Promise<string>;
-    /**
-     * Calculates EIP-1559 specific gas details.
-     * @see {@link https://github.com/ethers-io/ethers.js/blob/master/packages/abstract-provider/src.ts/index.ts#L235}
-     * @returns block baseFee, average maxPriorityFeePerGas, and maxFeePerGas.
-     */
-    getPriorityFeeGas(): Promise<GasPrice>;
-    /**
-     * Gets block by block id.
-     * @param [blockId] Block id: hash, number ... Default is 'latest'.
-     * @returns Block by blockId parameter.
-     */
-    getBlock(blockType?: BlockNumber | BlockTag): Promise<GetBlockReturnType>;
-    /**
-     * Estimates average maxPriorityFeePerGas for EIP-1559 transactions based on last 20 blocks.
-     * @see {@link https://docs.alchemy.com/docs/how-to-build-a-gas-fee-estimator-using-eip-1559}
-     * @returns Average maxPriorityFeePerGas in wei
-     */
-    getMaxPriorityFeePerGas(): Promise<number>;
-    getBaseFeePerGas(blockNumber: bigint): Promise<number>;
-    private handlePossibleError;
-}

package/src/lib/adapter/adapters/solana-adapter.d.ts

@@ -1,35 +0,0 @@
-import { Abi, MulticallResponse, MulticallParameters } from 'viem';
-import { AbstractAdapter } from './abstract-adapter';
-import { AddressLookupTableAccount, Connection, Keypair, PublicKey, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
-import { HttpClient, ICustomLogger, PriceTokenAmount, SolanaBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
-import { EvmTransactionConfig } from '../../utils/models/evm-transaction-config';
-import BigNumber from 'bignumber.js';
-import { SolanaRawInstruction } from './models/solana-web3-types';
-export declare const NATIVE_SOLANA_MINT_ADDRESS = "So11111111111111111111111111111111111111111";
-export declare class SolanaAdapter extends AbstractAdapter<Connection, Connection, SolanaBlockchainName> {
-    private readonly httpClient;
-    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger);
-    private createPublicClient;
-    read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    multicallByContract<T>(_contracts: MulticallParameters, _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    multicallByAddress<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[][], _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    simulateTransaction(_config: EvmTransactionConfig, _from: string): Promise<void>;
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    getBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
-    /**
-     * Gets balance of multiple tokens.
-     * @param address Wallet address.
-     * @param tokensAddresses Tokens addresses.
-     */
-    getTokensBalances(address: string, tokensAddresses: string[]): Promise<BigNumber[]>;
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<SolanaBlockchainName>[]>;
-    parseRawInstruction(rawInstruction: SolanaRawInstruction[], dataFormat: BufferEncoding): TransactionInstruction[];
-    parseLUTAddresses(lookupTableAddresses: string[]): Promise<AddressLookupTableAccount[]>;
-    createVersionedTransaction(instructions: TransactionInstruction[], walletAddress: string, addressLookupTableAccounts?: AddressLookupTableAccount[]): Promise<VersionedTransaction>;
-    getAtaAddress(walletAddress: string, tokenAddress: string): Promise<PublicKey>;
-    getKeypairFromSecret(pk?: string): Keypair | null;
-    getTxWithPayer(tx: VersionedTransaction, feePayer: string): Promise<VersionedTransaction>;
-    deserializeTransaction(data: string): VersionedTransaction;
-    serializeTransactionToBase58(tx: VersionedTransaction): string;
-}

package/src/lib/adapter/adapters/sui-adapter.d.ts

@@ -1,17 +0,0 @@
-import { Abi, MulticallResponse, MulticallParameters } from 'viem';
-import { AbstractAdapter } from './abstract-adapter';
-import { ICustomLogger, PriceTokenAmount, SuiBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
-import { EvmTransactionConfig } from '../../utils/models/evm-transaction-config';
-import { SuiClient } from '@mysten/sui/client';
-import BigNumber from 'bignumber.js';
-export declare class SuiAdapter extends AbstractAdapter<SuiClient, SuiClient, SuiBlockchainName> {
-    constructor(rpcList: string[], logger?: ICustomLogger);
-    read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    multicallByContract<T>(_contracts: MulticallParameters, _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    multicallByAddress<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[][], _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    simulateTransaction(_config: EvmTransactionConfig, _from: string): Promise<void>;
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<SuiBlockchainName>[]>;
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    getBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
-}

package/src/lib/adapter/adapters/ton-adapter.d.ts

@@ -1,22 +0,0 @@
-import { BlockchainName, HttpClient, ICustomLogger, PriceTokenAmount, Token, TokenAmount, TonBlockchainName } from '@cryptorubic/core';
-import { Address, TonClient } from '@ton/ton';
-import { TonApiParseAddressResp } from './models/tonapi-models';
-import { TonAdapterConfig } from './models/ton-adapter-config';
-import BigNumber from 'bignumber.js';
-import { TonTransactionConfig } from '../../utils/models/ton-transaction-config';
-import { AbstractAdapter } from './abstract-adapter';
-export declare class TonAdapter extends AbstractAdapter<TonClient, TonClient, TonBlockchainName> {
-    private readonly tonApi;
-    readonly tonClient: TonClient;
-    constructor(httpClient: HttpClient, config: TonAdapterConfig, logger?: ICustomLogger);
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
-    read<T>(args: unknown): Promise<T>;
-    write(args: unknown): Promise<string>;
-    getAllFormatsOfAddress(walletAddress: string): Promise<TonApiParseAddressResp>;
-    getWalletAddress(address: Address, contractAddress: Address): Promise<Address>;
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    getBalance(walletAddress: string, tokenAddress?: string): Promise<BigNumber>;
-    getTransferEncodedConfig(tokenAddress: string, walletAddress: string, receiver: string, amount: string): Promise<TonTransactionConfig>;
-    private getTransferNativeConfig;
-    private getTransferJettonConfig;
-}

package/src/lib/adapter/adapters/ton-adapter.js

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TonAdapter = void 0;
-const core_1 = require("@cryptorubic/core");
-const ton_api_service_1 = require("./utils/ton-api.service");
-const ton_1 = require("@ton/ton");
-const bignumber_js_1 = require("bignumber.js");
-const abstract_adapter_1 = require("./abstract-adapter");
-const web3_pure_1 = require("../../utils/web3-pure");
-class TonAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(httpClient, config, logger) {
-        super(core_1.BLOCKCHAIN_NAME.TON, logger);
-        this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig);
-        this.tonClient = new ton_1.TonClient(config.tonClientConfig);
-    }
-    async callForTokensInfo(tokenAddresses) {
-        const info = await Promise.all(tokenAddresses.map((address) => {
-            if (web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.TON, address)) {
-                const nativeToken = core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.TON];
-                return nativeToken;
-            }
-            return this.tonApi.fetchTokenInfo(address);
-        }));
-        if (!info.length)
-            return [];
-        const necessaryInfo = info.map(({ decimals, name, symbol, address }) => new core_1.Token({
-            address,
-            blockchain: core_1.BLOCKCHAIN_NAME.TON,
-            decimals: Number(decimals),
-            name,
-            symbol
-        }));
-        return necessaryInfo;
-    }
-    read(args) {
-        throw new Error('Not implemented');
-    }
-    write(args) {
-        throw new Error('Not implemented');
-    }
-    async getAllFormatsOfAddress(walletAddress) {
-        return this.tonApi.getAllFormatsOfAddress(walletAddress);
-    }
-    async getWalletAddress(address, contractAddress) {
-        const addressResult = await this.tonClient.runMethod(contractAddress, 'get_wallet_address', [
-            { cell: (0, ton_1.beginCell)().storeAddress(address).endCell(), type: 'slice' }
-        ]);
-        return addressResult.stack.readAddress();
-    }
-    async checkEnoughBalance(token, walletAddress) {
-        const weiBalance = await this.getBalance(walletAddress, token.address);
-        const balance = core_1.Token.fromWei(weiBalance, token.decimals);
-        return balance.gte(token.tokenAmount);
-    }
-    async getBalance(walletAddress, tokenAddress) {
-        const isNative = !tokenAddress || web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.TON, tokenAddress);
-        const tokenBalance = isNative
-            ? (await this.tonApi.fetchAccountInfo(walletAddress)).balance
-            : (await this.tonApi.fetchTokenInfoForWallet(walletAddress, tokenAddress)).balance;
-        return new bignumber_js_1.default(tokenBalance || 0);
-    }
-    getTransferEncodedConfig(tokenAddress, walletAddress, receiver, amount) {
-        if ((0, core_1.compareAddresses)(core_1.nativeTokensList.TON.address, tokenAddress)) {
-            return this.getTransferNativeConfig(receiver, amount);
-        }
-        return this.getTransferJettonConfig(tokenAddress, walletAddress, receiver, amount);
-    }
-    async getTransferNativeConfig(receiver, amount) {
-        const transferAmount = BigInt(amount);
-        const encodeConfig = {
-            address: receiver,
-            amount: transferAmount.toString()
-        };
-        return encodeConfig;
-    }
-    async getTransferJettonConfig(tokenAddress, walletAddress, receiver, amount) {
-        const fromAddress = ton_1.Address.parse(walletAddress);
-        const contractAddress = ton_1.Address.parse(tokenAddress);
-        const transferAmount = BigInt(amount);
-        const receiverAddress = ton_1.Address.parse(receiver);
-        const jettonWalletAddress = await this.getWalletAddress(fromAddress, contractAddress);
-        const body = (0, ton_1.beginCell)()
-            .storeUint(0xf8a7ea5, 32)
-            .storeUint(0, 64)
-            .storeCoins(transferAmount)
-            .storeAddress(receiverAddress)
-            .storeAddress(receiverAddress)
-            .storeBit(0)
-            .storeCoins((0, ton_1.toNano)('0.02'))
-            .storeBit(0)
-            .endCell();
-        const encodeConfig = {
-            address: jettonWalletAddress.toRawString(),
-            amount: (0, ton_1.toNano)('0.05').toString(),
-            payload: body.toBoc().toString('base64')
-        };
-        return encodeConfig;
-    }
-}
-exports.TonAdapter = TonAdapter;

package/src/lib/adapter/adapters/tron-adapter.d.ts

@@ -1,36 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { AbstractAdapter } from './abstract-adapter';
-import { ContractMulticallResponse, MethodData, TronWeb3PrimitiveType } from '@cryptorubic/tron-types';
-import { TronWeb } from 'tronweb';
-import { AbiFragment } from 'tronweb/lib/commonjs/types';
-import { ICustomLogger, PriceTokenAmount, Token, TokenAmount, TronBlockchainName } from '@cryptorubic/core';
-import { TronTransactionConfig } from '../../utils/models/tron-transaction-config';
-import { TronParameters } from '../../utils/models/tron-parameters';
-import { Abi } from 'viem';
-import { ApproveAdapter } from './models/approve-adapter';
-import { AllowanceInfo } from './models/common-types';
-export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> implements ApproveAdapter<TronTransactionConfig> {
-    private readonly multicallAddress;
-    needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
-    constructor(rpcList: string[], logger?: ICustomLogger);
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    multicallContractsMethods<Output extends TronWeb3PrimitiveType>(contractAbi: readonly AbiFragment[], contractsData: {
-        contractAddress: string;
-        methodsData: MethodData[];
-    }[]): Promise<ContractMulticallResponse<Output>[][]>;
-    private multicall;
-    read<T>(contractAddress: string, contractAbi: readonly AbiFragment[], methodName: string, methodArguments?: unknown[]): Promise<T>;
-    private multicallContractsMethodsByOne;
-    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token[]>;
-    getBalance(userAddress: string, tokenAddress?: string): Promise<BigNumber>;
-    getTokenBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
-    convertTronAddressToHex(address: string): Promise<string>;
-    static encodeMethodCall(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments: TronParameters, callValue?: string, feeLimit?: number): TronTransactionConfig;
-    private static flattenTypesToString;
-    needApprove(from: TokenAmount | PriceTokenAmount, walletAddress: string, spender: string): Promise<boolean>;
-    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): TronTransactionConfig;
-    getAllowance(fromTokenAddress: string, walletAddress: string, spender: string): Promise<AllowanceInfo>;
-    write(contractAddress: string, methodSignature: string, parameters: TronParameters): Promise<string>;
-    approve(fromAddress: string, tokenAddress: string, spenderAddress: string, amount?: string): Promise<string>;
-}