@cryptorubic/web3 0.0.34 → 0.0.37-alpha-1212.0

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

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TonApiService = void 0;
 class TonApiService {
-    constructor(httpClient, params) {
+    constructor(httpClient, params, logger) {
         this.httpClient = httpClient;
-        this.apiKey = params.tonApiKey;
+        this.logger = logger;
+        this.apiHeaders = {
+            ...params.tonApiHeaders,
+            referer: 'https://app.rubic.exchange'
+        };
         this.tonApiUrl = params?.tonApiUrl || 'https://tonapi.io';
         this.tonCenterV3Url = params.tonCenterV3Url || 'https://toncenter.com/api/v3';
     }
@@ -13,10 +17,7 @@ class TonApiService {
      */
     async getAllFormatsOfAddress(walletAddress) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/address/${walletAddress}/parse`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://api.rubic.exchange',
-            },
+            headers: this.apiHeaders
         });
         if ('error' in res) {
             throw new Error(`[TonWeb3Pure] Error in getAllFormatsOfAddress - ${res.error}`);
@@ -29,10 +30,7 @@ class TonApiService {
      */
     async fetchWalletSeqno(walletAddress) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/wallet/${walletAddress}/seqno`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://api.rubic.exchange',
-            },
+            headers: this.apiHeaders
         });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchWalletSeqno - ${res.error}`);
@@ -41,10 +39,7 @@ class TonApiService {
     }
     async fetchTxInfo(txHash) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/blockchain/transactions/${txHash}`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://api.rubic.exchange',
-            },
+            headers: this.apiHeaders
         });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchTxInfo - ${res.error}`);
@@ -53,10 +48,7 @@ class TonApiService {
     }
     async fetchTxInfoByMessageHash(txHash) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/blockchain/messages/${txHash}/transaction`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://api.rubic.exchange',
-            },
+            headers: this.apiHeaders
         });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchTxInfoByMessageHash - ${res.error}`);
@@ -66,10 +58,7 @@ class TonApiService {
     async checkIsTxCompleted(txHash) {
         try {
             const res = await this.httpClient.get(`${this.tonApiUrl}/v2/events/${txHash}`, {
-                headers: {
-                    apiKey: this.apiKey,
-                    referer: 'https://api.rubic.exchange',
-                },
+                headers: this.apiHeaders
             });
             if ('error' in res) {
                 throw new Error(`[TonApiService] Error in checkIsTxCompleted - ${res.error}`);
@@ -82,10 +71,7 @@ class TonApiService {
     }
     async healthcheck() {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/status`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://api.rubic.exchange',
-            },
+            headers: this.apiHeaders
         });
         if ('error' in res || !res.rest_online) {
             return false;
@@ -115,10 +101,7 @@ class TonApiService {
             argsParam += '?' + methodArgs.map((param) => `args=${param}`).join('&');
         }
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/blockchain/accounts/${address}/methods/${methodName}${argsParam}`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://api.rubic.exchange',
-            },
+            headers: this.apiHeaders
         });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in callContractMethod - ${res.error}`);
@@ -126,16 +109,18 @@ class TonApiService {
         return res.decoded;
     }
     async fetchTokenInfo(tokenAddress) {
-        const res = await this.httpClient.get(`${this.tonApiUrl}/v2/jettons/${tokenAddress}`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://api.rubic.exchange',
-            },
-        });
-        if ('error' in res) {
-            throw new Error(`[TonApiService] Error in fetchTokenInfo - ${res.error}`);
+        try {
+            const res = await this.httpClient.get(`${this.tonApiUrl}/v2/jettons/${tokenAddress}`, {
+                headers: this.apiHeaders
+            });
+            if ('error' in res) {
+                throw new Error(`[TonApiService] Error in fetchTokenInfo - ${res.error}`);
+            }
+            return res.metadata;
+        }
+        catch (err) {
+            throw new Error(`[TonApiService] Error in fetchTokenInfo - ${err}`);
         }
-        return res.metadata;
     }
     /**
      *
@@ -143,23 +128,24 @@ class TonApiService {
      * @returns balance, decimals, name, symbol, walletJettonAddress, jettonAddress
      */
     async fetchTokenInfoForWallet(walletAddress, tokenAddress) {
-        const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}/jettons/${tokenAddress}`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://api.rubic.exchange',
-            },
-        });
-        if ('error' in res) {
-            throw new Error(`[TonApiService] Error in fetchTokenInfoForWallet - ${res.error}`);
+        try {
+            const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}/jettons/${tokenAddress}`, {
+                headers: this.apiHeaders
+            });
+            if ('error' in res) {
+                this.logger?.customError('[TonApiService] ERROR IN fetchTokenInfoForWallet', res.error);
+                return { balance: '0' };
+            }
+            return res;
+        }
+        catch (err) {
+            this.logger?.customError('[TonApiService] ERROR IN fetchTokenInfoForWallet', err);
+            return { balance: '0' };
         }
