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

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonAdapterSigner = void 0;
+const core_1 = require("@cryptorubic/core");
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
+const user_reject_error_1 = require("../../../../errors/blockchain/user-reject.error");
+const rubic_sdk_error_1 = require("../../../../errors/rubic-sdk.error");
+const errors_1 = require("../../utils/errors");
+const core_2 = require("@ton/core");
+const waitFor_1 = require("../../utils/waitFor");
+class TonAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    get publicClient() {
+        if (!this.publicRef.public) {
+            const msg = `Trying to access undefined publicClient in TonAdapterSigner.`;
+            this.logger?.customLog(msg);
+            throw new Error(msg);
+        }
+        return this.publicRef.public;
+    }
+    constructor(tonApi, publicRef, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+        this.tonApi = tonApi;
+        this.publicRef = publicRef;
+    }
+    async write() {
+        throw new Error('Method write is not supported');
+    }
+    getBlockchainName() {
+        return Promise.resolve(core_1.BLOCKCHAIN_NAME.TON);
+    }
+    async sendTransaction(params) {
+        try {
+            const { boc } = await this.wallet.sendTransaction({
+                validUntil: Math.floor(Date.now() / 1000) + 360,
+                messages: params.txOptions.messages
+            });
+            const txHash = this.fromBocToBase64Hash(boc);
+            params.txOptions.onTransactionHash?.(txHash);
+            const isCompleted = await this.waitForTransactionReceipt(txHash);
+            if (!isCompleted) {
+                throw new rubic_sdk_error_1.RubicSdkError('[BitcoinWeb3Private] TON transaction timeout expired!');
+            }
+            return boc;
+        }
+        catch (err) {
+            console.error(`Send transaction error. ${err}`);
+            if (err.message.includes('Reject request')) {
+                throw new user_reject_error_1.UserRejectError();
+            }
+            throw (0, errors_1.parseError)(err);
+        }
+    }
+    async waitForTransactionReceipt(txHash) {
+        let isCompleted = false;
+        const startTimeMS = Date.now();
+        const timeLimitMS = 600 * 1000;
+        while (Date.now() < startTimeMS + timeLimitMS) {
+            if (isCompleted)
+                return true;
+            await (0, waitFor_1.waitFor)(30000);
+            isCompleted = await this.tonApi.checkIsTxCompleted(txHash);
+        }
+        return false;
+    }
+    /**
+     * Transfer asset from on wallet to another
+     * @param tokenAddress Token address to transfer
+     * @param walletAddress Wallet address to transfer from
+     * @param receiver Receiver wallet address
+     * @param amount Transfer amount
+     * @param options Transaction options
+     */
+    transferAsset(tokenAddress, walletAddress, receiver, amount, options) {
+        if ((0, core_1.compareAddresses)(core_1.nativeTokensList.TON.address, tokenAddress)) {
+            return this.transferNative(receiver, amount, options);
+        }
+        return this.transferJetton(tokenAddress, walletAddress, receiver, amount, options);
+    }
+    transferNative(receiver, amount, options) {
+        const transferAmount = BigInt(amount);
+        const encodeConfig = {
+            address: receiver,
+            amount: transferAmount.toString()
+        };
+        return this.sendTransaction({ txOptions: { messages: [encodeConfig], onTransactionHash: options?.onTransactionHash } });
+    }
+    async transferJetton(tokenAddress, walletAddress, receiver, amount, options) {
+        const fromAddress = core_2.Address.parse(walletAddress);
+        const contractAddress = core_2.Address.parse(tokenAddress);
+        const transferAmount = BigInt(amount);
+        const receiverAddress = core_2.Address.parse(receiver);
+        const jettonWalletAddress = await this.getJettonWalletAddress(fromAddress, contractAddress);
+        const body = (0, core_2.beginCell)()
+            .storeUint(0xf8a7ea5, 32)
+            .storeUint(0, 64)
+            .storeCoins(transferAmount)
+            .storeAddress(receiverAddress)
+            .storeAddress(receiverAddress)
+            .storeBit(0)
+            .storeCoins((0, core_2.toNano)('0.02'))
+            .storeBit(0)
+            .endCell();
+        const encodeConfig = {
+            address: jettonWalletAddress.toRawString(),
+            amount: (0, core_2.toNano)('0.05').toString(),
+            payload: body.toBoc().toString('base64')
+        };
+        return this.sendTransaction({ txOptions: { messages: [encodeConfig], onTransactionHash: options?.onTransactionHash } });
+    }
+    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 = core_2.Address.parse(walletAddress);
+        const contractAddress = core_2.Address.parse(tokenAddress);
+        const transferAmount = BigInt(amount);
+        const receiverAddress = core_2.Address.parse(receiver);
+        const jettonWalletAddress = await this.getJettonWalletAddress(fromAddress, contractAddress);
+        const body = (0, core_2.beginCell)()
+            .storeUint(0xf8a7ea5, 32)
+            .storeUint(0, 64)
+            .storeCoins(transferAmount)
+            .storeAddress(receiverAddress)
+            .storeAddress(receiverAddress)
+            .storeBit(0)
+            .storeCoins((0, core_2.toNano)('0.02'))
+            .storeBit(0)
+            .endCell();
+        const encodeConfig = {
+            address: jettonWalletAddress.toRawString(),
+            amount: (0, core_2.toNano)('0.05').toString(),
+            payload: body.toBoc().toString('base64')
+        };
+        return encodeConfig;
+    }
+    /**
+     *
+     * @param boc Boc returned in connector.sendTransaction
+     * @returns boc converter in base 64 string
+     */
+    fromBocToBase64Hash(boc) {
+        const inMsgCell = core_2.Cell.fromBase64(boc);
+        const inMsgHash = inMsgCell.hash();
+        const inMsgHashBase64 = inMsgHash.toString('base64');
+        const inMsgHashBase64Url = inMsgHashBase64.replace(/\+/g, '-').replace(/\//g, '_');
+        return inMsgHashBase64Url;
+    }
+    async getJettonWalletAddress(address, contractAddress) {
+        const addressResult = await this.publicClient.runMethod(contractAddress, 'get_wallet_address', [
+            { type: 'slice', cell: (0, core_2.beginCell)().storeAddress(address).endCell() }
+        ]);
+        return addressResult.stack.readAddress();
+    }
+}
+exports.TonAdapterSigner = TonAdapterSigner;

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

