@cryptorubic/web3 1.0.0-alpha.no-sdk.22 → 1.0.0-alpha.no-sdk.24

package/src/lib/adapter/adapters/adapter-evm/{client/evm-adapter-client.js → signer/evm-adapter-signer.js}

@@ -1,122 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvmAdapterClient = void 0;
+exports.EvmAdapterSigner = void 0;
 const core_1 = require("@cryptorubic/core");
-const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-client");
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
 const viem_1 = require("viem");
 const actions_1 = require("viem/actions");
 const options_1 = require("../../utils/options");
 const viem_blockchain_mapping_1 = require("../../../constants/viem-blockchain-mapping");
-const bignumber_js_1 = require("bignumber.js");
-const uni_v3_permit_abi_1 = require("../../constants/uni-v3-permit-abi");
-const erc20_token_abi_1 = require("../../constants/erc20-token-abi");
 const parse_evm_error_1 = require("../utils/parse-evm-error");
 const rubic_sdk_error_1 = require("../../../../errors/rubic-sdk.error");
-const evm_adapter_1 = require("../evm-adapter");
 const tx_status_1 = require("../../models/web3-public-models/tx-status");
-const insufficient_funds_gas_price_value_error_1 = require("../../../../errors/cross-chain/insufficient-funds-gas-price-value.error");
-class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
+class EvmAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
     constructor(evmPublic, httpClient, logger, clientParams) {
         super(httpClient, logger, clientParams);
         this.evmPublic = evmPublic;
     }
     async getBlockchainName() {
-        const userChainId = await this.clientWallet.getChainId();
+        const userChainId = await this.wallet.getChainId();
         return core_1.BlockchainsInfo.getBlockchainNameById(userChainId);
     }