-        return res;
     }
     async fetchAllNonNullableTokensInfoForWallet(walletAddress) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}/jettons`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://api.rubic.exchange',
-            },
+            headers: this.apiHeaders
         });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchAllNonNullableTokensInfoForWallet - ${res.error}`);
@@ -171,10 +157,7 @@ class TonApiService {
      */
     async fetchAccountInfo(walletAddress) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://api.rubic.exchange',
-            },
+            headers: this.apiHeaders
         });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchAccountInfo - ${res.error}`);

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

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

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonAdapterSigner = void 0;
+const core_1 = require("@cryptorubic/core");
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
+const user_reject_error_1 = require("../../../../errors/blockchain/user-reject.error");
+const rubic_sdk_error_1 = require("../../../../errors/rubic-sdk.error");
+const errors_1 = require("../../utils/errors");
+const core_2 = require("@ton/core");
+const waitFor_1 = require("../../utils/waitFor");
+class TonAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    get publicClient() {
+        if (!this.publicRef.public) {
+            const msg = `Trying to access undefined publicClient in TonAdapterSigner.`;
+            this.logger?.customLog(msg);
+            throw new Error(msg);
+        }
+        return this.publicRef.public;
+    }
+    constructor(tonApi, publicRef, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+        this.tonApi = tonApi;
+        this.publicRef = publicRef;
+    }
+    async write() {
+        throw new Error('Method write is not supported');
+    }
+    getBlockchainName() {
+        return Promise.resolve(core_1.BLOCKCHAIN_NAME.TON);
+    }
+    async sendTransaction(params) {
+        try {
+            const { boc } = await this.wallet.sendTransaction({
+                validUntil: Math.floor(Date.now() / 1000) + 360,
+                messages: params.txOptions.messages
+            });
+            const txHash = this.fromBocToBase64Hash(boc);
+            params.txOptions.onTransactionHash?.(txHash);
+            const isCompleted = await this.waitForTransactionReceipt(txHash);
+            if (!isCompleted) {
+                throw new rubic_sdk_error_1.RubicSdkError('[BitcoinWeb3Private] TON transaction timeout expired!');
+            }
+            return boc;
+        }
+        catch (err) {
+            console.error(`Send transaction error. ${err}`);
+            if (err.message.includes('Reject request')) {
+                throw new user_reject_error_1.UserRejectError();
+            }
+            throw (0, errors_1.parseError)(err);
+        }
+    }
+    async waitForTransactionReceipt(txHash) {
+        let isCompleted = false;
+        const startTimeMS = Date.now();
+        const timeLimitMS = 600 * 1000;
+        while (Date.now() < startTimeMS + timeLimitMS) {
+            if (isCompleted)
+                return true;
+            await (0, waitFor_1.waitFor)(30000);
+            isCompleted = await this.tonApi.checkIsTxCompleted(txHash);
+        }
+        return false;
+    }
+    /**
+     * Transfer asset from on wallet to another
+     * @param tokenAddress Token address to transfer
+     * @param walletAddress Wallet address to transfer from
+     * @param receiver Receiver wallet address
+     * @param amount Transfer amount
+     * @param options Transaction options
+     */
+    transferAsset(tokenAddress, walletAddress, receiver, amount, options) {
+        if ((0, core_1.compareAddresses)(core_1.nativeTokensList.TON.address, tokenAddress)) {
+            return this.transferNative(receiver, amount, options);
+        }
+        return this.transferJetton(tokenAddress, walletAddress, receiver, amount, options);
+    }
+    transferNative(receiver, amount, options) {
+        const transferAmount = BigInt(amount);
+        const encodeConfig = {
+            address: receiver,
+            amount: transferAmount.toString()
+        };
+        return this.sendTransaction({ txOptions: { messages: [encodeConfig], onTransactionHash: options?.onTransactionHash } });
+    }
+    async transferJetton(tokenAddress, walletAddress, receiver, amount, options) {
+        const fromAddress = core_2.Address.parse(walletAddress);
+        const contractAddress = core_2.Address.parse(tokenAddress);
+        const transferAmount = BigInt(amount);
+        const receiverAddress = core_2.Address.parse(receiver);
+        const jettonWalletAddress = await this.getJettonWalletAddress(fromAddress, contractAddress);
+        const body = (0, core_2.beginCell)()
+            .storeUint(0xf8a7ea5, 32)
+            .storeUint(0, 64)
+            .storeCoins(transferAmount)
+            .storeAddress(receiverAddress)
+            .storeAddress(receiverAddress)
+            .storeBit(0)
+            .storeCoins((0, core_2.toNano)('0.02'))
+            .storeBit(0)
+            .endCell();
+        const encodeConfig = {
+            address: jettonWalletAddress.toRawString(),
+            amount: (0, core_2.toNano)('0.05').toString(),
+            payload: body.toBoc().toString('base64')
+        };
+        return this.sendTransaction({ txOptions: { messages: [encodeConfig], onTransactionHash: options?.onTransactionHash } });
+    }
+    getTransferEncodedConfig(tokenAddress, walletAddress, receiver, amount) {
+        if ((0, core_1.compareAddresses)(core_1.nativeTokensList.TON.address, tokenAddress)) {
+            return this.getTransferNativeConfig(receiver, amount);
+        }
+        return this.getTransferJettonConfig(tokenAddress, walletAddress, receiver, amount);
+    }
+    async getTransferNativeConfig(receiver, amount) {
+        const transferAmount = BigInt(amount);
+        const encodeConfig = {
+            address: receiver,
+            amount: transferAmount.toString()
+        };
+        return encodeConfig;
+    }
+    async getTransferJettonConfig(tokenAddress, walletAddress, receiver, amount) {
+        const fromAddress = core_2.Address.parse(walletAddress);
+        const contractAddress = core_2.Address.parse(tokenAddress);
+        const transferAmount = BigInt(amount);
+        const receiverAddress = core_2.Address.parse(receiver);
+        const jettonWalletAddress = await this.getJettonWalletAddress(fromAddress, contractAddress);
+        const body = (0, core_2.beginCell)()
+            .storeUint(0xf8a7ea5, 32)
+            .storeUint(0, 64)
+            .storeCoins(transferAmount)
+            .storeAddress(receiverAddress)
+            .storeAddress(receiverAddress)
+            .storeBit(0)
+            .storeCoins((0, core_2.toNano)('0.02'))
+            .storeBit(0)
+            .endCell();
+        const encodeConfig = {
+            address: jettonWalletAddress.toRawString(),
+            amount: (0, core_2.toNano)('0.05').toString(),
+            payload: body.toBoc().toString('base64')
+        };
+        return encodeConfig;
+    }
+    /**
+     *
+     * @param boc Boc returned in connector.sendTransaction
+     * @returns boc converter in base 64 string
+     */
+    fromBocToBase64Hash(boc) {
+        const inMsgCell = core_2.Cell.fromBase64(boc);
+        const inMsgHash = inMsgCell.hash();
+        const inMsgHashBase64 = inMsgHash.toString('base64');
+        const inMsgHashBase64Url = inMsgHashBase64.replace(/\+/g, '-').replace(/\//g, '_');
+        return inMsgHashBase64Url;
+    }
+    async getJettonWalletAddress(address, contractAddress) {
+        const addressResult = await this.publicClient.runMethod(contractAddress, 'get_wallet_address', [
+            { type: 'slice', cell: (0, core_2.beginCell)().storeAddress(address).endCell() }
+        ]);
+        return addressResult.stack.readAddress();
+    }
+}
+exports.TonAdapterSigner = TonAdapterSigner;

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

@@ -0,0 +1,32 @@
+import { BlockchainName, HttpClient, ICustomLogger, PriceTokenAmount, Token, TokenAmount, TonBlockchainName } from '@cryptorubic/core';
+import { TonClient } from '@ton/ton';
+import { TonApiParseAddressResp } from '../models/tonapi-models';
+import { TonAdapterConfig } from '../models/ton-adapter-config';
+import BigNumber from 'bignumber.js';
+import { AbstractAdapter } from '../common/abstract-adapter';
+import { TonConnectUI } from '@tonconnect/ui';
+import { TonAdapterSigner } from './signer/ton-adapter-signer';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
+import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
+import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
+import { TxStatus } from '../models/web3-public-models/tx-status';
+export declare class TonAdapter extends AbstractAdapter<TonClient, TonConnectUI, TonBlockchainName> {
+    private readonly config;
+    readonly signer: TonAdapterSigner;
+    private readonly tonApi;
+    constructor(httpClient: HttpClient, config: TonAdapterConfig, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    initWeb3Client(): void;
+    read<T>(): Promise<T>;
+    callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
+    getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    multicallContractsMethods<Output extends Web3PrimitiveType>(): Promise<ContractMulticallResponse<Output>[][]>;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
+    getAllFormatsOfAddress(walletAddress: string): Promise<TonApiParseAddressResp>;
+    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
+    getBalance(walletAddress: string, tokenAddress?: string): Promise<BigNumber>;
+}

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonAdapter = void 0;
+const core_1 = require("@cryptorubic/core");
+const ton_api_service_1 = require("./services/ton-api.service");
+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_signer_1 = require("./signer/ton-adapter-signer");
+const tx_status_1 = require("../models/web3-public-models/tx-status");
+class TonAdapter extends abstract_adapter_1.AbstractAdapter {
+    constructor(httpClient, config, logger, clientParams) {
+        super(core_1.BLOCKCHAIN_NAME.TON, logger);
+        this.config = config;
+        this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig, logger);
+        this.signer = new ton_adapter_signer_1.TonAdapterSigner(this.tonApi, this.publicRef, httpClient, logger, clientParams);
+    }
+    initWeb3Client() {
+        this.public = new ton_1.TonClient(this.config.tonClientConfig);
+    }
+    async read() {
+        throw new Error('Method read is not supported');
+    }
+    async callContractMethod() {
+        throw new Error('Method call is not supported');
+    }
+    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 getTokensBalances(userAddress, tokensAddresses) {
+        const tokensWithBalance = await this.tonApi.fetchAllNonNullableTokensInfoForWallet(userAddress);
+        const nativeIndex = tokensAddresses.findIndex((tokenAddress) => web3_pure_1.Web3Pure.isNativeAddress('TON', tokenAddress));
+        if (!tokensWithBalance.length && nativeIndex === -1) {
+            return [];
+        }
+        const balances = tokensAddresses
+            .filter((tokenAddress) => !web3_pure_1.Web3Pure.isNativeAddress('TON', tokenAddress))
+            .map((address) => {
+            const tokenWithBalance = tokensWithBalance.find((token) => token.jetton.address.toLowerCase() === ton_1.Address.parse(address).toRawString().toLowerCase());
+            if (tokenWithBalance) {
+                return new bignumber_js_1.default(tokenWithBalance.balance);
+            }
+            return new bignumber_js_1.default(0);
+        });
+        if (nativeIndex !== -1) {
+            const acountInfo = await this.tonApi.fetchAccountInfo(userAddress);
+            const nativeBalance = new bignumber_js_1.default(acountInfo.balance);
+            balances.splice(nativeIndex, 0, nativeBalance);
+        }
+        return balances;
+    }
+    multicallContractsMethods() {
+        throw new Error('Method not implemented.');
+    }
+    async getBlockNumber() {
+        try {
+            const block = await this.tonApi.fetchLastBlockInfo();
+            return block.seqno;
+        }
+        catch {
+            return 0;
+        }
+    }
+    async callForTokensInfo(tokenAddresses) {
+        const info = await Promise.all(tokenAddresses.map((address) => {
+            if (web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.TON, address)) {
+                const nativeToken = core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.TON];
+                return nativeToken;
+            }
+            return this.tonApi.fetchTokenInfo(address);
+        }));
+        if (!info.length)
+            return [];
+        const necessaryInfo = info.map(({ decimals, name, symbol, address }) => new core_1.Token({
+            address,
+            blockchain: core_1.BLOCKCHAIN_NAME.TON,
+            decimals: Number(decimals),
+            name,
+            symbol
+        }));
+        return necessaryInfo;
+    }
+    async getAllFormatsOfAddress(walletAddress) {
+        return this.tonApi.getAllFormatsOfAddress(walletAddress);
+    }
+    async checkEnoughBalance(token, walletAddress) {
+        const weiBalance = await this.getBalance(walletAddress, token.address);
+        const balance = core_1.Token.fromWei(weiBalance, token.decimals);
+        return balance.gte(token.tokenAmount);
+    }
+    async getBalance(walletAddress, tokenAddress) {
+        const isNative = !tokenAddress || web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.TON, tokenAddress);
+        const tokenBalance = isNative
+            ? (await this.tonApi.fetchAccountInfo(walletAddress)).balance
+            : (await this.tonApi.fetchTokenInfoForWallet(walletAddress, tokenAddress)).balance;
+        return new bignumber_js_1.default(tokenBalance || 0);
+    }
+}
+exports.TonAdapter = TonAdapter;

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

@@ -0,0 +1,13 @@
+import { TronParameters } from '../../../../utils/models/tron-parameters';
+import { BasicSendTransactionOptions } from '../../models/basic-transaction-options';
+export interface TronSendTxParams {
+    contractAddress: string;
+    methodSignature: string;
+    parameters: TronParameters;
+    txOptions: TronTransactionOptions;
+}
+export interface TronTransactionOptions extends BasicSendTransactionOptions {
+    feeLimit?: number;
+    callValue?: number;
+    rawParameter?: string;
+}

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

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

package/src/lib/adapter/adapters/adapter-tron/models/tron-transfer-tx-params.d.ts

@@ -0,0 +1,7 @@
+import { TronTransactionOptions } from './tron-send-tx-params';
+export interface TronTransferTxParams {
+    receiver: string;
+    tokenWeiAmount: string;
+    tokenAddress: string;
+    txOptions: TronTransactionOptions;
+}

package/src/lib/adapter/adapters/adapter-tron/models/tron-transfer-tx-params.js

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

package/src/lib/adapter/adapters/adapter-tron/models/tron-web-provider.d.ts

@@ -0,0 +1,4 @@
+export interface TronWebProvider {
+    fullHost: string;
+    headers?: Record<string, string>;
+}

package/src/lib/adapter/adapters/adapter-tron/models/tron-web-provider.js

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

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

@@ -0,0 +1,19 @@
+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 { TronParameters } from '../../../../utils/models/tron-parameters';
+import { TronTransferTxParams } from '../models/tron-transfer-tx-params';
+export declare class TronAdapterSigner extends AbstractAdapterSigner<TronWeb, TronSendTxParams, string> {
+    private readonly publicRef;
+    get publicClient(): TronWeb;
+    constructor(publicRef: {
+        public: TronWeb | null;
+    }, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    write(contractAddress: string, methodSignature: string, parameters: TronParameters): Promise<string>;
+    getBlockchainName(): Promise<BlockchainName>;
+    sendTransaction(params: TronSendTxParams): Promise<string>;
+    trySendTransaction(params: TronSendTxParams): Promise<string>;
+    transfer(params: TronTransferTxParams): Promise<string>;
+}

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

@@ -0,0 +1,81 @@
+"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 parse_tron_error_1 = require("../utils/parse-tron-error");
+class TronAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    get publicClient() {
+        if (!this.publicRef.public) {
+            const msg = `Trying to access undefined publicClient in TronAdapterSigner.`;
+            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(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 sendTransaction(params) {
+        try {
+            const transaction = await this.wallet.transactionBuilder.triggerSmartContract(params.contractAddress, params.methodSignature, params.txOptions, params.parameters, this.walletAddress);
+            const signedTransaction = await this.wallet.trx.sign(transaction.transaction);
+            const receipt = await this.wallet.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.wallet.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);
+    }
+    async transfer(params) {
+        try {
+            if ((0, core_1.compareAddresses)(params.tokenAddress, core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.TRON].address)) {
+                const transaction = await this.wallet.transactionBuilder.sendTrx(params.receiver, parseInt(params.tokenWeiAmount));
+                const signedTransaction = await this.wallet.trx.sign(transaction);
+                const receipt = await this.wallet.trx.sendRawTransaction(signedTransaction);
+                if (params.txOptions.onTransactionHash) {
+                    params.txOptions.onTransactionHash(receipt.transaction.txID);
+                }
+                return receipt.transaction.txID;
+            }
+            const contract = await this.wallet.contract().at(params.tokenAddress);
+            const transaction = await contract['transfer'](params.receiver, parseInt(params.tokenWeiAmount)).send();
+            const txId = typeof transaction === 'string' ? transaction : transaction.txid;
+            if (params.txOptions.onTransactionHash) {
+                params.txOptions.onTransactionHash(txId);
+            }
+            return txId;
+        }
+        catch (err) {
+            console.error('Method execution error: ', err);
+            throw (0, parse_tron_error_1.parseTronError)(err);
+        }
+    }
+}
+exports.TronAdapterSigner = TronAdapterSigner;