@cryptorubic/web3 0.0.22 → 0.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptorubic/web3",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "dependencies": {
     "tslib": "^2.3.0"
   },

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

@@ -9,9 +9,6 @@ export declare abstract class AbstractAdapter<P, W, B extends BlockchainName> {
     private _wallet;
     set wallet(value: W | null);
     get wallet(): W;
-    private _walletAddress;
-    set walletAddress(value: string | null);
-    get walletAddress(): string;
     protected constructor(blockchain: B, logger?: ICustomLogger);
     abstract callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
     needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string | BigNumber): Promise<boolean>;

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

@@ -25,21 +25,9 @@ class AbstractAdapter {
         }
         return this._wallet;
     }
-    set walletAddress(value) {
-        this._walletAddress = value;
-    }
-    get walletAddress() {
-        if (!this._walletAddress) {
-            const msg = 'Trying to access undefined walletAddress';
-            this.logger?.customLog(msg);
-            throw new Error(msg);
-        }
-        return this._walletAddress;
-    }
     constructor(blockchain, logger) {
         this._public = null;
         this._wallet = null;
-        this._walletAddress = null;
         this.blockchain = blockchain;
         if (logger) {
             this.logger = logger;

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

@@ -6,7 +6,7 @@ import { EvmAdapterOptions } from "./models/evm-adapter-options";
 import { EvmTransactionConfig } from "../../utils/models/evm-transaction-config";
 import { ApproveAdapter } from "./models/approve-adapter";
 import { AllowanceInfo } from "./models/common-types";
-export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicClient, WalletClient & WalletActions, EvmBlockchainName> implements ApproveAdapter<EvmTransactionConfig> {
+export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicClient, WalletClient & WalletActions, EvmBlockchainName> implements ApproveAdapter {
     needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
     handlePreswap(contractAddress: string, walletAddress: string, tokenAmount: TokenAmount): Promise<void>;
     constructor(adapterOptions: EvmAdapterOptions, logger?: ICustomLogger);
@@ -31,5 +31,4 @@ export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicCl
     getAllowance(fromTokenAddress: string, walletAddress: string, spenderAddress: string): Promise<AllowanceInfo>;
     encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): EvmTransactionConfig;
     needApprove(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
-    approve(fromAddress: string, tokenAddress: string, spenderAddress: string, amount?: string): Promise<string>;
 }

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

@@ -136,7 +136,8 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
                 to: config.to,
                 ...(config.value && { value: BigInt(config.value) })
             };
-            await this.public.call(callParams);
+            // @ts-ignore
+            await this.core.call(callParams);
         }
         catch (err) {
             this.logger?.customError('Error while simulating transaction', err);
@@ -242,10 +243,5 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
         return allowanceWei.lt(token.weiAmount);
     }
     ;
-    async approve(fromAddress, tokenAddress, spenderAddress, amount) {
-        const config = this.encodeApprove(tokenAddress, spenderAddress, amount);
-        return this.write(fromAddress, config.to, config.value, config.data);
-    }
-    ;
 }
 exports.EvmAdapter = EvmAdapter;

package/src/lib/adapter/adapters/models/approve-adapter.d.ts

@@ -1,6 +1,7 @@
 import { TokenAmount } from "@cryptorubic/core";
 import { AllowanceInfo } from "./common-types";
-export interface ApproveAdapter<T> {
+import { EvmTransactionConfig } from "../../../utils/models/evm-transaction-config";
+export interface ApproveAdapter {
     /**
      * @param fromTokenAddress erc20 address of checked token
      * @param walletAddress owner wallet address
@@ -9,12 +10,12 @@ export interface ApproveAdapter<T> {
      */
     getAllowance(fromTokenAddress: string, walletAddress: string, spenderAddress: string): Promise<AllowanceInfo>;
     /**
-     * Get data for tokens approve
+     *
      * @param tokenAddress erc20 token address
      * @param spenderAddress spender address
      * @param amount amount in non wei
      */
-    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): T;
+    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): EvmTransactionConfig;
     /**
      * Check if approve needed.
      * @param token
@@ -23,11 +24,4 @@ export interface ApproveAdapter<T> {
      * @param amount
      */
     needApprove(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
-    /**
-     * Get data for tokens approve
-     * @param tokenAddress erc20 token address
-     * @param spenderAddress spender address
-     * @param amount amount in non wei
-     */
-    approve(walletAddress: string, tokenAddress: string, spenderAddress: string, amount?: string): Promise<string>;
 }

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

