@cryptorubic/web3 0.14.0-alpha.solana-gas.12 → 1.0.0-alpha.no-sdk.1

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

@@ -1,31 +1,37 @@
-import { Abi, MulticallResponse, MulticallParameters } from 'viem';
-import { AbstractAdapter } from './abstract-adapter';
+import { Abi } from 'viem';
 import { AddressLookupTableAccount, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
 import { HttpClient, ICustomLogger, PriceTokenAmount, SolanaBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
 import BigNumber from 'bignumber.js';
-import { SolanaRawInstruction } from './models/solana-web3-types';
-import { SolanaTxConfig } from '../../utils/models/solana-transaction-config';
+import { AbstractAdapter } from '../common/abstract-adapter';
+import { SolanaRawInstruction } from '../models/solana-web3-types';
+import { SolanaSendTxParams } from './models/solana-send-tx-params';
+import { RubicAppAdaptersFactoryParams } from '../../constants/models/create-factory-params';
+import { SolanaWeb3 } from '../../constants/models/solana-web3';
+import { AbstractAdapterClient } from '../common/client/abstract-adapter-client';
+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 const DEFAULT_CU_LIMIT = 400000;
-export declare class SolanaAdapter extends AbstractAdapter<Connection, Connection, SolanaBlockchainName> {
+export declare class SolanaAdapter extends AbstractAdapter<Connection, SolanaWeb3, SolanaBlockchainName> {
     private readonly httpClient;
-    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger);
-    private createPublicClient;
-    read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    multicallByContract<T>(_contracts: MulticallParameters, _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    multicallByAddress<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[][], _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    simulateTransaction(config: SolanaTxConfig, timeout?: number): Promise<string>;
-    private getFailedIxProgramId;
-    private getAddressLookupTableAccounts;
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    getBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
+    readonly client: AbstractAdapterClient<SolanaWeb3, SolanaSendTxParams, string>;
+    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
     /**
      * Gets balance of multiple tokens.
      * @param address Wallet address.
      * @param tokensAddresses Tokens addresses.
      */
     getTokensBalances(address: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    multicallContractsMethods<Output extends Web3PrimitiveType>(): Promise<ContractMulticallResponse<Output>[][]>;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    private createConection;
+    read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
+    write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
+    simulateTransaction(_config: object, _from: string): Promise<void>;
+    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
+    getBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<SolanaBlockchainName>[]>;
     parseRawInstruction(rawInstruction: SolanaRawInstruction[], dataFormat: BufferEncoding): TransactionInstruction[];
     parseLUTAddresses(lookupTableAddresses: string[]): Promise<AddressLookupTableAccount[]>;

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

@@ -1,27 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaAdapter = exports.DEFAULT_CU_LIMIT = exports.NATIVE_SOLANA_MINT_ADDRESS = void 0;
+exports.SolanaAdapter = exports.NATIVE_SOLANA_MINT_ADDRESS = 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 bs58_1 = require("bs58");
 const js_base64_1 = require("js-base64");
-const solana_tokens_service_1 = require("./utils/solana-utils/solana-tokens-service");
-const timeout_1 = require("./utils/timeout");
+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");
 exports.NATIVE_SOLANA_MINT_ADDRESS = 'So11111111111111111111111111111111111111111';
-/* minimal amount for tx (in lamports) */
-exports.DEFAULT_CU_LIMIT = 400_000;
 class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
-    httpClient;
-    constructor(rpcList, httpClient, logger) {
+    constructor(rpcList, httpClient, logger, rubicAppParams) {
         super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
         this.httpClient = httpClient;
-        this.public = this.createPublicClient(rpcList);
+        this.public = this.createConection(rpcList);
+        this.client = new solana_adapter_client_1.SolanaAdapterClient(this.public, httpClient, logger, rubicAppParams);
     }
-    createPublicClient(rpcList) {
+    /**
+     * Gets balance of multiple tokens.
+     * @param address Wallet address.
+     * @param tokensAddresses Tokens addresses.
+     */
+    async getTokensBalances(address, tokensAddresses) {
+        const resp = await this.public._rpcRequest('getTokenAccountsByOwner', [address, { programId: spl_token_1.TOKEN_PROGRAM_ID }, { encoding: 'jsonParsed' }]);
+        const tokenInfo = new Map(resp.result.value.map((el) => {
+            const { mint, tokenAmount } = el.account.data.parsed.info;
+            return [mint, tokenAmount.amount];
+        }));
+        const nativeSolBalance = await this.public.getBalanceAndContext(new web3_js_1.PublicKey(address), 'confirmed');
+        return tokensAddresses.map((tokenAddress) => {
+            if (tokenAddress === exports.NATIVE_SOLANA_MINT_ADDRESS) {
+                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;
@@ -36,73 +60,7 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
     async write(_address, _abi, _method, _methodArgs = []) {
         throw new Error('Method multicall 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, timeout = 15_000) {
-        try {
-            const bufferData = config.data.startsWith('0x') ? Buffer.from(config.data.slice(2), 'hex') : Buffer.from(config.data, 'base64');
-            const { blockhash } = await this.public.getLatestBlockhash();
-            const tx = web3_js_1.VersionedTransaction.deserialize(bufferData);
-            tx.message.recentBlockhash = blockhash;
-            const simulation = this.public.simulateTransaction(tx, {
-                replaceRecentBlockhash: true,
-                commitment: 'confirmed',
-                accounts: {
-                    encoding: 'base64',
-                    addresses: [config.walletAddress]
-                }
-            });
-            const resp = await (0, timeout_1.withTimeout)(simulation, timeout, 'Solana Simulation Timeout!');
-            const err = resp.value.err;
-            const defineCuLimit = () => {
-                const cuLimit = resp.value.unitsConsumed || 0;
-                const defaultGreaterEstimated = new bignumber_js_1.default(exports.DEFAULT_CU_LIMIT).gt(cuLimit);
-                return new bignumber_js_1.default(defaultGreaterEstimated ? exports.DEFAULT_CU_LIMIT : cuLimit).toFixed(0);
-            };
-            if (err) {
-                if (Array.isArray(err['InstructionError'])) {
-                    const [failedInstructionIdx, errorData] = err['InstructionError'];
-                    const failedInstructionProgramId = await this.getFailedIxProgramId(tx, failedInstructionIdx);
-                    this.logger?.customLog('FAILED INSTRUCTION INFO', { programId: failedInstructionProgramId, errorData });
-                    const weirdError = errorData?.Custom === 1;
-                    if (weirdError)
-                        return defineCuLimit();
-                }
-                throw new Error('Transaction simulation failed.');
-            }
-            return defineCuLimit();
-        }
-        catch (err) {
-            this.logger?.customError('Error while simulating transaction', err);
-            throw err;
-        }
-    }
-    async getFailedIxProgramId(tx, failedInstructionIdx) {
-        const lutKeys = (tx.message.addressTableLookups ?? []).map((l) => l.accountKey.toBase58());
-        const lutAccounts = lutKeys.length ? await this.getAddressLookupTableAccounts(lutKeys) : [];
-        const decompiled = web3_js_1.TransactionMessage.decompile(tx.message, { addressLookupTableAccounts: lutAccounts });
-        const programId = decompiled.instructions[failedInstructionIdx].programId;
-        return programId.toBase58();
-    }
-    async getAddressLookupTableAccounts(keys) {
-        const result = [];
-        const infos = await this.public.getMultipleAccountsInfo(keys.map((k) => new web3_js_1.PublicKey(k)));
-        keys.forEach((address, i) => {
-            const ai = infos[i];
-            if (ai) {
-                const alt = new web3_js_1.AddressLookupTableAccount({
-                    key: new web3_js_1.PublicKey(address),
-                    state: web3_js_1.AddressLookupTableAccount.deserialize(ai.data)
-                });
-                result.push(alt);
-            }
-        });
-        return result;
-    }
+    async simulateTransaction(_config, _from) { }
     async checkEnoughBalance(token, walletAddress) {
         const balance = await this.getBalance(walletAddress, token.address);
         return balance.gte(token.tokenAmount);
@@ -116,26 +74,6 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
         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.
-     * @param address Wallet address.
-     * @param tokensAddresses Tokens addresses.
-     */
-    async getTokensBalances(address, tokensAddresses) {
-        const resp = await this.public._rpcRequest('getTokenAccountsByOwner', [address, { programId: spl_token_1.TOKEN_PROGRAM_ID }, { encoding: 'jsonParsed' }]);
-        const tokenInfo = new Map(resp.result.value.map((el) => {
-            const { mint, tokenAmount } = el.account.data.parsed.info;
-            return [mint, tokenAmount.amount];
-        }));
-        const nativeSolBalance = await this.public.getBalanceAndContext(new web3_js_1.PublicKey(address), 'confirmed');
-        return tokensAddresses.map((tokenAddress) => {
-            if (tokenAddress === exports.NATIVE_SOLANA_MINT_ADDRESS) {
-                return new bignumber_js_1.default(nativeSolBalance.value.toString());
-            }
-            const tokenWithBalance = tokenInfo.get(tokenAddress);
-            return new bignumber_js_1.default(tokenWithBalance || NaN);
-        });
-    }
     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/client/sui-adapter-client.d.ts

@@ -0,0 +1,15 @@
+import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
+import { RubicAppAdaptersFactoryParams } from '../../../constants/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> {
+    private readonly suiClient;
+    constructor(suiClient: SuiClient, httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    getBlockchainName(): Promise<BlockchainName>;
+    getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    sendTransaction(params: SuiSendTxParams): Promise<string>;
+    executeTxBlock(params: ExecuteTransactionBlockParams): Promise<SuiTransactionBlockResponse>;
+}

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiAdapterClient = void 0;
+const core_1 = require("@cryptorubic/core");
+const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-client");
+const user_reject_error_1 = require("packages/web3/src/lib/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 {
+    constructor(suiClient, httpClient, logger, rubicAppParams) {
+        super(httpClient, logger, rubicAppParams);
+        this.suiClient = suiClient;
+    }
+    getBlockchainName() {
+        return Promise.resolve(core_1.BLOCKCHAIN_NAME.SUI);
+    }
+    async getTransactionStatus(srcTxHash) {
+        try {
+            const txDetails = await this.suiClient.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 sendTransaction(params) {
+        try {
+            const account = this.clientWallet.accounts[0];
+            const signedTx = await this.clientWallet.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.suiClient.executeTransactionBlock(params);
+    }
+}
+exports.SuiAdapterClient = SuiAdapterClient;

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/sui-adapter.d.ts

@@ -0,0 +1,29 @@
+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 { AbstractAdapterClient } from '../common/client/abstract-adapter-client';
+import { WalletAdapter } from '@suiet/wallet-sdk';
+import { RubicAppAdaptersFactoryParams } from '../../constants/models/create-factory-params';
+import { SuiSendTxParams } from './models/sui-send-tx-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: AbstractAdapterClient<WalletAdapter, SuiSendTxParams, string>;
+    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    multicallContractsMethods<Output extends Web3PrimitiveType>(): Promise<ContractMulticallResponse<Output>[][]>;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
+    write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
+    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,15 +1,32 @@
 "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_client_1 = require("./client/sui-adapter-client");
 class SuiAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(rpcList, logger) {
+    constructor(rpcList, httpClient, logger, rubicAppParams) {
         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, rubicAppParams);
+    }
+    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);
+        });
+    }
+    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 read(_address, _abi, _method, _methodArgs = []) {
         throw new Error('Method read is not supported');
@@ -17,9 +34,6 @@ class SuiAdapter extends abstract_adapter_1.AbstractAdapter {
     async write(_address, _abi, _method, _methodArgs = []) {
         throw new Error('Method write 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');
     }
@@ -71,5 +85,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/client/ton-adapter-client.d.ts

@@ -0,0 +1,41 @@
+import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
+import { RubicAppAdaptersFactoryParams } from '../../../constants/models/create-factory-params';
+import { TxStatus } from '../../models/web3-public-models/tx-status';
+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 { TonAdapterConfig } from '../../models/ton-adapter-config';
+import { TonTransactionConfig } from 'packages/web3/src/lib/utils/models/ton-transaction-config';
+export declare class TonAdapterClient extends AbstractAdapterClient<TonConnectUI, TonSendTxParams, string> {
+    private readonly tonApi;
+    private readonly tonClient;
+    constructor(tonApi: TonApiService, config: TonAdapterConfig, httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    getBlockchainName(): Promise<BlockchainName>;
+    getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    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/client/ton-adapter-client.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonAdapterClient = void 0;
+const core_1 = require("@cryptorubic/core");
+const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-client");
+const user_reject_error_1 = require("packages/web3/src/lib/errors/blockchain/user-reject.error");
+const tx_status_1 = require("../../models/web3-public-models/tx-status");
+const rubic_sdk_error_1 = require("packages/web3/src/lib/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, rubicAppParams) {
+        super(httpClient, logger, rubicAppParams);
+        this.tonApi = tonApi;
+        this.tonClient = new ton_1.TonClient(config.tonClientConfig);
+    }
+    getBlockchainName() {
+        return Promise.resolve(core_1.BLOCKCHAIN_NAME.TON);
+    }
+    async getTransactionStatus(srcTxHash) {
+        const isCompleted = await this.tonApi.checkIsTxCompleted(srcTxHash);
+        if (isCompleted) {
+            return tx_status_1.TX_STATUS.SUCCESS;
+        }
+        return tx_status_1.TX_STATUS.PENDING;
+    }
+    async sendTransaction(params) {
+        try {
+            const { boc } = await this.clientWallet.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.tonClient.runMethod(contractAddress, 'get_wallet_address', [
+            { type: 'slice', cell: (0, core_2.beginCell)().storeAddress(address).endCell() }
+        ]);
+        return addressResult.stack.readAddress();
+    }
+}
+exports.TonAdapterClient = TonAdapterClient;

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?;