@cryptorubic/web3 1.6.0-alpha-rub-2366.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "1.6.0-alpha-rub-2366.0",
+    "version": "1.6.0",
     "dependencies": {
         "@ethersproject/bignumber": "^5.8.0",
         "@mysten/sui": "^1.24.0",

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

@@ -16,12 +16,13 @@ import { ApprovableAdapter } from '../models/approve-adapter';
 import { TxStatus } from '../models/web3-public-models/tx-status';
 export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> implements ApprovableAdapter<TronTransactionConfig> {
     private readonly rpcList;
+    private readonly clientParams?;
     readonly signer: TronAdapterSigner;
     private readonly multicallAddress;
     needPreswapAction(): Promise<boolean>;
     constructor(rpcList: (string | {
         fullHost: string;
-    })[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    })[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams | undefined);
     initWeb3Client(): void;
     callContractMethod<T extends Web3PrimitiveType = string>(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments?: unknown[]): Promise<T>;
     getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
@@ -42,7 +43,6 @@ export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronB
     }>;
     checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
     private multicall;
-    private multicallContractsMethodsByOne;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token[]>;
     getBalance(userAddress: string, tokenAddress?: string): Promise<BigNumber>;
     getTokenBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;

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

@@ -20,12 +20,17 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
     constructor(rpcList, httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.TRON, logger);
         this.rpcList = rpcList;
-        this.multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
+        this.clientParams = clientParams;
+        this.multicallAddress = 'TEazPvZwDjDtFeJupyo7QunvnrnUjPH8ED';
         this.signer = new tron_adapter_signer_1.TronAdapterSigner(this.publicRef, httpClient, logger, clientParams);
     }
     initWeb3Client() {
         const rpc = typeof this.rpcList[0] === 'string' ? this.rpcList[0] : this.rpcList[0].fullHost;
-        this.public = new tronweb_1.TronWeb({ fullHost: rpc });
+        const headers = this.clientParams?.tronwebHeaders;
+        this.public = new tronweb_1.TronWeb({
+            fullHost: rpc,
+            ...(headers && { headers })
+        });
     }
     async callContractMethod(contractAddress, contractAbi, methodName, methodArguments = []) {
         this.public.setAddress(contractAddress);
@@ -57,7 +62,7 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
             tokensAddresses.splice(indexOfNativeCoin, 1);
             promises[1] = this.getBalance(userAddress);
         }