@@ -9,7 +9,8 @@ import { TronParameters } from "../../utils/models/tron-parameters";
 import { Abi } from "viem";
 import { ApproveAdapter } from "./models/approve-adapter";
 import { AllowanceInfo } from "./models/common-types";
-export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> implements ApproveAdapter<TronTransactionConfig> {
+import { EvmTransactionConfig } from "../../utils/models/evm-transaction-config";
+export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> implements ApproveAdapter {
     private readonly multicallAddress;
     needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
     constructor(rpcList: string[], logger?: ICustomLogger);
@@ -18,18 +19,18 @@ export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronB
         methodsData: MethodData[];
     }[]): Promise<ContractMulticallResponse<Output>[][]>;
     private multicall;
-    read<T>(contractAddress: string, contractAbi: readonly AbiFragment[], methodName: string, methodArguments?: unknown[]): Promise<T>;
+    callContractMethod<T extends TronWeb3PrimitiveType = string>(contractAddress: string, contractAbi: readonly AbiFragment[], methodName: string, methodArguments?: unknown[]): Promise<T>;
     private multicallContractsMethodsByOne;
     getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token[]>;
     getBalance(userAddress: string, tokenAddress?: string): Promise<BigNumber>;
     getTokenBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
     convertTronAddressToHex(address: string): Promise<string>;
-    write(contractAddress: string, methodSignature: string, parameters: TronParameters): Promise<string>;
+    read<T>(): Promise<T>;
+    write(): Promise<string>;
     static encodeMethodCall(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments: TronParameters, callValue?: string, feeLimit?: number): TronTransactionConfig;
     private static flattenTypesToString;
     needApprove(from: TokenAmount | PriceTokenAmount, walletAddress: string, spender: string): Promise<boolean>;
-    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): TronTransactionConfig;
+    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): EvmTransactionConfig;
     getAllowance(fromTokenAddress: string, walletAddress: string, spender: string): Promise<AllowanceInfo>;
-    approve(fromAddress: string, tokenAddress: string, spenderAddress: string, amount?: string): Promise<string>;
 }

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

@@ -51,7 +51,7 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
         // @ts-ignore
         return contract.aggregateViewCalls(calls).call();
     }
