@cryptorubic/web3 1.5.1-alpha.tron.7 → 1.5.1-alpha.tron.9

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "1.5.1-alpha.tron.7",
+    "version": "1.5.1-alpha.tron.9",
     "dependencies": {
         "@ethersproject/bignumber": "^5.8.0",
         "@mysten/sui": "^1.24.0",

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

@@ -43,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

@@ -21,16 +21,16 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
         super(core_1.BLOCKCHAIN_NAME.TRON, logger);
         this.rpcList = rpcList;
         this.clientParams = clientParams;
-        // private readonly multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
         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;
-        const tronApiKey = this.clientParams?.tronApiKey;
+        const headers = this.clientParams?.tronwebHeaders;
         this.public = new tronweb_1.TronWeb({
             fullHost: rpc,
-            headers: { ...(tronApiKey && { 'TRON-PRO-API-KEY': tronApiKey }) }
+            ...(headers && { headers })
+            // headers: { ...(tronApiKey && { 'TRON-PRO-API-KEY': tronApiKey }) }
         });
     }
     async callContractMethod(contractAddress, contractAbi, methodName, methodArguments = []) {
@@ -63,7 +63,7 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
             tokensAddresses.splice(indexOfNativeCoin, 1);
             promises[1] = this.getBalance(userAddress);
         }
-        promises[0] = this.batchMulticallTokenBalance(userAddress, tokensAddresses, 10);
+        promises[0] = this.batchMulticallTokenBalance(userAddress, tokensAddresses, 20);
         const results = await Promise.all(promises);
         const tokensBalances = results[0].map((tokenResults) => {
             const { success, output } = tokenResults[0];
@@ -91,45 +91,6 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
         }
         return balances;
     }
-    // public async multicallContractsMethods<Output extends TronWeb3PrimitiveType>(
-    //     contractAbi: any,
-    //     contractsData: {
-    //         contractAddress: string;
-    //         methodsData: MethodData[];
-    //     }[]
-    // ): Promise<ContractMulticallResponse<any>[][]> {
-    //     const calls: TronCall[][] = contractsData.map(({ contractAddress, methodsData }) => {
-    //         return methodsData.map(({ methodName, methodArguments }) => [
-    //             contractAddress,
-    //             TronWeb3Pure.encodeFunctionCall(contractAbi as any, methodName, methodArguments)
-    //         ]);
-    //     });
-    //     try {
-    //         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]!;
-    //                 outputIndex++;
-    //                 const methodOutputAbi = contractAbi.find(
-    //                     // @ts-ignore
-    //                     (funcSignature) => funcSignature.name === methodData.methodName
-    //                     // @ts-ignore
-    //                 )!.outputs!;
-    //                 return {
-    //                     output: success ? (TronWeb3Pure.decodeMethodOutput(methodOutputAbi, returnData) as Output) : null,
-    //                     success
-    //                 };
-    //             })
-    //         );
-    //     } catch (err) {
-    //         this.logger
-    //             ? this.logger.customError('[TronAdapter_multicallContractsMethods] Error: ', err)
-    //             : console.debug('[TronAdapter_multicallContractsMethods] Error:', err);
-    //         return this.multicallContractsMethodsByOne(contractAbi, contractsData);
-    //     }
-    // }
     async multicallContractsMethods(contractAbi, contractsData) {
         const calls = contractsData.map(({ contractAddress, methodsData }) => {
             return methodsData.map(({ methodName, methodArguments }) => [
@@ -138,17 +99,13 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
                 tron_web3_pure_1.TronWeb3Pure.encodeFunctionCall(contractAbi, methodName, methodArguments)
             ]);
         });
-        console.log('[multicallContractsMethods] calls ==>', calls);
         try {
             const outputs = await this.multicall(calls.flat());
-            console.log('[multicallContractsMethods] outputs ==>', outputs);
             let outputIndex = 0;
             return contractsData.map((contractData) => contractData.methodsData.map((methodData) => {
                 const output = outputs.returnData[outputIndex];
-                if (!output) {
-                    console.log('[multicallContractsMethods] Error index:', { outputIndex, outputs });
+                if (!output)
                     return { output: null, success: false };
-                }
                 const methodOutputAbi = contractAbi.find((funcSignature) => funcSignature.name === methodData.methodName).outputs;
                 outputIndex++;
                 return {
@@ -171,37 +128,12 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
         const balance = await this.getBalance(walletAddress, token.address);
         return balance.gte(token.weiAmount);
     }
-    // private async multicall(calls: TronCall[]): Promise<TronMulticallResponse> {
-    //     this.public.setAddress(this.multicallAddress);
-    //     const contract = await this.public.contract(TRON_MULTICALL_ABI as any, this.multicallAddress);
-    //     // @ts-ignore
-    //     return contract.aggregateViewCalls(calls).call();
-    // }
     async multicall(calls) {
         this.public.setAddress(this.multicallAddress);
         const contract = await this.public.contract(tron_multicall_abi_1.TRON_MULTICALL_ABI, this.multicallAddress);
         // @ts-ignore
         return contract['aggregate3'](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
-                    };
-                }
-            }));
-        }));
-    }
     async callForTokensInfo(tokenAddresses) {
         const tokenFields = ['decimals', 'symbol', 'name'];
         const nativeTokenIndex = tokenAddresses.findIndex((address) => web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.TRON, address));

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

@@ -1,29 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TRON_MULTICALL_ABI = void 0;
-// export const TRON_MULTICALL_ABI = [
-//     {
-//         inputs: [
-//             {
-//                 components: [
-//                     { internalType: 'address', name: 'target', type: 'address' },
-//                     { internalType: 'bytes', name: 'callData', type: 'bytes' }
-//                 ],
-//                 internalType: 'struct Multicall.Call[]',
-//                 name: 'calls',
-//                 type: 'tuple[]'
-//             }
-//         ],
-//         name: 'aggregateViewCalls',
-//         outputs: [
-//             { internalType: 'uint256', name: 'blockNumber', type: 'uint256' },
-//             { internalType: 'bytes[]', name: 'returnData', type: 'bytes[]' },
-//             { internalType: 'bool[]', name: 'results', type: 'bool[]' }
-//         ],
-//         stateMutability: 'view',
-//         type: 'function'
-//     }
-// ] as AbiItem[];
 exports.TRON_MULTICALL_ABI = [
     {
         inputs: [

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

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

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

@@ -1,8 +1,3 @@
-/**
- * First argument is `target`, that is contract address to execute on.
- * Second argument is `data`, that is encoded contract method.
- */
-export type TronCall = [string, string];
 /**
  * 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.