-        promises[0] = this.batchMulticallTokenBalance(userAddress, tokensAddresses, 50);
+        promises[0] = this.batchMulticallTokenBalance(userAddress, tokensAddresses, 20);
         const results = await Promise.all(promises);
         const tokensBalances = results[0].map((tokenResults) => {
             const { success, output } = tokenResults[0];
@@ -69,37 +74,27 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
         return tokensBalances;
     }
     async batchMulticallTokenBalance(userAddress, tokensAddresses, batchSize) {
-        if (tokensAddresses.length > 100) {
-            const balances = [];
-            for (let i = 0; i < tokensAddresses.length; i += batchSize) {
-                const batchRequest = tokensAddresses.slice(i, i + batchSize);
-                const batchResult = await this.multicallContractsMethods(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, batchRequest.map((tokenAddress) => ({
-                    contractAddress: tokenAddress,
-                    methodsData: [
-                        {
-                            methodName: 'balanceOf',
-                            methodArguments: [userAddress]
-                        }
-                    ]
-                })));
-                balances.push(...batchResult);
-            }
-            return balances;
+        const balances = [];
+        for (let i = 0; i < tokensAddresses.length; i += batchSize) {
+            const batchRequest = tokensAddresses.slice(i, i + batchSize);
+            const batchResult = await this.multicallContractsMethods(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, batchRequest.map((tokenAddress) => ({
+                contractAddress: tokenAddress,
+                methodsData: [
+                    {
+                        methodName: 'balanceOf',
+                        methodArguments: [userAddress]
+                    }
+                ]
+            })));
+            balances.push(...batchResult);
         }
-        return this.multicallContractsMethods(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, tokensAddresses.map((tokenAddress) => ({
-            contractAddress: tokenAddress,
-            methodsData: [
-                {
-                    methodName: 'balanceOf',
-                    methodArguments: [userAddress]
-                }
-            ]
-        })));
+        return balances;
     }
     async multicallContractsMethods(contractAbi, contractsData) {
         const calls = contractsData.map(({ contractAddress, methodsData }) => {
             return methodsData.map(({ methodName, methodArguments }) => [
                 contractAddress,
+                true,
                 tron_web3_pure_1.TronWeb3Pure.encodeFunctionCall(contractAbi, methodName, methodArguments)
             ]);
         });
@@ -107,17 +102,14 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
             const outputs = await this.multicall(calls.flat());
             let outputIndex = 0;
             return contractsData.map((contractData) => contractData.methodsData.map((methodData) => {
-                const success = outputs.results[outputIndex];
-                const returnData = outputs.returnData[outputIndex];
+                const output = outputs.returnData[outputIndex];
+                if (!output)
+                    return { output: null, success: false };
+                const methodOutputAbi = contractAbi.find((funcSignature) => funcSignature.name === methodData.methodName).outputs;
                 outputIndex++;
-                const methodOutputAbi = contractAbi.find(
-                // @ts-ignore
-                (funcSignature) => funcSignature.name === methodData.methodName
-                // @ts-ignore
-                ).outputs;
                 return {
-                    output: success ? tron_web3_pure_1.TronWeb3Pure.decodeMethodOutput(methodOutputAbi, returnData) : null,
-                    success
+                    output: output.success ? tron_web3_pure_1.TronWeb3Pure.decodeMethodOutput(methodOutputAbi, output.returnData) : null,
+                    success: output.success
                 };
             }));
         }
@@ -125,7 +117,7 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
             this.logger
                 ? this.logger.customError('[TronAdapter_multicallContractsMethods] Error: ', err)
                 : console.debug('[TronAdapter_multicallContractsMethods] Error:', err);
-            return this.multicallContractsMethodsByOne(contractAbi, contractsData);
+            return contractsData.map((contractData) => contractData.methodsData.map(() => ({ output: null, success: false })));
         }
     }
     async getBlockNumber() {
@@ -139,26 +131,7 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
         this.public.setAddress(this.multicallAddress);
         const contract = await this.public.contract(tron_multicall_abi_1.TRON_MULTICALL_ABI, this.multicallAddress);
         // @ts-ignore
-        return contract.aggregateViewCalls(calls).call();
-    }
-    multicallContractsMethodsByOne(contractAbi, contractsData) {
-        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));
-                    return {
-                        output,
-                        success: true
-                    };
-                }
-                catch {
-                    return {
-                        output: null,
-                        success: false
-                    };
-                }
-            }));
-        }));
+        return contract['aggregate3'](calls).call();
     }
     async callForTokensInfo(tokenAddresses) {
         const tokenFields = ['decimals', 'symbol', 'name'];

package/src/lib/adapter/adapters/constants/trc-20-contract-abi.d.ts

@@ -10,3 +10,4 @@ export declare const TRC20_CONTRACT_ABI: {
     stateMutability: string;
     type: string;
 }[];
+export type TronAbiItem = (typeof TRC20_CONTRACT_ABI)[number];

package/src/lib/adapter/adapters/constants/tron-multicall-abi.js

@@ -7,18 +7,25 @@ exports.TRON_MULTICALL_ABI = [
             {
                 components: [
                     { internalType: 'address', name: 'target', type: 'address' },
+                    { internalType: 'bool', name: 'allowFailure', type: 'bool' },
                     { internalType: 'bytes', name: 'callData', type: 'bytes' }
                 ],
-                internalType: 'struct Multicall.Call[]',
+                internalType: 'struct Multicall3.Call3[]',
                 name: 'calls',
                 type: 'tuple[]'
             }
         ],
-        name: 'aggregateViewCalls',
+        name: 'aggregate3',
         outputs: [
-            { internalType: 'uint256', name: 'blockNumber', type: 'uint256' },
-            { internalType: 'bytes[]', name: 'returnData', type: 'bytes[]' },
-            { internalType: 'bool[]', name: 'results', type: 'bool[]' }
+            {
+                components: [
+                    { internalType: 'bool', name: 'success', type: 'bool' },
+                    { internalType: 'bytes', name: 'returnData', type: 'bytes' }
+                ],
+                internalType: 'struct Multicall3.Result[]',
+                name: 'returnData',
+                type: 'tuple[]'
+            }
         ],
         stateMutability: 'view',
         type: 'function'

package/src/lib/adapter/models/create-factory-params.d.ts

@@ -16,6 +16,9 @@ export interface ClientAdaptersFactoryParams {
     envType: EnvType;
     viemConfig?: ViemChainConfig;
     lazyLoadWeb3?: boolean;
+    tronwebHeaders?: {
+        [key: string]: string;
+    };
 }
 export type ViemChainConfig = Partial<Record<EvmBlockchainName, ViemConfig>>;
 export interface ViemConfig {

package/src/lib/utils/models/tron-call.d.ts

@@ -1,5 +1,10 @@
 /**
- * First argument is `target`, that is contract address to execute on.
- * Second argument is `data`, that is encoded contract method.
+ * First argument is `target`, that is contract address to execute on
+ * Second argument is `allowFailure`. If false, the entire call will revert if the call fails.
+ * 3th argument is `callData`. Data to call on the target contract
  */
-export type TronCall = [string, string];
+export type TronCall3Request = [string, boolean, string];
+export type TronCall3Result = {
+    success: boolean;
+    returnData: string;
+};