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

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 utils_1 = require("ethers/lib/utils");
-exports.NATIVE_SOLANA_MINT_ADDRESS = 'So11111111111111111111111111111111111111111';
+const js_base64_1 = require("js-base64");
+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');
-        }
-    }
-    async read(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method multicall is not supported');
+    initWeb3Client() {
+        this.public = this.createConection(this.rpcList);
     }
-    async write(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method multicall is not supported');
+    async callContractMethod() {
+        throw new Error('Method call is not supported');
     }
-    async multicallByContract(_contracts, _allowErrors = true) {
-        throw new Error('Method multicall is not supported');
+    async read() {
+        throw new Error('Method read 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));
@@ -115,7 +137,7 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
         return accounts.filter((v) => !!v);
     }
     async createVersionedTransaction(instructions, walletAddress, addressLookupTableAccounts = []) {
-        const { blockhash } = await this.public.getLatestBlockhash();
+        const blockhash = await this.getLatestBlockhash();
         const message = new web3_js_1.TransactionMessage({
             instructions,
             payerKey: new web3_js_1.PublicKey(walletAddress),
@@ -157,11 +179,53 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
         return new web3_js_1.VersionedTransaction(newMsg);
     }
     deserializeTransaction(data) {
-        const decodedData = data.startsWith('0x') ? Buffer.from(data.slice(2), 'hex') : utils_1.base64.decode(data);
+        const decodedData = data.startsWith('0x') ? Buffer.from(data.slice(2), 'hex') : js_base64_1.Base64.toUint8Array(data);
         return web3_js_1.VersionedTransaction.deserialize(decodedData);
     }
     serializeTransactionToBase58(tx) {
         return bs58_1.default.encode(tx.serialize());
     }
+    async createTransferData(fromToken, walletAddress, receiver, convertToVersionedTx, allowOwnerOffCurve = false) {
+        const fromAddress = new web3_js_1.PublicKey(walletAddress);
+        const toAddress = new web3_js_1.PublicKey(receiver);
+        const transaction = fromToken.isNative
+            ? this.createNativeTransfer(fromAddress, toAddress, fromToken.stringWeiAmount)
+            : await this.createTokenTransfer(fromAddress, toAddress, fromToken.address, fromToken.stringWeiAmount, allowOwnerOffCurve);
+        if (convertToVersionedTx) {
+            const blockhash = await this.getLatestBlockhash();
+            const message = new web3_js_1.TransactionMessage({
+                payerKey: fromAddress,
+                recentBlockhash: blockhash,
+                instructions: transaction.instructions
+            }).compileToV0Message();
+            return new web3_js_1.VersionedTransaction(message);
+        }
+        return transaction;
+    }
+    createNativeTransfer(fromAddress, toAddress, fromWeiAmount) {
+        return new web3_js_1.Transaction().add(web3_js_1.SystemProgram.transfer({
+            fromPubkey: fromAddress,
+            toPubkey: toAddress,
+            lamports: BigInt(fromWeiAmount)
+        }));
+    }
+    async createTokenTransfer(fromAddress, toAddress, fromTokenAddress, fromWeiAmount, allowOwnerOffCurve) {
+        const mintTokenAccount = new web3_js_1.PublicKey(fromTokenAddress);
+        const [fromATA, toATA] = await Promise.all([
+            (0, spl_token_1.getAssociatedTokenAddress)(mintTokenAccount, fromAddress),
+            (0, spl_token_1.getAssociatedTokenAddress)(mintTokenAccount, toAddress, allowOwnerOffCurve)
+        ]);
+        const transaction = new web3_js_1.Transaction();
+        const receiverAccountInfo = await this.public.getAccountInfo(toATA);
+        if (!receiverAccountInfo) {
+            transaction.add((0, spl_token_1.createAssociatedTokenAccountInstruction)(fromAddress, toATA, toAddress, mintTokenAccount));
+        }
+        transaction.add((0, spl_token_1.createTransferInstruction)(fromATA, toATA, fromAddress, BigInt(fromWeiAmount)));
+        return transaction;
+    }
+    async getLatestBlockhash() {
+        const { blockhash } = await this.public.getLatestBlockhash();
+        return blockhash;
+    }
 }
 exports.SolanaAdapter = SolanaAdapter;

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,14 +1,15 @@
-import { TonApiAccountInfoResp, TonApiAllNonNullableTokenInfoForWalletResp, TonApiParseAddressResp, TonApiTokenInfoForWalletResp, TonApiTokenInfoResp, TonApiTxDataByBocResp } from '../models/tonapi-models';
-import { TonCenterBlockInfo } from '../models/toncenter-types';
-import { HttpClient } from '@cryptorubic/core';
-import { TonApiConfig } from '../models/ton-api-config';
-import { Web3PrimitiveType } from '../../../utils/models/primitive-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';
 export declare class TonApiService {
     private readonly httpClient;
+    private readonly logger?;
     private readonly tonApiUrl;
     private readonly apiKey;
     private readonly tonCenterV3Url;
-    constructor(httpClient: HttpClient, params: TonApiConfig);
+    constructor(httpClient: HttpClient, params: TonApiConfig, logger?: ICustomLogger | undefined);
     /**
      * @param walletAddress in any format: raw or friendly
      */

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

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TonApiService = void 0;
 class TonApiService {
-    constructor(httpClient, params) {
+    constructor(httpClient, params, logger) {
         this.httpClient = httpClient;
+        this.logger = logger;
         this.apiKey = params.tonApiKey;
         this.tonApiUrl = params?.tonApiUrl || 'https://tonapi.io';
         this.tonCenterV3Url = params.tonCenterV3Url || 'https://toncenter.com/api/v3';
@@ -148,16 +149,23 @@ class TonApiService {
      * @returns balance, decimals, name, symbol, walletJettonAddress, jettonAddress
      */
     async fetchTokenInfoForWallet(walletAddress, tokenAddress) {
-        const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}/jettons/${tokenAddress}`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://app.rubic.exchange'
+        try {
+            const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}/jettons/${tokenAddress}`, {
+                headers: {
+                    apiKey: this.apiKey,
+                    referer: 'https://app.rubic.exchange'
+                }
+            });
+            if ('error' in res) {
+                this.logger?.customError('[TonApiService] ERROR IN fetchTokenInfoForWallet', res.error);
+                return { balance: '0' };
             }
-        });
-        if ('error' in res) {
-            throw new Error(`[TonApiService] Error in fetchTokenInfoForWallet - ${res.error}`);
+            return res;
+        }
+        catch (err) {
+            this.logger?.customError('[TonApiService] ERROR IN fetchTokenInfoForWallet', err);
+            return { balance: '0' };
         }
-        return res;
     }
     async fetchAllNonNullableTokensInfoForWallet(walletAddress) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}/jettons`, {

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