@cryptorubic/web3 0.15.0-alpha-stellar.0 → 1.0.0-alpha-rub-1103.0

package/src/lib/adapter/adapters/{solana-adapter.js → adapter-solana/solana-adapter.js}

@@ -1,56 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaAdapter = exports.NATIVE_SOLANA_MINT_ADDRESS = void 0;
+exports.SolanaAdapter = void 0;
 const spl_token_1 = require("@solana/spl-token");
-const abstract_adapter_1 = require("./abstract-adapter");
 const web3_js_1 = require("@solana/web3.js");
 const core_1 = require("@cryptorubic/core");
-const web3_pure_1 = require("../../utils/web3-pure");
 const bignumber_js_1 = require("bignumber.js");
-const solana_tokens_service_1 = require("./utils/solana-tokens-service");
 const bs58_1 = require("bs58");
 const js_base64_1 = require("js-base64");
-exports.NATIVE_SOLANA_MINT_ADDRESS = 'So11111111111111111111111111111111111111111';
+const abstract_adapter_1 = require("../common/abstract-adapter");
+const web3_pure_1 = require("../../../utils/web3-pure");
+const solana_tokens_service_1 = require("./services/solana-tokens-service");
+const solana_adapter_signer_1 = require("./signer/solana-adapter-signer");
+const tx_status_1 = require("../models/web3-public-models/tx-status");
 class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(rpcList, httpClient, logger) {
+    constructor(rpcList, httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
+        this.rpcList = rpcList;
         this.httpClient = httpClient;
-        this.public = this.createPublicClient(rpcList);
+        this.signer = new solana_adapter_signer_1.SolanaAdapterSigner(this.publicRef, httpClient, logger, clientParams);
     }
-    createPublicClient(rpcList) {
-        if (!rpcList?.[0]) {
-            this.logger?.customError('RPC list is empty');
-            return null;
-        }
-        else {
-            return new web3_js_1.Connection(rpcList[0], 'confirmed');
-        }
+    initWeb3Client() {
+        this.public = this.createConection(this.rpcList);
     }
-    async read(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method multicall is not supported');
+    async callContractMethod() {
+        throw new Error('Method call is not supported');
     }
-    async write(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method multicall is not supported');
+    async read() {
+        throw new Error('Method read is not supported');
     }
-    async multicallByContract(_contracts, _allowErrors = true) {
-        throw new Error('Method multicall is not supported');
-    }
-    async multicallByAddress(_address, _abi, _method, _methodArgs = [], _allowErrors = true) {
-        throw new Error('Method multicall is not supported');
-    }
-    async simulateTransaction(_config, _from) { }
-    async checkEnoughBalance(token, walletAddress) {
-        const balance = await this.getBalance(walletAddress, token.address);
-        return balance.gte(token.tokenAmount);
-    }
-    async getBalance(userAddress, tokenAddress) {
-        const isToken = tokenAddress && !web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.SOLANA, tokenAddress);
-        if (isToken) {
-            const balance = await this.getTokensBalances(userAddress, [tokenAddress]);
-            return balance?.[0] || new bignumber_js_1.default(0);
+    async getTransactionStatus(txHash) {
+        try {
+            const transaction = await this.public.getTransaction(txHash, {
+                maxSupportedTransactionVersion: 1
+            });
+            if (transaction?.meta?.err) {
+                return tx_status_1.TX_STATUS.FAIL;
+            }
+            if (transaction?.blockTime) {
+                return tx_status_1.TX_STATUS.SUCCESS;
+            }
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+        catch {
+            return tx_status_1.TX_STATUS.PENDING;
         }
-        const balance = await this.public.getBalanceAndContext(new web3_js_1.PublicKey(userAddress), 'confirmed');
-        return new bignumber_js_1.default(balance.value.toString());
     }
     /**
      * Gets balance of multiple tokens.
@@ -65,13 +58,42 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
         }));
         const nativeSolBalance = await this.public.getBalanceAndContext(new web3_js_1.PublicKey(address), 'confirmed');
         return tokensAddresses.map((tokenAddress) => {
-            if (tokenAddress === exports.NATIVE_SOLANA_MINT_ADDRESS) {
+            if (tokenAddress === web3_pure_1.Web3Pure.getNativeTokenAddress(core_1.BLOCKCHAIN_NAME.SOLANA)) {
                 return new bignumber_js_1.default(nativeSolBalance.value.toString());
             }
             const tokenWithBalance = tokenInfo.get(tokenAddress);
             return new bignumber_js_1.default(tokenWithBalance || NaN);
         });
     }
+    multicallContractsMethods() {
+        throw new Error('Method not implemented.');
+    }
+    getBlockNumber() {
+        return this.public.getBlockHeight('finalized');
+    }
+    createConection(rpcList) {
+        if (!rpcList?.[0]) {
+            this.logger?.customError('RPC list is empty');
+            return null;
+        }
+        else {
+            return new web3_js_1.Connection(rpcList[0], 'confirmed');
+        }
+    }
+    async simulateTransaction(_config, _from) { }
+    async checkEnoughBalance(token, walletAddress) {
+        const balance = await this.getBalance(walletAddress, token.address);
+        return balance.gte(token.tokenAmount);
+    }
+    async getBalance(userAddress, tokenAddress) {
+        const isToken = tokenAddress && !web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.SOLANA, tokenAddress);
+        if (isToken) {
+            const balance = await this.getTokensBalances(userAddress, [tokenAddress]);
+            return balance?.[0] || new bignumber_js_1.default(0);
+        }
+        const balance = await this.public.getBalanceAndContext(new web3_js_1.PublicKey(userAddress), 'confirmed');
+        return new bignumber_js_1.default(balance.value.toString());
+    }
     async callForTokensInfo(tokenAddresses) {
         const nativeToken = core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.SOLANA];
         const nativeTokenIndex = tokenAddresses.findIndex((address) => web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.SOLANA, address));

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

@@ -0,0 +1,8 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { BasicSendTransactionOptions } from '../../models/basic-transaction-options';
+export interface SuiSendTxParams {
+    txOptions: SuiTransactionOptions;
+}
+export interface SuiTransactionOptions extends BasicSendTransactionOptions {
+    transactionBlock: Transaction;
+}

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

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

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

@@ -0,0 +1,17 @@
+import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { AbstractAdapterSigner } from '../../common/signer/abstract-adapter-signer';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
+import { SuiSendTxParams } from '../models/sui-send-tx-params';
+import { WalletAdapter } from '@suiet/wallet-sdk';
+import { ExecuteTransactionBlockParams, SuiClient, SuiTransactionBlockResponse } from '@mysten/sui/dist/cjs/client';
+export declare class SuiAdapterSigner extends AbstractAdapterSigner<WalletAdapter, SuiSendTxParams, string> {
+    private readonly publicRef;
+    get publicClient(): SuiClient;
+    constructor(publicRef: {
+        public: SuiClient | null;
+    }, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    write<T>(): Promise<T>;
+    getBlockchainName(): Promise<BlockchainName>;
+    sendTransaction(params: SuiSendTxParams): Promise<string>;
+    executeTxBlock(params: ExecuteTransactionBlockParams): Promise<SuiTransactionBlockResponse>;
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiAdapterSigner = 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 parse_evm_error_1 = require("../../adapter-evm/utils/parse-evm-error");
+class SuiAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    get publicClient() {
+        if (!this.publicRef.public) {
+            const msg = `Trying to access undefined publicClient in SuiAdapterSigner.`;
+            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() {
+        throw new Error('Method write is not supported');
+    }
+    getBlockchainName() {
+        return Promise.resolve(core_1.BLOCKCHAIN_NAME.SUI);
+    }
+    async sendTransaction(params) {
+        try {
+            const account = this.wallet.accounts[0];
+            const signedTx = await this.wallet.features['sui:signTransaction'].signTransaction({
+                account: account,
+                transaction: params.txOptions.transactionBlock,
+                chain: 'sui:mainnet'
+            });
+            const tx = await this.executeTxBlock({
+                transactionBlock: signedTx.bytes,
+                signature: signedTx.signature
+            });
+            params.txOptions.onTransactionHash?.(tx.digest);
+            return tx.digest;
+        }
+        catch (err) {
+            if (err?.message.includes('User rejected the request.') ||
+                err?.message.includes('User rejection | (UserRejectionError:-4005)')) {
+                throw new user_reject_error_1.UserRejectError();
+            }
+            console.error(`Send transaction error. ${err}`);
+            throw (0, parse_evm_error_1.parseEvmError)(err);
+        }
+    }
+    executeTxBlock(params) {
+        return this.publicClient.executeTransactionBlock(params);
+    }
+}
+exports.SuiAdapterSigner = SuiAdapterSigner;

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

@@ -0,0 +1,32 @@
+import { Abi, MulticallResponse } from 'viem';
+import { HttpClient, ICustomLogger, PriceTokenAmount, SuiBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
+import { SuiClient } from '@mysten/sui/client';
+import BigNumber from 'bignumber.js';
+import { AbstractAdapter } from '../common/abstract-adapter';
+import { WalletAdapter } from '@suiet/wallet-sdk';
+import { SuiAdapterSigner } from './signer/sui-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 SuiAdapter extends AbstractAdapter<SuiClient, WalletAdapter, SuiBlockchainName> {
+    private readonly rpcList;
+    readonly signer: SuiAdapterSigner;
+    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    initWeb3Client(): void;
+    callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
+    read<T>(): 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;
+    }>;
+    multicallByAddress<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[][], _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
+    simulateTransaction(_config: object, _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>;
+    compareSuiAddress(addressA: string, addressB: string): boolean;
+}

package/src/lib/adapter/adapters/{sui-adapter.js → adapter-sui/sui-adapter.js}

@@ -1,24 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SuiAdapter = void 0;
-const abstract_adapter_1 = require("./abstract-adapter");
 const core_1 = require("@cryptorubic/core");
-const web3_pure_1 = require("../../utils/web3-pure");
 const client_1 = require("@mysten/sui/client");
 const bignumber_js_1 = require("bignumber.js");
+const abstract_adapter_1 = require("../common/abstract-adapter");
+const web3_pure_1 = require("../../../utils/web3-pure");
+const sui_adapter_signer_1 = require("./signer/sui-adapter-signer");
+const tx_status_1 = require("../models/web3-public-models/tx-status");
 class SuiAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(rpcList, logger) {
+    constructor(rpcList, httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.SUI, logger);
-        this.public = new client_1.SuiClient({ url: rpcList[0] });
+        this.rpcList = rpcList;
+        this.signer = new sui_adapter_signer_1.SuiAdapterSigner(this.publicRef, httpClient, logger, clientParams);
     }
-    async read(_address, _abi, _method, _methodArgs = []) {
+    initWeb3Client() {
+        this.public = new client_1.SuiClient({ url: this.rpcList[0] });
+    }
+    async callContractMethod() {
+        throw new Error('Method call is not supported');
+    }
+    async read() {
         throw new Error('Method read is not supported');
     }
-    async write(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method write is not supported');
+    async getTransactionStatus(srcTxHash) {
+        try {
+            const txDetails = await this.public.getTransactionBlock({ digest: srcTxHash });
+            const status = txDetails?.effects?.status.status;
+            if (!status) {
+                return tx_status_1.TX_STATUS.PENDING;
+            }
+            return status === 'success' ? tx_status_1.TX_STATUS.SUCCESS : tx_status_1.TX_STATUS.FAIL;
+        }
+        catch {
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+    }
+    async getTokensBalances(userAddress, tokensAddresses) {
+        const allUserTokens = await this.public.getAllBalances({ owner: userAddress });
+        return tokensAddresses.map((address) => {
+            const possibleBalance = allUserTokens.find((el) => (0, core_1.compareAddresses)(address, el.coinType) || this.compareSuiAddress(address, el.coinType));
+            return new bignumber_js_1.default(possibleBalance?.totalBalance || 0);
+        });
     }
-    async multicallByContract(_contracts, _allowErrors = true) {
-        throw new Error('Method multicall is not supported');
+    multicallContractsMethods() {
+        throw new Error('Method not implemented.');
+    }
+    async getBlockNumber() {
+        const epochInfo = await this.public.getEpochs({ limit: 1 });
+        const stringEpoch = epochInfo.data[0].epoch;
+        return Number(stringEpoch);
     }
     async multicallByAddress(_address, _abi, _method, _methodArgs = [], _allowErrors = true) {
         throw new Error('Method multicall is not supported');
@@ -71,5 +102,10 @@ class SuiAdapter extends abstract_adapter_1.AbstractAdapter {
         const balance = await this.public.getBalance({ owner: userAddress });
         return new bignumber_js_1.default(balance.totalBalance);
     }
+    compareSuiAddress(addressA, addressB) {
+        const pureAddressA = addressA.split(':')[0];
+        const pureAddressB = addressB.split(':')[0];
+        return (0, core_1.compareAddresses)(new bignumber_js_1.default(pureAddressA).toFixed(), new bignumber_js_1.default(pureAddressB).toFixed());
+    }
 }
 exports.SuiAdapter = SuiAdapter;

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

@@ -0,0 +1,26 @@
+import { BasicSendTransactionOptions } from '../../models/basic-transaction-options';
+export interface TonSendTxParams {
+    txOptions: TonTransactionOptions;
+}
+export interface TonTransactionOptions extends BasicSendTransactionOptions {
+    messages: TonEncodedConfig[];
+}
+export interface TonEncodedConfig {
+    /**
+     * In default transfer - it's a receiverWalletAddress to send funds
+     * In tx using contracts - it's a jettonWalletAddress (like ERC-20, but in TON)
+     */
+    address: string;
+    /**
+     * Amount to send in tx in nanotons
+     * In default trasfer - it's a transfered value
+     * In tx using contracts - it's static gasFee, by default toNano(0.05).toString()
+     */
+    amount: string;
+    /**
+     * Data for contract.
+     * body.toBoc().toString('base64')
+     */
+    payload?: string;
+    stateInit?: string;
+}

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

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

package/src/lib/adapter/adapters/{utils → adapter-ton/services}/ton-api.service.d.ts

@@ -1,8 +1,8 @@
-import { TonApiAccountInfoResp, TonApiAllNonNullableTokenInfoForWalletResp, TonApiParseAddressResp, TonApiTokenInfoForWalletResp, TonApiTokenInfoResp, TonApiTxDataByBocResp } from '../models/tonapi-models';
-import { TonCenterBlockInfo } from '../models/toncenter-types';
+import { TonApiAccountInfoResp, TonApiAllNonNullableTokenInfoForWalletResp, TonApiParseAddressResp, TonApiTokenInfoForWalletResp, TonApiTokenInfoResp, TonApiTxDataByBocResp } from '../../models/tonapi-models';
+import { TonCenterBlockInfo } from '../../models/toncenter-types';
 import { HttpClient, ICustomLogger } from '@cryptorubic/core';
-import { TonApiConfig } from '../models/ton-api-config';
-import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
+import { TonApiConfig } from '../../models/ton-api-config';
+import { Web3PrimitiveType } from '../../../../utils/models/primitive-types';
 export declare class TonApiService {
     private readonly httpClient;
     private readonly logger?;

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

@@ -0,0 +1,43 @@
+import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { AbstractAdapterSigner } from '../../common/signer/abstract-adapter-signer';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
+import { TonSendTxParams } from '../models/ton-send-tx-params';
+import { TonConnectUI } from '@tonconnect/ui';
+import { BasicSendTransactionOptions } from '../../models/basic-transaction-options';
+import { Address } from '@ton/core';
+import { TonApiService } from '../services/ton-api.service';
+import { TonClient } from '@ton/ton';
+import { TonTransactionConfig } from '../../../../utils/models/ton-transaction-config';
+export declare class TonAdapterSigner extends AbstractAdapterSigner<TonConnectUI, TonSendTxParams, string> {
+    private readonly tonApi;
+    private readonly publicRef;
+    get publicClient(): TonClient;
+    constructor(tonApi: TonApiService, publicRef: {
+        public: TonClient | null;
+    }, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    write<T>(): Promise<T>;
+    getBlockchainName(): Promise<BlockchainName>;
+    sendTransaction(params: TonSendTxParams): Promise<string>;
+    private waitForTransactionReceipt;
+    /**
+     * 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: string, walletAddress: string, receiver: string, amount: string, options?: BasicSendTransactionOptions): Promise<string>;
+    private transferNative;
+    private transferJetton;
+    getTransferEncodedConfig(tokenAddress: string, walletAddress: string, receiver: string, amount: string): Promise<TonTransactionConfig>;
+    private getTransferNativeConfig;
+    private getTransferJettonConfig;
+    /**
+     *
+     * @param boc Boc returned in connector.sendTransaction
+     * @returns boc converter in base 64 string
+     */
+    fromBocToBase64Hash(boc: string): string;
+    getJettonWalletAddress(address: Address, contractAddress: Address): Promise<Address>;
+}

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>;
+}