@@ -0,0 +1,32 @@
+import { BlockchainName, HttpClient, ICustomLogger, PriceTokenAmount, Token, TokenAmount, TonBlockchainName } from '@cryptorubic/core';
+import { TonClient } from '@ton/ton';
+import { TonApiParseAddressResp } from '../models/tonapi-models';
+import { TonAdapterConfig } from '../models/ton-adapter-config';
+import BigNumber from 'bignumber.js';
+import { AbstractAdapter } from '../common/abstract-adapter';
+import { TonConnectUI } from '@tonconnect/ui';
+import { TonAdapterSigner } from './signer/ton-adapter-signer';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
+import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
+import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
+import { TxStatus } from '../models/web3-public-models/tx-status';
+export declare class TonAdapter extends AbstractAdapter<TonClient, TonConnectUI, TonBlockchainName> {
+    private readonly config;
+    readonly signer: TonAdapterSigner;
+    private readonly tonApi;
+    constructor(httpClient: HttpClient, config: TonAdapterConfig, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    initWeb3Client(): void;
+    read<T>(): Promise<T>;
+    callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
+    getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    multicallContractsMethods<Output extends Web3PrimitiveType>(): Promise<ContractMulticallResponse<Output>[][]>;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
+    getAllFormatsOfAddress(walletAddress: string): Promise<TonApiParseAddressResp>;
+    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
+    getBalance(walletAddress: string, tokenAddress?: string): Promise<BigNumber>;
+}

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonAdapter = void 0;
+const core_1 = require("@cryptorubic/core");
+const ton_api_service_1 = require("./services/ton-api.service");
+const ton_1 = require("@ton/ton");
+const bignumber_js_1 = require("bignumber.js");
+const abstract_adapter_1 = require("../common/abstract-adapter");
+const web3_pure_1 = require("../../../utils/web3-pure");
+const ton_adapter_signer_1 = require("./signer/ton-adapter-signer");
+const tx_status_1 = require("../models/web3-public-models/tx-status");
+class TonAdapter extends abstract_adapter_1.AbstractAdapter {
+    constructor(httpClient, config, logger, clientParams) {
+        super(core_1.BLOCKCHAIN_NAME.TON, logger);
+        this.config = config;
+        this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig, logger);
+        this.signer = new ton_adapter_signer_1.TonAdapterSigner(this.tonApi, this.publicRef, httpClient, logger, clientParams);
+    }
+    initWeb3Client() {
+        this.public = new ton_1.TonClient(this.config.tonClientConfig);
+    }
+    async read() {
+        throw new Error('Method read is not supported');
+    }
+    async callContractMethod() {
+        throw new Error('Method call is not supported');
+    }
+    async getTransactionStatus(srcTxHash) {
+        const isCompleted = await this.tonApi.checkIsTxCompleted(srcTxHash);
+        if (isCompleted) {
+            return tx_status_1.TX_STATUS.SUCCESS;
+        }
+        return tx_status_1.TX_STATUS.PENDING;
+    }
+    async getTokensBalances(userAddress, tokensAddresses) {
+        const tokensWithBalance = await this.tonApi.fetchAllNonNullableTokensInfoForWallet(userAddress);
+        const nativeIndex = tokensAddresses.findIndex((tokenAddress) => web3_pure_1.Web3Pure.isNativeAddress('TON', tokenAddress));
+        if (!tokensWithBalance.length && nativeIndex === -1) {
+            return [];
+        }
+        const balances = tokensAddresses
+            .filter((tokenAddress) => !web3_pure_1.Web3Pure.isNativeAddress('TON', tokenAddress))
+            .map((address) => {
+            const tokenWithBalance = tokensWithBalance.find((token) => token.jetton.address.toLowerCase() === ton_1.Address.parse(address).toRawString().toLowerCase());
+            if (tokenWithBalance) {
+                return new bignumber_js_1.default(tokenWithBalance.balance);
+            }
+            return new bignumber_js_1.default(0);
+        });
+        if (nativeIndex !== -1) {
+            const acountInfo = await this.tonApi.fetchAccountInfo(userAddress);
+            const nativeBalance = new bignumber_js_1.default(acountInfo.balance);
+            balances.splice(nativeIndex, 0, nativeBalance);
+        }
+        return balances;
+    }
+    multicallContractsMethods() {
+        throw new Error('Method not implemented.');
+    }
+    async getBlockNumber() {
+        try {
+            const block = await this.tonApi.fetchLastBlockInfo();
+            return block.seqno;
+        }
+        catch {
+            return 0;
+        }
+    }
+    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;
+    }
+    async getAllFormatsOfAddress(walletAddress) {
+        return this.tonApi.getAllFormatsOfAddress(walletAddress);
+    }
+    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);
+    }
+}
+exports.TonAdapter = TonAdapter;