-    async getAllowance(fromTokenAddress, walletAddress, spenderAddress) {
-        const [decimals, allowance] = await Promise.all([
-            this.read(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'decimals'),
-            this.read(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'allowance', [walletAddress, spenderAddress])
-        ]);
-        const allowanceWeiBN = new bignumber_js_1.default(allowance);
-        const allowanceNonWei = core_1.Token.fromWei(allowanceWeiBN, Number(decimals));
-        return { allowanceNonWei, allowanceWei: allowanceWeiBN };
-    }
-    async needApprove(token, contractAddress, walletAddress, amount) {
-        // Native coin in METIS can be Token required approve
-        if (token.isNative && token.blockchain !== core_1.BLOCKCHAIN_NAME.METIS) {
-            return false;
-        }
-        // Special native address for METIS native coin
-        const fromTokenAddress = token.isNative && token.blockchain === core_1.BLOCKCHAIN_NAME.METIS ? '0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000' : token.address;
-        const { allowanceWei } = await this.getAllowance(fromTokenAddress, walletAddress, contractAddress);
-        return allowanceWei.lt(token.weiAmount);
-    }
-    /**
-     * Executes approve method in ERC-20 token contract.
-     * @param tokenAddress Address of the smart-contract corresponding to the token.
-     * @param spenderAddress Wallet or contract address to approve.
-     * @param amount Token amount to approve in wei.
-     * @param [options] Additional options.
-     * @returns Approval transaction hash.
-     */
-    async approveTokens(tokenAddress, spenderAddress, amount = 'infinity', options = {}) {
-        try {
-            const rawValue = amount === 'infinity' ? new bignumber_js_1.default(2).pow(256).minus(1) : amount;
-            const encodedApprove = this.encodeApprove(tokenAddress, spenderAddress, rawValue.toFixed(0));
-            const gaslessParams = {
-                account: this.walletAddress,
-                to: tokenAddress,
-                value: BigInt('0'),
-                data: encodedApprove.data
-            };
-            const gas = await this.evmPublic.estimateGas({
-                ...gaslessParams,
-                ...(0, options_1.getViemGasOptions)(options)
-            });
-            const gasfulViemOptions = {
-                ...gaslessParams,
-                ...(0, options_1.getViemGasOptions)(options),
-                gas: gas.toString()
-            };
-            const receipt = await this.executeContractMethod(tokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', [spenderAddress, BigInt(rawValue.toFixed(0))], gasfulViemOptions);
-            return receipt.transactionHash;
-        }
-        catch (err) {
-            if (err?.message?.includes('gas required exceeds allowance') || err?.message?.includes('insufficient balance to pay for gas')) {
-                throw new insufficient_funds_gas_price_value_error_1.InsufficientFundsGasPriceValueError();
-            }
-            console.debug(err);
-            throw err;
-        }
-    }
-    /**
-     * Build encoded approve transaction config.
-     * @param tokenAddress Address of the smart-contract corresponding to the token.
-     * @param spenderAddress Wallet or contract address to approve.
-     * @param amount wei amount of tokens in approval window in spending cap field
-     * @returns Encoded approve transaction config.
-     */
-    encodeApprove(tokenAddress, spenderAddress, amount) {
-        const amountWei = amount ?? new bignumber_js_1.default(2).pow(256).minus(1).toFixed();
-        const tx = evm_adapter_1.EvmAdapter.encodeMethodCall(tokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', [spenderAddress, amountWei]);
-        return {
-            data: tx.data,
-            to: tx.to,
-            value: tx.value
-        };
-    }
-    async needPermit2Approve(token, permit2Address, walletAddress, spenderAddress) {
-        const res = await this.read(permit2Address, uni_v3_permit_abi_1.UNI_V3_PERMIT_2_ABI, 'allowance', [
-            walletAddress,
-            token.address,
-            spenderAddress
-        ]);
-        const [amount, expiration, _nonce] = res;
-        return token.weiAmount.gt(amount) || new bignumber_js_1.default(Date.now()).gt(Number(expiration) * 1000);
-    }
-    /**
-     * @param tokenAddress Token address you want to approve for spending
-     * @param permit2Address Addres of permit2 contract
-     * @param spenderAddress Contract address spending your tokens
-     * @param amount Approved amount
-     * @param deadline Ms number added to current time (Date.now()) until approve expiration
-     */
-    async approveOnPermit2(tokenAddress, spenderAddress, amount = 'infinity', options = {}) {
-        const rawValue = amount === 'infinity' ? new bignumber_js_1.default(2).pow(256).minus(1) : amount;
-        return this.executeContractMethod(tokenAddress, uni_v3_permit_abi_1.UNI_V3_PERMIT_2_ABI, 'approve', [spenderAddress, BigInt(rawValue.toString())], options);
-    }
     async getTransactionStatus(hash) {
         const txReceipt = await this.getTransactionReceipt(hash);
         if (txReceipt === null) {
@@ -154,9 +56,9 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
                 ...(params.txOptions.gas && { gas: BigInt(params.txOptions.gas) }),
                 chain
             };
-            const hash = await this.clientWallet.sendTransaction(viemParams);
+            const hash = await this.wallet.sendTransaction(viemParams);
             params.txOptions?.onTransactionHash?.(hash);
-            return (0, actions_1.waitForTransactionReceipt)(this.clientWallet, { hash });
+            return (0, actions_1.waitForTransactionReceipt)(this.wallet, { hash });
         }
         catch (err) {
             console.error('Send transaction error', err);
@@ -242,9 +144,9 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
                 account: account,
                 chain: chain
             };
-            const hash = await this.clientWallet.writeContract(sendParams);
+            const hash = await this.wallet.writeContract(sendParams);
             options?.onTransactionHash?.(hash);
-            return (0, actions_1.waitForTransactionReceipt)(this.clientWallet, { hash });
+            return (0, actions_1.waitForTransactionReceipt)(this.wallet, { hash });
         }
         catch (err) {
             console.error(`Method execution error. ${err}`);
@@ -322,14 +224,14 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
         return test;
     }
     async signMessage(message) {
-        return this.clientWallet.signMessage({
+        return this.wallet.signMessage({
             account: this.walletAddress,
             message: message
         });
     }
     async getChainAndAccount() {
         const account = this.walletAddress;
-        const chainId = await this.clientWallet.getChainId();
+        const chainId = await this.wallet.getChainId();
         const chainName = core_1.BlockchainsInfo.getBlockchainNameById(chainId);
         if (!chainName) {
             throw Error(`Unsupported chain ID: ${chainId}. Please provide a valid EVM blockchain ID`);
@@ -340,17 +242,8 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
         }
         return { account, chain };
     }
-    async read(address, abi, method, methodArgs = []) {
-        const result = await this.evmPublic.readContract({
-            abi,
-            address: address,
-            args: methodArgs,
-            functionName: method
-        });
-        return result;
-    }
     async writeContract(address, abi, method, value = '0', methodArgs = []) {
-        const result = await this.clientWallet.writeContract({
+        const result = await this.wallet.writeContract({
             abi,
             address: address,
             account: address,
@@ -362,7 +255,7 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
         return result;
     }
     async write(address, to, value, data, options = {}) {
-        const result = await this.clientWallet.sendTransaction({
+        const result = await this.wallet.sendTransaction({
             account: address,
             to: to,
             value: (0, viem_1.parseEther)(value),
@@ -374,4 +267,4 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
         return result;
     }
 }
-exports.EvmAdapterClient = EvmAdapterClient;
+exports.EvmAdapterSigner = EvmAdapterSigner;

package/src/lib/adapter/adapters/adapter-solana/{client/solana-adapter-client.d.ts → signer/solana-adapter-signer.d.ts}

@@ -3,12 +3,11 @@ import { SolanaWeb3 } from '../../../constants/models/solana-web3';
 import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
 import { SolanaSendTxParams } from '../models/solana-send-tx-params';
 import { Connection } from '@solana/web3.js';
-import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
+import { AbstractAdapterSigner } from '../../common/signer/abstract-adapter-signer';
 import { TxStatus } from '../../models/web3-public-models/tx-status';
-export declare class SolanaAdapterClient extends AbstractAdapterClient<SolanaWeb3, SolanaSendTxParams, string> {
+export declare class SolanaAdapterSigner extends AbstractAdapterSigner<SolanaWeb3, SolanaSendTxParams, string> {
     private readonly connection;
     constructor(connection: Connection, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
-    read<T>(): Promise<T>;
     write<T>(): Promise<T>;
     getBlockchainName(): Promise<BlockchainName>;
     getTransactionStatus(txHash: string): Promise<TxStatus>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaAdapterClient = void 0;
+exports.SolanaAdapterSigner = void 0;
 const core_1 = require("@cryptorubic/core");
 const web3_js_1 = require("@solana/web3.js");
 const waitFor_1 = require("../../utils/waitFor");
@@ -8,16 +8,13 @@ const timeout_error_1 = require("../../../../errors/common/timeout.error");
 const js_base64_1 = require("js-base64");
 const user_reject_error_1 = require("../../../../errors/blockchain/user-reject.error");
 const errors_1 = require("../../utils/errors");
-const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-client");
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
 const tx_status_1 = require("../../models/web3-public-models/tx-status");
-class SolanaAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
+class SolanaAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
     constructor(connection, httpClient, logger, clientParams) {
         super(httpClient, logger, clientParams);
         this.connection = connection;
     }
-    async read() {
-        throw new Error('Method read is not supported');
-    }
     async write() {
         throw new Error('Method write is not supported');
     }
@@ -45,7 +42,7 @@ class SolanaAdapterClient extends abstract_adapter_client_1.AbstractAdapterClien
         try {
             const decodedData = js_base64_1.Base64.toUint8Array(params.txOptions.data);
             const tx = web3_js_1.VersionedTransaction.deserialize(decodedData);
-            const signedTx = await this.clientWallet.signTransaction(tx);
+            const signedTx = await this.wallet.signTransaction(tx);
             const txBase64 = js_base64_1.Base64.fromUint8Array(signedTx.serialize());
             let signature;
             if (params.txOptions?.sponsorParams) {
@@ -97,4 +94,4 @@ class SolanaAdapterClient extends abstract_adapter_client_1.AbstractAdapterClien
             throw new timeout_error_1.TimeoutError();
     }
 }
-exports.SolanaAdapterClient = SolanaAdapterClient;
+exports.SolanaAdapterSigner = SolanaAdapterSigner;

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

@@ -5,15 +5,16 @@ import { AbstractAdapter } from '../common/abstract-adapter';
 import { SolanaRawInstruction } from '../models/solana-web3-types';
 import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
 import { SolanaWeb3 } from '../../constants/models/solana-web3';
-import { SolanaAdapterClient } from './client/solana-adapter-client';
+import { SolanaAdapterSigner } from './signer/solana-adapter-signer';
 import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
 import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
 export declare const NATIVE_SOLANA_MINT_ADDRESS = "So11111111111111111111111111111111111111111";
 export declare class SolanaAdapter extends AbstractAdapter<Connection, SolanaWeb3, SolanaBlockchainName> {
     private readonly httpClient;
-    readonly client: SolanaAdapterClient;
+    readonly signer: SolanaAdapterSigner;
     constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
     callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
+    read<T>(): Promise<T>;
     /**
      * Gets balance of multiple tokens.
      * @param address Wallet address.

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

@@ -10,18 +10,21 @@ 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_client_1 = require("./client/solana-adapter-client");
+const solana_adapter_signer_1 = require("./signer/solana-adapter-signer");
 exports.NATIVE_SOLANA_MINT_ADDRESS = 'So11111111111111111111111111111111111111111';
 class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
     constructor(rpcList, httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
         this.httpClient = httpClient;
         this.public = this.createConection(rpcList);
-        this.client = new solana_adapter_client_1.SolanaAdapterClient(this.public, httpClient, logger, clientParams);
+        this.signer = new solana_adapter_signer_1.SolanaAdapterSigner(this.public, httpClient, logger, clientParams);
     }
     async callContractMethod() {
         throw new Error('Method call is not supported');
     }
+    async read() {
+        throw new Error('Method read is not supported');
+    }
     /**
      * Gets balance of multiple tokens.
      * @param address Wallet address.

package/src/lib/adapter/adapters/adapter-sui/{client/sui-adapter-client.d.ts → signer/sui-adapter-signer.d.ts}

@@ -1,14 +1,13 @@
 import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
-import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
+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 { TxStatus } from '../../models/web3-public-models/tx-status';
 import { ExecuteTransactionBlockParams, SuiClient, SuiTransactionBlockResponse } from '@mysten/sui/dist/cjs/client';
-export declare class SuiAdapterClient extends AbstractAdapterClient<WalletAdapter, SuiSendTxParams, string> {
+export declare class SuiAdapterSigner extends AbstractAdapterSigner<WalletAdapter, SuiSendTxParams, string> {
     private readonly suiClient;
     constructor(suiClient: SuiClient, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
-    read<T>(): Promise<T>;
     write<T>(): Promise<T>;
     getBlockchainName(): Promise<BlockchainName>;
     getTransactionStatus(srcTxHash: string): Promise<TxStatus>;

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

@@ -1,19 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SuiAdapterClient = void 0;
+exports.SuiAdapterSigner = void 0;
 const core_1 = require("@cryptorubic/core");
-const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-client");
+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");
 const tx_status_1 = require("../../models/web3-public-models/tx-status");
-class SuiAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
+class SuiAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
     constructor(suiClient, httpClient, logger, clientParams) {
         super(httpClient, logger, clientParams);
         this.suiClient = suiClient;
     }
-    async read() {
-        throw new Error('Method read is not supported');
-    }
     async write() {
         throw new Error('Method write is not supported');
     }
@@ -35,8 +32,8 @@ class SuiAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
     }
     async sendTransaction(params) {
         try {
-            const account = this.clientWallet.accounts[0];
-            const signedTx = await this.clientWallet.features['sui:signTransaction'].signTransaction({
+            const account = this.wallet.accounts[0];
+            const signedTx = await this.wallet.features['sui:signTransaction'].signTransaction({
                 account: account,
                 transaction: params.txOptions.transactionBlock,
                 chain: 'sui:mainnet'
@@ -61,4 +58,4 @@ class SuiAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
         return this.suiClient.executeTransactionBlock(params);
     }
 }
-exports.SuiAdapterClient = SuiAdapterClient;
+exports.SuiAdapterSigner = SuiAdapterSigner;

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

@@ -4,14 +4,15 @@ import { SuiClient } from '@mysten/sui/client';
 import BigNumber from 'bignumber.js';
 import { AbstractAdapter } from '../common/abstract-adapter';
 import { WalletAdapter } from '@suiet/wallet-sdk';
-import { SuiAdapterClient } from './client/sui-adapter-client';
+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';
 export declare class SuiAdapter extends AbstractAdapter<SuiClient, WalletAdapter, SuiBlockchainName> {
-    readonly client: SuiAdapterClient;
+    readonly signer: SuiAdapterSigner;
     constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
     callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
+    read<T>(): Promise<T>;
     getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
     multicallContractsMethods<Output extends Web3PrimitiveType>(): Promise<ContractMulticallResponse<Output>[][]>;
     getBlockNumber(): Promise<number | {

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

@@ -6,16 +6,19 @@ 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_client_1 = require("./client/sui-adapter-client");
+const sui_adapter_signer_1 = require("./signer/sui-adapter-signer");
 class SuiAdapter extends abstract_adapter_1.AbstractAdapter {
     constructor(rpcList, httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.SUI, logger);
         this.public = new client_1.SuiClient({ url: rpcList[0] });
-        this.client = new sui_adapter_client_1.SuiAdapterClient(this.public, httpClient, logger, clientParams);
+        this.signer = new sui_adapter_signer_1.SuiAdapterSigner(this.public, httpClient, logger, clientParams);
     }
     async callContractMethod() {
         throw new Error('Method call is not supported');
     }
+    async read() {
+        throw new Error('Method read is not supported');
+    }
     async getTokensBalances(userAddress, tokensAddresses) {
         const allUserTokens = await this.public.getAllBalances({ owner: userAddress });
         return tokensAddresses.map((address) => {

package/src/lib/adapter/adapters/adapter-ton/{client/ton-adapter-client.d.ts → signer/ton-adapter-signer.d.ts}

@@ -1,5 +1,5 @@
 import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
-import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
+import { AbstractAdapterSigner } from '../../common/signer/abstract-adapter-signer';
 import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
 import { TxStatus } from '../../models/web3-public-models/tx-status';
 import { TonSendTxParams } from '../models/ton-send-tx-params';
@@ -7,13 +7,12 @@ 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 { TonAdapterConfig } from '../../models/ton-adapter-config';
+import { TonClient } from '@ton/ton';
 import { TonTransactionConfig } from '../../../../utils/models/ton-transaction-config';
-export declare class TonAdapterClient extends AbstractAdapterClient<TonConnectUI, TonSendTxParams, string> {
+export declare class TonAdapterSigner extends AbstractAdapterSigner<TonConnectUI, TonSendTxParams, string> {
     private readonly tonApi;
     private readonly tonClient;
-    constructor(tonApi: TonApiService, config: TonAdapterConfig, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
-    read<T>(): Promise<T>;
+    constructor(tonApi: TonApiService, tonClient: TonClient, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
     write<T>(): Promise<T>;
     getBlockchainName(): Promise<BlockchainName>;
     getTransactionStatus(srcTxHash: string): Promise<TxStatus>;

package/src/lib/adapter/adapters/adapter-ton/{client/ton-adapter-client.js → signer/ton-adapter-signer.js}

@@ -1,23 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TonAdapterClient = void 0;
+exports.TonAdapterSigner = void 0;
 const core_1 = require("@cryptorubic/core");
-const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-client");
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
 const user_reject_error_1 = require("../../../../errors/blockchain/user-reject.error");
 const tx_status_1 = require("../../models/web3-public-models/tx-status");
 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");
-const ton_1 = require("@ton/ton");
-class TonAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
-    constructor(tonApi, config, httpClient, logger, clientParams) {
+class TonAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    constructor(tonApi, tonClient, httpClient, logger, clientParams) {
         super(httpClient, logger, clientParams);
         this.tonApi = tonApi;
-        this.tonClient = new ton_1.TonClient(config.tonClientConfig);
-    }
-    async read() {
-        throw new Error('Method read is not supported');
+        this.tonClient = tonClient;
     }
     async write() {
         throw new Error('Method write is not supported');
@@ -34,7 +30,7 @@ class TonAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
     }
     async sendTransaction(params) {
         try {
-            const { boc } = await this.clientWallet.sendTransaction({
+            const { boc } = await this.wallet.sendTransaction({
                 validUntil: Math.floor(Date.now() / 1000) + 360,
                 messages: params.txOptions.messages
             });
@@ -167,4 +163,4 @@ class TonAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
         return addressResult.stack.readAddress();
     }
 }
-exports.TonAdapterClient = TonAdapterClient;
+exports.TonAdapterSigner = TonAdapterSigner;

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

@@ -5,14 +5,15 @@ import { TonAdapterConfig } from '../models/ton-adapter-config';
 import BigNumber from 'bignumber.js';
 import { AbstractAdapter } from '../common/abstract-adapter';
 import { TonConnectUI } from '@tonconnect/ui';
-import { TonAdapterClient } from './client/ton-adapter-client';
+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';
 export declare class TonAdapter extends AbstractAdapter<TonClient, TonConnectUI, TonBlockchainName> {
-    readonly client: TonAdapterClient;
+    readonly signer: TonAdapterSigner;
     private readonly tonApi;
     constructor(httpClient: HttpClient, config: TonAdapterConfig, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    read<T>(): Promise<T>;
     callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
     getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
     multicallContractsMethods<Output extends Web3PrimitiveType>(): Promise<ContractMulticallResponse<Output>[][]>;

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

@@ -7,12 +7,16 @@ 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_client_1 = require("./client/ton-adapter-client");
+const ton_adapter_signer_1 = require("./signer/ton-adapter-signer");
 class TonAdapter extends abstract_adapter_1.AbstractAdapter {
     constructor(httpClient, config, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.TON, logger);
         this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig, logger);
-        this.client = new ton_adapter_client_1.TonAdapterClient(this.tonApi, config, httpClient, logger, clientParams);
+        this.public = new ton_1.TonClient(config.tonClientConfig);
+        this.signer = new ton_adapter_signer_1.TonAdapterSigner(this.tonApi, this.public, httpClient, logger, clientParams);
+    }
+    async read() {
+        throw new Error('Method read is not supported');
     }
     async callContractMethod() {
         throw new Error('Method call is not supported');

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

@@ -0,0 +1,21 @@
+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 { TxStatus } from '../../models/web3-public-models/tx-status';
+import { TronParameters } from '../../../../utils/models/tron-parameters';
+export declare class TronAdapterSigner extends AbstractAdapterSigner<TronWeb, TronSendTxParams, string> {
+    private readonly tronWeb;
+    constructor(tronWeb: TronWeb, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    write(contractAddress: string, methodSignature: string, parameters: TronParameters): Promise<string>;
+    getBlockchainName(): Promise<BlockchainName>;
+    getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    /**
+     * Gets mined transaction info.
+     * @param hash Transaction hash.
+     */
+    private getTransactionInfo;
+    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,67 @@
+"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 tx_status_1 = require("../../models/web3-public-models/tx-status");
+const parse_tron_error_1 = require("../utils/parse-tron-error");
+class TronAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    constructor(tronWeb, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+        this.tronWeb = tronWeb;
+    }
+    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 getTransactionStatus(srcTxHash) {
+        const txReceipt = await this.getTransactionInfo(srcTxHash);
+        if (txReceipt?.receipt) {
+            if (txReceipt.result === 'FAILED') {
+                return tx_status_1.TX_STATUS.FAIL;
+            }
+            return tx_status_1.TX_STATUS.SUCCESS;
+        }
+        return tx_status_1.TX_STATUS.PENDING;
+    }
+    /**
+     * Gets mined transaction info.
+     * @param hash Transaction hash.
+     */
+    async getTransactionInfo(hash) {
+        return this.tronWeb.trx.getTransactionInfo(hash);
+    }
+    async sendTransaction(params) {
+        try {
+            const transaction = await this.tronWeb.transactionBuilder.triggerSmartContract(params.contractAddress, params.methodSignature, params.txOptions, params.parameters, this.walletAddress);
+            const signedTransaction = await this.tronWeb.trx.sign(transaction.transaction);
+            const receipt = await this.tronWeb.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.tronWeb.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

@@ -9,9 +9,11 @@ import { ContractMulticallResponse } from '../../../utils/models/contract-multic
 import { TronWeb3PrimitiveType, Web3PrimitiveType } from '../../../utils/models/primitive-types';
 import { MethodData } from '../../../utils/models/method-data';
 import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
-import { TronAdapterClient } from './client/tron-adapter-client';
+import { TronAdapterSigner } from './signer/tron-adapter-signer';
+import { TronTransactionOptions } from './models/tron-send-tx-params';
+import { AllowanceInfo } from '../models/common-types';
 export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> {
-    readonly client: TronAdapterClient;
+    readonly signer: TronAdapterSigner;
     private readonly multicallAddress;
     needPreswapAction(): Promise<boolean>;
     constructor(rpcList: (string | {
@@ -35,5 +37,10 @@ export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronB
     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, _walletAddress: string, spender: 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;
 }