@cryptorubic/web3 0.0.34 → 0.0.37-alpha-1212.0

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

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StellarAdapter = void 0;
+const core_1 = require("@cryptorubic/core");
+const abstract_adapter_1 = require("../common/abstract-adapter");
+const tx_status_1 = require("../models/web3-public-models/tx-status");
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const stellar_adapter_signer_1 = require("./signer/stellar-adapter-signer");
+const stellar_sdk_2 = require("@stellar/stellar-sdk");
+const bignumber_js_1 = require("bignumber.js");
+const web3_pure_1 = require("../../../utils/web3-pure");
+const fake_stellar_wallet_1 = require("./constants/fake-stellar-wallet");
+const inactive_account_error_1 = require("../../../errors/blockchain/inactive-account.error");
+class StellarAdapter extends abstract_adapter_1.AbstractAdapter {
+    constructor(rpc, httpClient, logger, clientParams) {
+        super(core_1.BLOCKCHAIN_NAME.STELLAR, logger);
+        this.rpc = rpc;
+        this.CLASSIC_TOKEN_DECIMALS = 7;
+        this.signer = new stellar_adapter_signer_1.StellarAdapterSigner(this.publicRef, httpClient, logger, clientParams);
+        this.horizonClient = new stellar_sdk_1.Horizon.Server(rpc[0].horizon, {
+            allowHttp: true,
+            appName: 'rubic.exchange',
+            headers: rpc[0].horizonHeaders
+        });
+    }
+    initWeb3Client() {
+        this.public = new stellar_sdk_2.rpc.Server(this.rpc[0].soroban, {
+            allowHttp: true,
+            timeout: 5000,
+            headers: this.rpc[0].sorobanHeaders
+        });
+    }
+    async getBlockNumber() {
+        const { sequence } = await this.public.getLatestLedger();
+        return sequence;
+    }
+    async getTokensBalances(userAddress, tokensAddresses) {
+        try {
+            const balances = (await this.horizonClient.loadAccount(userAddress)).balances;
+            return tokensAddresses.map((token) => {
+                const possibleBalance = balances.find((balance) => {
+                    if (balance.asset_type === 'native') {
+                        return web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.STELLAR, token);
+                    }
+                    const tokenBalance = balance;
+                    return (0, core_1.compareAddresses)(token, `${tokenBalance.asset_code}-${tokenBalance.asset_issuer}`);
+                });
+                return new bignumber_js_1.default(core_1.Token.toWei(possibleBalance?.balance || '0', this.CLASSIC_TOKEN_DECIMALS));
+            });
+        }
+        catch (err) {
+            console.error(err);
+            return tokensAddresses.map(() => new bignumber_js_1.default(0));
+        }
+    }
+    async getBalance(userAddress, tokenAddress) {
+        try {
+            if (!tokenAddress || web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.STELLAR, tokenAddress)) {
+                const resp = await this.public.getAccountEntry(userAddress);
+                return new bignumber_js_1.default(resp.balance().toString());
+            }
+            const resp = await this.public.getTrustline(userAddress, this.convertTokenAddressToAsset(tokenAddress));
+            return new bignumber_js_1.default(resp.balance().toString());
+        }
+        catch {
+            return new bignumber_js_1.default(0);
+        }
+    }
+    async callForTokensInfo(tokenAddresses) {
+        return Promise.all(tokenAddresses.map((token) => this.callForTokenInfo(token)));
+    }
+    async callForTokenInfo(tokenAddress) {
+        if (web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.STELLAR, tokenAddress)) {
+            return core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.STELLAR];
+        }
+        const [code, issuer] = tokenAddress.toUpperCase().split('-');
+        try {
+            const fetchedTokens = await this.horizonClient.assets().forIssuer(issuer).limit(200).call();
+            const fetchedToken = fetchedTokens.records.find((fetchedToken) => (0, core_1.compareAddresses)(fetchedToken.asset_code, code) &&
+                (0, core_1.compareAddresses)(fetchedToken.asset_issuer, issuer) &&
+                parseFloat(fetchedToken.balances.authorized) > 0);
+            if (fetchedToken && 'toml' in fetchedToken._links) {
+                const { href } = fetchedToken._links.toml;
+                if (href) {
+                    const { CURRENCIES } = await stellar_sdk_1.StellarToml.Resolver.resolve(new URL(href).hostname, { allowHttp: true }).catch(() => ({}));
+                    if (CURRENCIES) {
+                        const tomlToken = CURRENCIES.find((currency) => (0, core_1.compareAddresses)(fetchedToken.asset_code, currency.code) &&
+                            (0, core_1.compareAddresses)(fetchedToken.asset_issuer, currency.issuer));
+                        return new core_1.Token({
+                            name: tomlToken.name || tomlToken.code,
+                            symbol: tomlToken.code,
+                            decimals: tomlToken.display_decimals || this.CLASSIC_TOKEN_DECIMALS,
+                            blockchain: core_1.BLOCKCHAIN_NAME.STELLAR,
+                            address: `${tomlToken.code}-${tomlToken.issuer}`
+                        });
+                    }
+                }
+                return new core_1.Token({
+                    name: fetchedToken.asset_code,
+                    symbol: fetchedToken.asset_code,
+                    decimals: this.CLASSIC_TOKEN_DECIMALS,
+                    blockchain: core_1.BLOCKCHAIN_NAME.STELLAR,
+                    address: `${fetchedToken.asset_code}-${fetchedToken.asset_issuer}`
+                });
+            }
+            throw new Error('Token not found');
+        }
+        catch (err) {
+            console.error(err);
+            throw err;
+        }
+    }
+    async checkEnoughBalance(token, walletAddress) {
+        const userBalance = await this.getBalance(walletAddress, token.address);
+        return userBalance.gte(token.weiAmount);
+    }
+    async needTrustline(token, walletAddress) {
+        const isCorrectWalletAddress = await web3_pure_1.Web3Pure.isAddressCorrect(core_1.BLOCKCHAIN_NAME.STELLAR, walletAddress);
+        if (token.isNative || !isCorrectWalletAddress)
+            return false;
+        try {
+            const trustline = await this.public.getTrustline(walletAddress, this.convertTokenAddressToAsset(token.address));
+            return new bignumber_js_1.default(trustline.limit().toString()).lt(token.weiAmount);
+        }
+        catch (err) {
+            return true;
+        }
+    }
+    async addTrustline(tokenAddress) {
+        try {
+            const tx = await this.encodeTrustline(tokenAddress, this.signer.walletAddress);
+            const { signedTxXdr } = await this.signer.wallet.signTransaction(tx, {
+                networkPassphrase: stellar_sdk_1.Networks.PUBLIC,
+                address: this.signer.walletAddress
+            });
+            const resp = await this.public.sendTransaction(stellar_sdk_1.TransactionBuilder.fromXDR(signedTxXdr, stellar_sdk_1.Networks.PUBLIC));
+            if (resp.status === 'ERROR' && resp.errorResult) {
+                this.signer.parseTxError(resp.errorResult);
+            }
+            const resStatus = await this.public.pollTransaction(resp.hash);
+            if (resStatus.status === 'FAILED') {
+                this.signer.parseTxError(resStatus.resultXdr);
+            }
+            return resStatus.txHash;
+        }
+        catch (err) {
+            this.logger?.customError('FAILED TO ADD TRUSTLINE', err);
+            throw err;
+        }
+    }
+    async encodeTrustline(tokenAddress, walletAddress) {
+        const account = await this.getAccountInfo(walletAddress);
+        const tx = new stellar_sdk_1.TransactionBuilder(account, {
+            fee: stellar_sdk_1.BASE_FEE,
+            networkPassphrase: stellar_sdk_1.Networks.PUBLIC
+        })
+            .addOperation(stellar_sdk_1.Operation.changeTrust({
+            asset: this.convertTokenAddressToAsset(tokenAddress)
+        }))
+            .setTimeout(600)
+            .build();
+        return tx.toXDR();
+    }
+    getTokenContractId(tokenAddress) {
+        if (web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.STELLAR, tokenAddress)) {
+            return stellar_sdk_1.Asset.native().contractId(stellar_sdk_1.Networks.PUBLIC);
+        }
+        return this.convertTokenAddressToAsset(tokenAddress).contractId(stellar_sdk_1.Networks.PUBLIC);
+    }
+    convertTokenAddressToAsset(tokenAddress) {
+        const [code, issuer] = tokenAddress.split('-');
+        return new stellar_sdk_1.Asset(code, issuer);
+    }
+    async read(address, method, methodArgs = []) {
+        const contract = new stellar_sdk_1.Contract(address);
+        const args = methodArgs.map(({ value, type }) => (0, stellar_sdk_1.nativeToScVal)(value, { type }));
+        const operation = contract.call(method, ...args);
+        const tx = new stellar_sdk_1.TransactionBuilder(new stellar_sdk_1.Account(fake_stellar_wallet_1.FAKE_STELLAR_WALLET, '0'), {
+            fee: stellar_sdk_1.BASE_FEE,
+            networkPassphrase: stellar_sdk_1.Networks.PUBLIC
+        })
+            .addOperation(operation)
+            .setTimeout(600)
+            .build();
+        const resp = await this.public.simulateTransaction(tx);
+        if ('error' in resp) {
+            throw new Error(resp.error);
+        }
+        const rawValue = resp.result.retval;
+        return (0, stellar_sdk_1.scValToNative)(rawValue);
+    }
+    async simulateTransaction(config) {
+        try {
+            const resp = await this.public.simulateTransaction(stellar_sdk_1.TransactionBuilder.fromXDR(config.transaction, stellar_sdk_1.Networks.PUBLIC));
+            if ('error' in resp) {
+                throw new Error(resp.error);
+            }
+            return resp.minResourceFee;
+        }
+        catch (err) {
+            this.logger?.customError('Error while simulating transaction', err);
+            throw err;
+        }
+    }
+    async getTransactionStatus(srcTxHash) {
+        try {
+            const resp = await this.public.pollTransaction(srcTxHash);
+            if (resp.status === 'SUCCESS') {
+                return tx_status_1.TX_STATUS.SUCCESS;
+            }
+            if (resp.status === 'FAILED') {
+                return tx_status_1.TX_STATUS.FAIL;
+            }
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+        catch {
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+    }
+    async getMinWeiBalance(userAddress) {
+        try {
+            const resp = await this.public.getAccountEntry(userAddress);
+            const baseReserve = 5000000;
+            return new bignumber_js_1.default(2 + resp.numSubEntries()).multipliedBy(baseReserve);
+        }
+        catch {
+            return new bignumber_js_1.default(0);
+        }
+    }
+    getFeeFromTransaction(xdr) {
+        const parsedTranssaction = stellar_sdk_1.TransactionBuilder.fromXDR(xdr, stellar_sdk_1.Networks.PUBLIC);
+        return new bignumber_js_1.default(parsedTranssaction.fee);
+    }
+    async getAccountInfo(walletAddress) {
+        try {
+            const account = await this.public.getAccount(walletAddress);
+            return account;
+        }
+        catch (err) {
+            if (err.message?.includes('Account not found')) {
+                throw new inactive_account_error_1.InactiveAccountError();
+            }
+            throw err;
+        }
+    }
+    async callContractMethod(_contractAddress, _contractAbi = [], _methodName, _methodArguments = [], _options) {
+        throw new Error('Method call is not supported');
+    }
+    multicallContractsMethods(_contractAbi, _contractsData) {
+        throw new Error('Method multicall is not supported');
+    }
+}
+exports.StellarAdapter = StellarAdapter;

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiAdapter = void 0;
+const core_1 = require("@cryptorubic/core");
+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, httpClient, logger, clientParams) {
+        super(core_1.BLOCKCHAIN_NAME.SUI, logger);
+        this.rpcList = rpcList;
+        this.signer = new sui_adapter_signer_1.SuiAdapterSigner(this.publicRef, httpClient, logger, clientParams);
+    }
+    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 getTransactionStatus(srcTxHash) {
+        try {
+            const txDetails = await this.public.getTransactionBlock({ digest: srcTxHash, options: { showEffects: true } });
+            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);
+        });
+    }
+    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');
+    }
+    async simulateTransaction(_config, _from) { }
+    async callForTokensInfo(tokenAddresses) {
+        const nativeToken = core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.SUI];
+        const nativeTokenIndex = tokenAddresses.findIndex((address) => web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.SUI, address));
+        const filteredTokenAddresses = tokenAddresses.filter((_, index) => index !== nativeTokenIndex);
+        // only native token in array
+        if (!filteredTokenAddresses.length && nativeTokenIndex !== -1) {
+            return [nativeToken];
+        }
+        const allTokensMeta = await Promise.all(filteredTokenAddresses.map((coinType) => this.public.getCoinMetadata({ coinType })));
+        const tokens = allTokensMeta.map((metadata, metaIndex) => {
+            if (metadata) {
+                if (!metadata) {
+                    return null;
+                }
+                const token = new core_1.Token({
+                    decimals: metadata.decimals,
+                    symbol: metadata.symbol,
+                    name: metadata.name,
+                    blockchain: core_1.BLOCKCHAIN_NAME.SUI,
+                    address: filteredTokenAddresses[metaIndex]
+                });
+                return token;
+            }
+            return null;
+        });
+        if (nativeTokenIndex === -1) {
+            return tokens;
+        }
+        tokens.splice(nativeTokenIndex, 0, nativeToken);
+        return tokens;
+    }
+    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.BLOCKCHAIN_NAME.SUI, tokenAddress);
+        if (isToken) {
+            const balance = await this.public.getBalance({
+                owner: userAddress,
+                coinType: tokenAddress
+            });
+            return new bignumber_js_1.default(balance.totalBalance);
+        }
+        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 apiHeaders;
     private readonly tonCenterV3Url;
-    constructor(httpClient: HttpClient, params: TonApiConfig);
+    constructor(httpClient: HttpClient, params: TonApiConfig, logger?: ICustomLogger | undefined);
     /**
      * @param walletAddress in any format: raw or friendly
      */