package/src/lib/adapter/adapters/adapter-tron/models/tron-send-tx-params.d.ts

@@ -0,0 +1,13 @@
+import { TronParameters } from '../../../../utils/models/tron-parameters';
+import { BasicSendTransactionOptions } from '../../models/basic-transaction-options';
+export interface TronSendTxParams {
+    contractAddress: string;
+    methodSignature: string;
+    parameters: TronParameters;
+    txOptions: TronTransactionOptions;
+}
+export interface TronTransactionOptions extends BasicSendTransactionOptions {
+    feeLimit?: number;
+    callValue?: number;
+    rawParameter?: string;
+}

package/src/lib/adapter/adapters/adapter-tron/models/tron-send-tx-params.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/lib/adapter/adapters/adapter-tron/models/tron-web-provider.d.ts

@@ -0,0 +1,4 @@
+export interface TronWebProvider {
+    fullHost: string;
+    headers?: Record<string, string>;
+}

package/src/lib/adapter/adapters/adapter-tron/models/tron-web-provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,17 @@
+import { TronWeb } from 'tronweb';
+import { AbstractAdapterSigner } from '../../common/signer/abstract-adapter-signer';
+import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
+import { TronSendTxParams } from '../models/tron-send-tx-params';
+import { TronParameters } from '../../../../utils/models/tron-parameters';
+export declare class TronAdapterSigner extends AbstractAdapterSigner<TronWeb, TronSendTxParams, string> {
+    private readonly publicRef;
+    get publicClient(): TronWeb;
+    constructor(publicRef: {
+        public: TronWeb | null;
+    }, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    write(contractAddress: string, methodSignature: string, parameters: TronParameters): Promise<string>;
+    getBlockchainName(): Promise<BlockchainName>;
+    sendTransaction(params: TronSendTxParams): Promise<string>;
+    trySendTransaction(params: TronSendTxParams): Promise<string>;
+}

package/src/lib/adapter/adapters/adapter-tron/signer/tron-adapter-signer.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TronAdapterSigner = void 0;
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
+const core_1 = require("@cryptorubic/core");
+const parse_tron_error_1 = require("../utils/parse-tron-error");
+class TronAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    get publicClient() {
+        if (!this.publicRef.public) {
+            const msg = `Trying to access undefined publicClient in TronAdapterSigner.`;
+            this.logger?.customLog(msg);
+            throw new Error(msg);
+        }
+        return this.publicRef.public;
+    }
+    constructor(publicRef, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+        this.publicRef = publicRef;
+    }
+    async write(contractAddress, methodSignature, parameters) {
+        const transaction = await this.wallet.transactionBuilder.triggerSmartContract(contractAddress, methodSignature, {}, parameters, this.walletAddress);
+        const signedTransaction = await this.wallet.trx.sign(transaction.transaction);
+        const receipt = await this.wallet.trx.sendRawTransaction(signedTransaction);
+        return receipt.transaction.txID;
+    }
+    getBlockchainName() {
+        return Promise.resolve(core_1.BLOCKCHAIN_NAME.TRON);
+    }
+    async sendTransaction(params) {
+        try {
+            const transaction = await this.wallet.transactionBuilder.triggerSmartContract(params.contractAddress, params.methodSignature, params.txOptions, params.parameters, this.walletAddress);
+            const signedTransaction = await this.wallet.trx.sign(transaction.transaction);
+            const receipt = await this.wallet.trx.sendRawTransaction(signedTransaction);
+            if (params.txOptions.onTransactionHash) {
+                params.txOptions.onTransactionHash(receipt.transaction.txID);
+            }
+            return receipt.transaction.txID;
+        }
+        catch (err) {
+            console.error('Method execution error: ', err);
+            throw (0, parse_tron_error_1.parseTronError)(err);
+        }
+    }
+    async trySendTransaction(params) {
+        try {
+            await this.wallet.transactionBuilder.estimateEnergy(params.contractAddress, params.methodSignature, {}, params.parameters, this.walletAddress);
+        }
+        catch (err) {
+            const errMessage = typeof err === 'object' ? err.message : err;
+            if (errMessage !== 'this node does not support estimate energy') {
+                throw new Error('Tron transaction simulation error');
+            }
+        }
+        return this.sendTransaction(params);
+    }
+}
+exports.TronAdapterSigner = TronAdapterSigner;

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