-    async read(contractAddress, contractAbi, methodName, methodArguments = []) {
+    async callContractMethod(contractAddress, contractAbi, methodName, methodArguments = []) {
         this.public.setAddress(contractAddress);
         const contract = await this.public.contract(contractAbi, contractAddress);
         const response = await contract[methodName](...methodArguments).call();
@@ -61,7 +61,7 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
         return Promise.all(contractsData.map((contractData) => {
             return Promise.all(contractData.methodsData.map(async (methodData) => {
                 try {
-                    const output = (await this.read(contractData.contractAddress, contractAbi, methodData.methodName, methodData.methodArguments));
+                    const output = (await this.callContractMethod(contractData.contractAddress, contractAbi, methodData.methodName, methodData.methodArguments));
                     return {
                         output,
                         success: true
@@ -161,11 +161,12 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
     async convertTronAddressToHex(address) {
         return this.public.address.toHex(address);
     }
-    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;
+    read() {
+        throw new Error('Method is not implemented');
+    }
+    ;
+    write() {
+        throw new Error('Method is not implemented');
     }
     ;
     static encodeMethodCall(contractAddress, contractAbi, methodName, methodArguments, callValue, feeLimit) {
@@ -200,25 +201,22 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
     }
     encodeApprove(tokenAddress, spenderAddress, amount) {
         const amountWei = amount ?? new bignumber_js_1.default(2).pow(256).minus(1).toFixed();
-        return tron_web3_pure_1.TronWeb3Pure.encodeMethodCall(tokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'approve', [
-            { type: 'address', value: spenderAddress },
-            { type: 'uint256', value: amountWei }
-        ]);
+        const callData = tron_web3_pure_1.TronWeb3Pure.encodeFunctionCall(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'approve', [spenderAddress, amountWei]);
+        return {
+            data: callData,
+            to: tokenAddress,
+            value: '0'
+        };
     }
     async getAllowance(fromTokenAddress, walletAddress, spender) {
-        const [contract, decimals, allowance] = await Promise.all([
+        const [contract, decimals] = await Promise.all([
             this.public.contract(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, fromTokenAddress),
-            this.read(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'decimals'),
-            this.read(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'allowance', [spender])
+            this.callContractMethod(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'decimals')
         ]);
-        const allowanceWeiBN = new bignumber_js_1.default(allowance);
+        const allowance = await this.getAllowance(fromTokenAddress, walletAddress, spender);
+        const allowanceWeiBN = new bignumber_js_1.default(allowance?.toString());
         const allowanceNonWei = core_1.Token.fromWei(allowanceWeiBN, Number(decimals));
         return { allowanceNonWei, allowanceWei: allowanceWeiBN };
     }
-    async approve(fromAddress, tokenAddress, spenderAddress, amount) {
-        const config = this.encodeApprove(tokenAddress, spenderAddress, amount);
-        return this.write(config.to, config.signature, config.arguments);
-    }
-    ;
 }
 exports.TronAdapter = TronAdapter;

package/src/lib/adapter/adapters/utils/ton-api.service.js

@@ -14,7 +14,7 @@ class TonApiService {
     async getAllFormatsOfAddress(walletAddress) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/address/${walletAddress}/parse`, {
             headers: {
-                Authorization: this.apiKey
+                apiKey: this.apiKey
             }
         });
         if ('error' in res) {
@@ -28,7 +28,7 @@ class TonApiService {
      */
     async fetchWalletSeqno(walletAddress) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/wallet/${walletAddress}/seqno`, {
-            headers: { Authorization: this.apiKey }
+            headers: { apiKey: this.apiKey }
         });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchWalletSeqno - ${res.error}`);
@@ -37,7 +37,7 @@ class TonApiService {
     }
     async fetchTxInfo(txHash) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/blockchain/transactions/${txHash}`, {
-            headers: { Authorization: this.apiKey }
+            headers: { apiKey: this.apiKey }
         });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchTxInfo - ${res.error}`);
@@ -45,7 +45,7 @@ class TonApiService {
         return res;
     }
     async fetchTxInfoByMessageHash(txHash) {
-        const res = await this.httpClient.get(`${this.tonApiUrl}/v2/blockchain/messages/${txHash}/transaction`, { headers: { Authorization: this.apiKey } });
+        const res = await this.httpClient.get(`${this.tonApiUrl}/v2/blockchain/messages/${txHash}/transaction`, { headers: { apiKey: this.apiKey } });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchTxInfoByMessageHash - ${res.error}`);
         }
@@ -54,7 +54,7 @@ class TonApiService {
     async checkIsTxCompleted(txHash) {
         try {
             const res = await this.httpClient.get(`${this.tonApiUrl}/v2/events/${txHash}`, {
-                headers: { Authorization: this.apiKey }
+                headers: { apiKey: this.apiKey }
             });
             if ('error' in res) {
                 throw new Error(`[TonApiService] Error in checkIsTxCompleted - ${res.error}`);
@@ -67,7 +67,7 @@ class TonApiService {
     }
     async healthcheck() {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/status`, {
-            headers: { Authorization: this.apiKey }
+            headers: { apiKey: this.apiKey }
         });
         if ('error' in res || !res.rest_online) {
             return false;
@@ -96,7 +96,7 @@ class TonApiService {
         if (methodArgs.length) {
             argsParam += '?' + methodArgs.map((param) => `args=${param}`).join('&');
         }
-        const res = await this.httpClient.get(`${this.tonApiUrl}/v2/blockchain/accounts/${address}/methods/${methodName}${argsParam}`, { headers: { Authorization: this.apiKey } });
+        const res = await this.httpClient.get(`${this.tonApiUrl}/v2/blockchain/accounts/${address}/methods/${methodName}${argsParam}`, { headers: { apiKey: this.apiKey } });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in callContractMethod - ${res.error}`);
         }
@@ -104,7 +104,7 @@ class TonApiService {
     }
     async fetchTokenInfo(tokenAddress) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/jettons/${tokenAddress}`, {
-            headers: { Authorization: this.apiKey }
+            headers: { apiKey: this.apiKey }
         });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchTokenInfo - ${res.error}`);
@@ -117,7 +117,7 @@ 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: { Authorization: this.apiKey } });
+        const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}/jettons/${tokenAddress}`, { headers: { apiKey: this.apiKey } });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchTokenInfoForWallet - ${res.error}`);
         }
@@ -125,7 +125,7 @@ class TonApiService {
     }
     async fetchAllNonNullableTokensInfoForWallet(walletAddress) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}/jettons`, {
-            headers: { Authorization: this.apiKey }
+            headers: { apiKey: this.apiKey }
         });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchAllNonNullableTokensInfoForWallet - ${res.error}`);
@@ -137,7 +137,7 @@ class TonApiService {
      */
     async fetchAccountInfo(walletAddress) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}`, {
-            headers: { Authorization: this.apiKey }
+            headers: { apiKey: this.apiKey }
         });
         if ('error' in res) {
             throw new Error(`[TonApiService] Error in fetchAccountInfo - ${res.error}`);

package/src/lib/adapter/blockchain-adapter-factory.service.d.ts

@@ -2,8 +2,7 @@ import { SolanaAdapter } from './adapters/solana-adapter';
 import { TronAdapter } from './adapters/tron-adapter';
 import { AbstractAdapter } from './adapters/abstract-adapter';
 import { WalletProvider } from "./constants/models/wallet-provider";
-import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, HttpClient, TonBlockchainName } from "@cryptorubic/core";
-import { TonAdapter } from "./adapters/ton-adapter";
+import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, HttpClient } from "@cryptorubic/core";
 import { TonAdapterConfig } from "./adapters/models/ton-adapter-config";
 import { EvmAdapter } from "./adapters/evm-adapter";
 export declare class BlockchainAdapterFactoryService {
@@ -18,7 +17,6 @@ export declare class BlockchainAdapterFactoryService {
     getAdapter(blockchain: SolanaBlockchainName): SolanaAdapter;
     getAdapter(blockchain: EvmBlockchainName): EvmAdapter;
     getAdapter(blockchain: TronBlockchainName): TronAdapter;
-    getAdapter(blockchain: TonBlockchainName): TonAdapter;
     private createStorage;
     private createAdapter;
     connectWallet(walletProvider: WalletProvider): void;

package/src/lib/adapter/blockchain-adapter-factory.service.js

@@ -92,23 +92,19 @@ class BlockchainAdapterFactoryService {
                     chain: chain,
                     transport: (0, viem_1.custom)(provider)
                 });
-                adapter.walletAddress = walletProvider[core_1.CHAIN_TYPE.EVM].address;
             });
         }
         if (walletProvider?.[core_1.CHAIN_TYPE.SOLANA]?.core && this.adapterStore?.[core_1.BLOCKCHAIN_NAME.SOLANA]) {
             const store = this.adapterStore[core_1.BLOCKCHAIN_NAME.SOLANA];
             store.wallet = walletProvider[core_1.CHAIN_TYPE.SOLANA].core;
-            store.walletAddress = walletProvider[core_1.CHAIN_TYPE.SOLANA].address;
         }
         if (walletProvider?.[core_1.CHAIN_TYPE.TRON]?.core && this.adapterStore?.[core_1.BLOCKCHAIN_NAME.TRON]) {
             const store = this.adapterStore[core_1.BLOCKCHAIN_NAME.TRON];
             store.wallet = walletProvider[core_1.CHAIN_TYPE.TRON].core;
-            store.walletAddress = walletProvider[core_1.CHAIN_TYPE.TRON].address;
         }
         if (walletProvider?.[core_1.CHAIN_TYPE.TON]?.core && this.adapterStore?.[core_1.BLOCKCHAIN_NAME.TON]) {
             const store = this.adapterStore[core_1.BLOCKCHAIN_NAME.TON];
             store.wallet = walletProvider[core_1.CHAIN_TYPE.TON].core;
-            store.walletAddress = walletProvider[core_1.CHAIN_TYPE.TON].address;
         }
     }
 }

package/src/lib/utils/web3-types/tron-web3-pure.d.ts

@@ -1,9 +1,7 @@
 import { CommonWeb3Pure } from "./common-web3-pure";
-import { TronTransactionConfig } from "../models/tron-transaction-config";
 import { TronParameters } from "../models/tron-parameters";
 import { TronWeb3PrimitiveType, Web3PrimitiveType } from "../models/primitive-types";
 import { FunctionFragment } from "tronweb/src/types/ABI";
-import { AbiItem } from "../models/abi-types";
 export declare class TronWeb3Pure extends CommonWeb3Pure {
     constructor();
     isAddressCorrect(address: string): Promise<boolean>;
@@ -17,7 +15,6 @@ export declare class TronWeb3Pure extends CommonWeb3Pure {
      * @returns An ABI encoded function call. Means function signature + parameters.
      */
     static encodeFunctionCall(contractAbi: FunctionFragment[], methodName: string, methodArguments: unknown[]): string;
-    static encodeMethodCall(contractAddress: string, contractAbi: AbiItem[], methodName: string, methodArguments: TronParameters, callValue?: string, feeLimit?: number): TronTransactionConfig;
     static encodeMethodSignature(methodSignature: string, parameters: TronParameters): string;
     /**
      * Decodes method result using its JSON interface object and given parameters.

package/src/lib/utils/web3-types/tron-web3-pure.js

@@ -33,20 +33,6 @@ class TronWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
         const encodedParameters = tronweb_1.utils.abi.encodeParamsV2ByABI(methodSignature, methodArguments);
         return encodedMethodSignature + encodedParameters.slice(2);
     }
-    static encodeMethodCall(contractAddress, contractAbi, methodName, methodArguments, callValue, feeLimit) {
-        const methodAbi = contractAbi.find(abiItem => abiItem.name === methodName);
-        if (!methodAbi) {
-            throw new Error('Encode fail. No method in ABI');
-        }
-        const signature = `${methodAbi.name}(${this.flattenTypesToString(methodAbi.inputs).join(',')})`;
-        return {
-            to: contractAddress,
-            arguments: methodArguments,
-            signature,
-            ...(callValue && { callValue }),
-            ...(feeLimit && { feeLimit })
-        };
-    }
     static encodeMethodSignature(methodSignature, parameters) {
         const encodedMethodSignature = tronweb_1.TronWeb.sha3(methodSignature).slice(0, 10);
         const flattenedParameters = this.flattenParameters(parameters);

package/src/lib/adapter/adapters/models/basic-transaction-options.d.ts

@@ -1,7 +0,0 @@
-export interface BasicTransactionOptions {
-    /**
-     * Callback to be called, when user confirm swap transaction.
-     * @param hash Transaction hash.
-     */
-    onTransactionHash?: (hash: string) => void;
-}

package/src/lib/adapter/adapters/models/basic-transaction-options.js

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