@cryptorubic/web3 1.5.0 → 1.5.1-alpha.tron.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "1.5.0",
+    "version": "1.5.1-alpha.tron.2",
     "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>;

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

@@ -20,12 +20,18 @@ 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;
+        // 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;
-        this.public = new tronweb_1.TronWeb({ fullHost: rpc });
+        const tronApiKey = this.clientParams?.tronApiKey;
+        this.public = new tronweb_1.TronWeb({
+            fullHost: rpc,
+            headers: { ...(tronApiKey && { 'TRON-PRO-API-KEY': tronApiKey }) }
+        });
     }
     async callContractMethod(contractAddress, contractAbi, methodName, methodArguments = []) {
         this.public.setAddress(contractAddress);
@@ -96,32 +102,70 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
             ]
         })));
     }
+    // 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 }) => [
-                contractAddress,
-                tron_web3_pure_1.TronWeb3Pure.encodeFunctionCall(contractAbi, methodName, methodArguments)
-            ]);
+            return methodsData.map(({ methodName, methodArguments }) => ({
+                target: contractAddress,
+                allowFailure: true,
+                callData: 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 success = outputs.results[outputIndex];
-                const returnData = outputs.returnData[outputIndex];
+                const output = outputs[outputIndex];
+                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
                 };
             }));
         }
         catch (err) {
+            console.log('[multicallContractsMethods] err ==>', err);
             this.logger
                 ? this.logger.customError('[TronAdapter_multicallContractsMethods] Error: ', err)
                 : console.debug('[TronAdapter_multicallContractsMethods] Error:', err);
@@ -135,11 +179,17 @@ 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.aggregateViewCalls(calls).call();
+        return contract['aggregate3'](calls).call();
     }
     multicallContractsMethodsByOne(contractAbi, contractsData) {
         return Promise.all(contractsData.map((contractData) => {

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

@@ -1,26 +1,56 @@
 "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: [
             {
                 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',
+        stateMutability: 'payable',
         type: 'function'
     }
 ];

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

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

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

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