@@ -0,0 +1,57 @@
+import BigNumber from 'bignumber.js';
+import { AbstractAdapter } from '../common/abstract-adapter';
+import { TronWeb } from 'tronweb';
+import { HttpClient, 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 { ContractMulticallResponse } from '../../../utils/models/contract-multicall-response';
+import { TronWeb3PrimitiveType, Web3PrimitiveType } from '../../../utils/models/primitive-types';
+import { MethodData } from '../../../utils/models/method-data';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
+import { TronAdapterSigner } from './signer/tron-adapter-signer';
+import { TronTransactionOptions } from './models/tron-send-tx-params';
+import { AllowanceInfo } from '../models/common-types';
+import { ApprovableAdapter } from '../models/approve-adapter';
+import { TxStatus } from '../models/web3-public-models/tx-status';
+export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> implements ApprovableAdapter<TronTransactionConfig> {
+    private readonly rpcList;
+    readonly signer: TronAdapterSigner;
+    private readonly multicallAddress;
+    needPreswapAction(): Promise<boolean>;
+    constructor(rpcList: (string | {
+        fullHost: string;
+    })[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    initWeb3Client(): void;
+    callContractMethod<T extends Web3PrimitiveType = string>(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments?: unknown[]): Promise<T>;
+    getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    /**
+     * Gets mined transaction info.
+     * @param hash Transaction hash.
+     */
+    private getTransactionInfo;
+    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    private batchMulticallTokenBalance;
+    multicallContractsMethods<Output extends TronWeb3PrimitiveType>(contractAbi: any, contractsData: {
+        contractAddress: string;
+        methodsData: MethodData[];
+    }[]): Promise<ContractMulticallResponse<any>[][]>;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
+    private multicall;
+    private multicallContractsMethodsByOne;
+    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;
+    read<T>(contractAddress: string, contractAbi: any, methodName: string, methodArguments?: unknown[]): Promise<T>;
+    private static flattenTypesToString;
+    getAllowance(fromTokenAddress: string, ownerAddress: string, spenderAddress: string): Promise<AllowanceInfo>;
+    needApprove(from: TokenAmount, walletAddress: string, spender: string): Promise<boolean>;
+    approveTokens(tokenAddress: string, spenderAddress: string, amount?: BigNumber | 'infinity', options?: TronTransactionOptions): Promise<string>;
+    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): TronTransactionConfig;
+}