@instadapp/interop-x 0.0.0-dev.7738003 → 0.0.0-dev.7913ed9

package/src/utils/index.ts

@@ -1,19 +1,20 @@
 /**
  * @module util
  */
-import axios from 'axios'
+import axios from "axios";
 import axiosRetry from "axios-retry";
-import { addresses } from '@/constants';
-import { ChainId } from '@/types'
-import { ethers } from 'ethers';
-import { GnosisSafe } from '@/typechain';
-import retry from 'async-retry'
+import { addresses } from "@/constants";
+import { ChainId } from "@/types";
+import { ethers } from "ethers";
+import { GnosisSafe } from "@/typechain";
+import retry from "async-retry";
+import { connectors } from "@/abi/connectors";
+import Web3EthAbi from "web3-eth-abi";
 
 export const http = axios.create();
 
 axiosRetry(http, { retries: 3, retryDelay: axiosRetry.exponentialDelay });
 
-
 export function shortenHash(hash: string, length: number = 4) {
   if (!hash) return;
 
@@ -27,22 +28,25 @@ export function shortenHash(hash: string, length: number = 4) {
 }
 
 export function short(buffer: Buffer): string {
-  return buffer.toString('hex').slice(0, 8) + '...'
+  return buffer.toString("hex").slice(0, 8) + "...";
 }
 
-export const signGnosisSafeTx = async ({
-  to,
-  data = null as any,
-  value = '0',
-  operation = '1',
-  baseGas = '0',
-  gasPrice = "0",
-  gasToken = "0x0000000000000000000000000000000000000000",
-  refundReceiver = "0x0000000000000000000000000000000000000000",
-  safeTxGas = "79668" as string | number,
-  nonce = "0",
-  chainId = 137 as ChainId,
-}, { signer }) => {
+export const signGnosisSafeTx = async (
+  {
+    to,
+    data = null as any,
+    value = "0",
+    operation = "1",
+    baseGas = "0",
+    gasPrice = "0",
+    gasToken = "0x0000000000000000000000000000000000000000",
+    refundReceiver = "0x0000000000000000000000000000000000000000",
+    safeTxGas = "79668" as string | number,
+    nonce = "0",
+    chainId = 137 as ChainId,
+  },
+  { signer }
+) => {
   const gnosisSafe = addresses[chainId].gnosisSafe;
 
   const domain = {
@@ -52,16 +56,16 @@ export const signGnosisSafeTx = async ({
 
   const types = {
     SafeTx: [
-      { type: 'address', name: 'to' },
-      { type: 'uint256', name: 'value' },
-      { type: 'bytes', name: 'data' },
-      { type: 'uint8', name: 'operation' },
-      { type: 'uint256', name: 'safeTxGas' },
-      { type: 'uint256', name: 'baseGas' },
-      { type: 'uint256', name: 'gasPrice' },
-      { type: 'address', name: 'gasToken' },
-      { type: 'address', name: 'refundReceiver' },
-      { type: 'uint256', name: 'nonce' },
+      { type: "address", name: "to" },
+      { type: "uint256", name: "value" },
+      { type: "bytes", name: "data" },
+      { type: "uint8", name: "operation" },
+      { type: "uint256", name: "safeTxGas" },
+      { type: "uint256", name: "baseGas" },
+      { type: "uint256", name: "gasPrice" },
+      { type: "address", name: "gasToken" },
+      { type: "address", name: "refundReceiver" },
+      { type: "uint256", name: "nonce" },
     ],
   };
 
@@ -79,21 +83,21 @@ export const signGnosisSafeTx = async ({
     value,
   };
 
-  return await signer._signTypedData(domain, types, message)
+  return await signer._signTypedData(domain, types, message);
 };
 
 export const getRpcProviderUrl = (chainId: ChainId) => {
   switch (chainId) {
     case 1:
-      return 'https://rpc.ankr.com/eth';
+      return "https://rpc.ankr.com/eth";
     case 137:
-      return 'https://rpc.ankr.com/polygon';
+      return "https://rpc.ankr.com/polygon";
     case 43114:
-      return 'https://rpc.ankr.com/avalanche';
+      return "https://rpc.ankr.com/avalanche";
     default:
       throw new Error(`Unknown chainId: ${chainId}`);
   }
-}
+};
 
 export interface Signature {
   signer: string;
@@ -116,36 +120,40 @@ export const buildSignatureBytes = (signatures: Signature[]): string => {
  * Call an async function with a maximum time limit (in milliseconds) for the timeout
  *  Resolved promise for async function call, or an error if time limit reached
  */
-export const asyncCallWithTimeout = async <T>(asyncPromise: Promise<T>, timeout: number) => {
+export const asyncCallWithTimeout = async <T>(
+  asyncPromise: Promise<T>,
+  timeout: number
+) => {
   let timeoutHandle;
 
   const timeoutPromise = new Promise((_resolve, reject) => {
     timeoutHandle = setTimeout(
-      () => reject(new Error('Async call timeout limit reached')),
+      () => reject(new Error("Async call timeout limit reached")),
       timeout
     );
   });
 
-  return Promise.race([asyncPromise, timeoutPromise]).then(result => {
+  return Promise.race([asyncPromise, timeoutPromise]).then((result) => {
     clearTimeout(timeoutHandle);
     return result;
-  }) as Promise<T>
-}
-
+  }) as Promise<T>;
+};
 
 type GenerateInteropTransactionHashParam = {
-  actionId: string,
-  vnonce: string,
-  sourceSender: string,
-  sourceChainId: string | number,
-  sourceDsaId: string,
-  targetChainId: string | number,
-  targetDsaId: string,
+  actionId: string;
+  vnonce: string;
+  sourceSender: string;
+  sourceChainId: string | number;
+  sourceDsaId: string;
+  targetChainId: string | number;
+  targetDsaId: string;
 };
 
-export const generateInteropTransactionHash = (data: GenerateInteropTransactionHashParam) => {
+export const generateInteropTransactionHash = (
+  data: GenerateInteropTransactionHashParam
+) => {
   return ethers.utils.solidityKeccak256(
-    Array.from({ length : 7 }, () => 'string'),
+    Array.from({ length: 7 }, () => "string"),
     [
       String(data.actionId),
       String(data.vnonce),
@@ -154,9 +162,9 @@ export const generateInteropTransactionHash = (data: GenerateInteropTransactionH
       String(data.sourceDsaId),
       String(data.targetChainId),
       String(data.targetDsaId),
-    ]);
-}
-
+    ]
+  );
+};
 
 export class ContractError extends Error {
   method: string;
@@ -164,76 +172,109 @@ export class ContractError extends Error {
   args: any[];
 }
 
-export function getContract<TContract extends ethers.Contract>(address: string, contractInterface: ethers.ContractInterface | any, signerOrProvider?: ethers.Signer | ethers.providers.Provider) {
-  if (!ethers.utils.getAddress(address) || address === ethers.constants.AddressZero) {
-    throw Error(`Invalid 'address' parameter '${address}'.`)
+export function getContract<TContract extends ethers.Contract>(
+  address: string,
+  contractInterface: ethers.ContractInterface | any,
+  signerOrProvider?: ethers.Signer | ethers.providers.Provider
+) {
+  if (
+    !ethers.utils.getAddress(address) ||
+    address === ethers.constants.AddressZero
+  ) {
+    throw Error(`Invalid 'address' parameter '${address}'.`);
   }
 
   const contract = new ethers.Contract(
     address,
     contractInterface,
     signerOrProvider
-  ) as TContract
+  ) as TContract;
 
   // Make sure the contract properties is writable
-  const desc = Object.getOwnPropertyDescriptor(contract, 'functions');
+  const desc = Object.getOwnPropertyDescriptor(contract, "functions");
 
   if (!desc || desc.writable !== true) {
-    return contract
+    return contract;
   }
 
   return new Proxy(contract, {
     get(target, prop, receiver) {
       const value = Reflect.get(target, prop, receiver);
 
-      if (typeof value === 'function' && (contract.functions.hasOwnProperty(prop) || ['queryFilter'].includes(String(prop)))) {
+      if (
+        typeof value === "function" &&
+        (contract.functions.hasOwnProperty(prop) ||
+          ["queryFilter"].includes(String(prop)))
+      ) {
         let isConstant = false;
 
         try {
-          isConstant = contract.interface.getFunction(String(prop)).constant
-        } catch (error) {
-        }
+          isConstant = contract.interface.getFunction(String(prop)).constant;
+        } catch (error) {}
 
         return async (...args: any[]) => {
           try {
-            return await retry(async () => await value.bind(contract)(...args), { retries: isConstant ? 1 : 3 });
+            return await retry(
+              async () => await value.bind(contract)(...args),
+              { retries: isConstant ? 1 : 3 }
+            );
           } catch (error) {
-            const err = new ContractError(`Error calling "${String(prop)}" on "${address}": ${error.reason || error.message}`)
+            const err = new ContractError(
+              `Error calling "${String(prop)}" on "${address}": ${
+                error.reason || error.message
+              }`
+            );
 
-            err.method = String(prop)
-            err.address = address
-            err.args = [...args]
+            err.method = String(prop);
+            err.address = address;
+            err.args = [...args];
 
-            throw err
+            throw err;
           }
-        }
+        };
       }
 
-
-      if (typeof value === 'object' && ['populateTransaction', 'estimateGas', 'functions', 'callStatic'].includes(String(prop))) {
+      if (
+        typeof value === "object" &&
+        [
+          "populateTransaction",
+          "estimateGas",
+          "functions",
+          "callStatic",
+        ].includes(String(prop))
+      ) {
         const parentProp = String(prop);
 
         return new Proxy(value, {
           get(target, prop, receiver) {
             const value = Reflect.get(target, prop, receiver);
 
-            if (typeof value === 'function') {
+            if (typeof value === "function") {
               return async (...args: any[]) => {
                 try {
-                  return await retry(async () => await value.bind(contract)(...args), { retries: parentProp === 'callStatic' ? 3 : 1 });
+                  return await retry(
+                    async () => await value.bind(contract)(...args),
+                    { retries: parentProp === "callStatic" ? 3 : 1 }
+                  );
                 } catch (error) {
-                  const err = new ContractError(`Error calling "${String(prop)}" using "${parentProp}" on "${address}": ${error.reason || error.message}`)
-
-                  err.method = String(prop)
-                  err.address = address
-                  err.args = [...args]
-
-                  throw err
+                  const err = new ContractError(
+                    `Error calling "${String(
+                      prop
+                    )}" using "${parentProp}" on "${address}": ${
+                      error.reason || error.message
+                    }`
+                  );
+
+                  err.method = String(prop);
+                  err.address = address;
+                  err.args = [...args];
+
+                  throw err;
                 }
-              }
+              };
             }
-          }
-        })
+          },
+        });
       }
 
       return value;
@@ -241,7 +282,10 @@ export function getContract<TContract extends ethers.Contract>(address: string,
   });
 }
 
-export const generateGnosisTransaction = async (transactionData: any, safeContract: GnosisSafe) => {
+export const generateGnosisTransaction = async (
+  transactionData: any,
+  safeContract: GnosisSafe
+) => {
   console.log(transactionData);
 
   let isExecuted = await safeContract.dataHashes(
@@ -257,10 +301,14 @@ export const generateGnosisTransaction = async (transactionData: any, safeContra
       transactionData.refundReceiver,
       transactionData.nonce
     )
-  )
+  );
 
   while (isExecuted == 1) {
-    transactionData.safeTxGas = ethers.BigNumber.from(String(transactionData.safeTxGas)).add(1).toString()
+    transactionData.safeTxGas = ethers.BigNumber.from(
+      String(transactionData.safeTxGas)
+    )
+      .add(1)
+      .toString();
 
     isExecuted = await safeContract.dataHashes(
       await safeContract.getTransactionHash(
@@ -275,15 +323,43 @@ export const generateGnosisTransaction = async (transactionData: any, safeContra
         transactionData.refundReceiver,
         transactionData.nonce
       )
-    )
+    );
   }
 
-  return transactionData
-}
+  return transactionData;
+};
 
 export class LiquidityError extends Error {
   constructor(message?: string) {
-    super(message || 'Not enough liquidity');
+    super(message || "Not enough liquidity");
     Object.setPrototypeOf(this, new.target.prototype);
   }
-}
+}
+
+export const encodeConnectorMethod = (params: {
+  connector: string;
+  method: string;
+  args: string[];
+}) => {
+  const connectorInterface = getInterface(
+    connectors.versions[2][params.connector],
+    params.method
+  );
+
+  if (!connectorInterface)
+    throw new Error(`ConnectorInterface '${params.method}' not found`);
+
+  //@ts-ignore
+  return Web3EthAbi.encodeFunctionCall(connectorInterface, params.args);
+};
+
+const getInterface = (abiItems: any[], method: string) => {
+  const abiItem = abiItems.find((abiItem) => abiItem.name === method);
+
+  if (!abiItem) {
+    console.error(`${method} is an invalid method.`);
+    return;
+  }
+
+  return abiItem;
+};

package/dist/src/gnosis/actions/withdraw/index.js

@@ -1,114 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// const getBridgeAmounts = async (user: string, tokens: string[], chainId: ChainId) => {
-//     const sourceChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(chainId));
-//     const sourceWallet = new ethers.Wallet(config.privateKey, sourceChainProvider);
-//     const contractAddress = addresses[chainId].interopX;
-//     const contract = getContract<InteropX>(contractAddress, abi.interopX, sourceWallet);
-//     const data = await contract.getBridgeAmounts(user, tokens);
-//     return data.map((item, index) => ({
-//         token: tokens[index],
-//         deposit: item.deposit,
-//         withdraw: item.withdraw,
-//     }))
-// }
-async function default_1(transaction, type) {
-    const transactions = [];
-    const logs = [];
-    // if (transaction.actionId !== 'withdraw') {
-    //     throw new Error(`Invalid action: ${transaction.actionId}`)
-    // }
-    // if (type !== 'source') {
-    //     throw new Error(`[WIP] Type not supported: ${type}`)
-    // }
-    // if (transaction.sourceStatus === 'pending') {
-    //     throw Error('Source transaction already processesing')
-    // }
-    // if (transaction.sourceStatus === 'pending') {
-    //     throw Error('Source transaction already processed')
-    // }
-    // if (!transaction.requestEvent) {
-    //     throw Error('Something went wrong, source transaction has no request event')
-    // }
-    // const { actionId, bridger, position, sourceChainId, targetChainId, metadata } = transaction.requestEvent;
-    // const sourceChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(sourceChainId as ChainId));
-    // const sourceWallet = new ethers.Wallet(config.privateKey, sourceChainProvider);
-    // const contractAddress = addresses[sourceChainId].interopX;
-    // const contract = getContract<InteropX>(contractAddress, abi.interopX, sourceWallet);
-    // const sourceToken = tokens[sourceChainId].find(t => t.address.toLowerCase() === position.withdraw[0].sourceToken.toLowerCase());
-    // if (!sourceToken) {
-    //     throw Error('Source token not found')
-    // }
-    // const targetToken = tokens[targetChainId].find(t => t.address.toLowerCase() === position.withdraw[0].targetToken.toLowerCase());
-    // if (!targetToken) {
-    //     throw Error('Target token not found')
-    // }
-    // if (!sourceToken.aliases.some(alias => targetToken.aliases.includes(alias))) {
-    //     throw Error('Source and target token must be the same')
-    // }
-    // const networks: ChainId[] = [137, 43114];
-    // const networkUserData = {}
-    // for (const network of networks) {
-    //     networkUserData[network] = await getBridgeAmounts(bridger, tokens[network].map(t => t.address), network)
-    // }
-    // for (const tokenSymbol of ["dai", "usdc", "usdt", "eth", "wbtc"]) {
-    //     let totalDeposit = BigNumber.from(0)
-    //     let totalWithdraw = BigNumber.from(0)
-    //     for (const network of networks) {
-    //         // on avax might we have 2 usdc/usdt tokens
-    //         const matchedTokens = tokens[network].filter(t => t.aliases.includes(tokenSymbol));
-    //         for (const matchedToken of matchedTokens) {
-    //             const data = networkUserData[network].find(t => t.token.toLowerCase() === matchedToken.address.toLowerCase());
-    //             if (data) {
-    //                 totalDeposit = totalDeposit.add(data.deposit)
-    //                 totalWithdraw = totalWithdraw.add(data.withdraw)
-    //             }
-    //         }
-    //         //  on Mainent add weth too
-    //         if (tokenSymbol === "eth" && network === 1) {
-    //             const weth = tokens[1].find(t => t.symbol === 'WETH');
-    //             if (weth) {
-    //                 const data = networkUserData[1].find(t => t.token.toLowerCase() === weth.address.toLowerCase());
-    //                 if (data) {
-    //                     totalDeposit = totalDeposit.add(data.deposit)
-    //                     totalWithdraw = totalWithdraw.add(data.withdraw)
-    //                 }
-    //             }
-    //         }
-    //     }
-    //     if (totalWithdraw.gt(totalDeposit)) {
-    //         throw Error(`if withdraw > deposit, user has debt and we can't process the withdraw and reject it`)
-    //     }
-    //     if (totalWithdraw.lt(totalDeposit)) {
-    //         throw Error('Something went wrong')
-    //     }
-    // }
-    // let balance = BigNumber.from(0);
-    // if (position.withdraw[0].sourceToken.toLowerCase() === '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'.toLowerCase()) {
-    //     balance = await sourceChainProvider.getBalance(bridger);
-    // } else {
-    //     const erc20 = getContract<Erc20>(position.withdraw[0].sourceToken, abi.erc20, sourceChainProvider);
-    //     balance = await erc20.balanceOf(addresses[sourceChainId].gnosisSafe);
-    // }
-    // if (balance.lt(position.withdraw[0].amount)) {
-    //     throw new LiquidityError()
-    // }
-    // const { data } = await contract.populateTransaction.withdrawRequested(
-    //     actionId,
-    //     bridger,
-    //     position.withdraw[0].sourceToken,
-    //     position.withdraw[0].targetToken,
-    //     position.withdraw[0].amount,
-    //     targetChainId,
-    //     transaction.requestTransactionHash,
-    //     metadata,
-    // );
-    // transactions.push({
-    //     to: contractAddress,
-    //     data: data!,
-    //     value: '0',
-    //     operation: OperationType.Call,
-    // });
-    return { transactions, logs };
-}
-exports.default = default_1;

package/src/gnosis/actions/withdraw/index.ts

@@ -1,155 +0,0 @@
-import abi from "@/abi";
-import config from "@/config";
-import { addresses, tokens } from "@/constants";
-import { Transaction } from "@/db";
-import { Erc20, InteropX } from "@/typechain";
-import { ChainId } from "@/types";
-import { getContract, getRpcProviderUrl, LiquidityError } from "@/utils";
-import { BigNumber, ethers } from "ethers";
-import { MetaTransaction, OperationType } from "ethers-multisend";
-
-
-// const getBridgeAmounts = async (user: string, tokens: string[], chainId: ChainId) => {
-//     const sourceChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(chainId));
-//     const sourceWallet = new ethers.Wallet(config.privateKey, sourceChainProvider);
-//     const contractAddress = addresses[chainId].interopX;
-//     const contract = getContract<InteropX>(contractAddress, abi.interopX, sourceWallet);
-//     const data = await contract.getBridgeAmounts(user, tokens);
-
-
-//     return data.map((item, index) => ({
-//         token: tokens[index],
-//         deposit: item.deposit,
-//         withdraw: item.withdraw,
-//     }))
-// }
-
-export default async function (transaction: Transaction, type: 'source' | 'target') {
-    const transactions: MetaTransaction[] = [];
-    const logs: any[] = [];
-
-    // if (transaction.actionId !== 'withdraw') {
-    //     throw new Error(`Invalid action: ${transaction.actionId}`)
-    // }
-
-    // if (type !== 'source') {
-    //     throw new Error(`[WIP] Type not supported: ${type}`)
-    // }
-
-    // if (transaction.sourceStatus === 'pending') {
-    //     throw Error('Source transaction already processesing')
-    // }
-
-    // if (transaction.sourceStatus === 'pending') {
-    //     throw Error('Source transaction already processed')
-    // }
-
-    // if (!transaction.requestEvent) {
-    //     throw Error('Something went wrong, source transaction has no request event')
-    // }
-
-    // const { actionId, bridger, position, sourceChainId, targetChainId, metadata } = transaction.requestEvent;
-
-    // const sourceChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(sourceChainId as ChainId));
-    // const sourceWallet = new ethers.Wallet(config.privateKey, sourceChainProvider);
-    // const contractAddress = addresses[sourceChainId].interopX;
-    // const contract = getContract<InteropX>(contractAddress, abi.interopX, sourceWallet);
-
-    // const sourceToken = tokens[sourceChainId].find(t => t.address.toLowerCase() === position.withdraw[0].sourceToken.toLowerCase());
-
-    // if (!sourceToken) {
-    //     throw Error('Source token not found')
-    // }
-
-    // const targetToken = tokens[targetChainId].find(t => t.address.toLowerCase() === position.withdraw[0].targetToken.toLowerCase());
-
-    // if (!targetToken) {
-    //     throw Error('Target token not found')
-    // }
-
-    // if (!sourceToken.aliases.some(alias => targetToken.aliases.includes(alias))) {
-    //     throw Error('Source and target token must be the same')
-    // }
-
-    // const networks: ChainId[] = [137, 43114];
-    // const networkUserData = {}
-    // for (const network of networks) {
-    //     networkUserData[network] = await getBridgeAmounts(bridger, tokens[network].map(t => t.address), network)
-    // }
-
-    // for (const tokenSymbol of ["dai", "usdc", "usdt", "eth", "wbtc"]) {
-    //     let totalDeposit = BigNumber.from(0)
-    //     let totalWithdraw = BigNumber.from(0)
-
-    //     for (const network of networks) {
-    //         // on avax might we have 2 usdc/usdt tokens
-    //         const matchedTokens = tokens[network].filter(t => t.aliases.includes(tokenSymbol));
-
-    //         for (const matchedToken of matchedTokens) {
-    //             const data = networkUserData[network].find(t => t.token.toLowerCase() === matchedToken.address.toLowerCase());
-
-    //             if (data) {
-    //                 totalDeposit = totalDeposit.add(data.deposit)
-    //                 totalWithdraw = totalWithdraw.add(data.withdraw)
-    //             }
-    //         }
-
-    //         //  on Mainent add weth too
-    //         if (tokenSymbol === "eth" && network === 1) {
-    //             const weth = tokens[1].find(t => t.symbol === 'WETH');
-
-    //             if (weth) {
-    //                 const data = networkUserData[1].find(t => t.token.toLowerCase() === weth.address.toLowerCase());
-
-    //                 if (data) {
-    //                     totalDeposit = totalDeposit.add(data.deposit)
-    //                     totalWithdraw = totalWithdraw.add(data.withdraw)
-    //                 }
-    //             }
-    //         }
-    //     }
-
-    //     if (totalWithdraw.gt(totalDeposit)) {
-    //         throw Error(`if withdraw > deposit, user has debt and we can't process the withdraw and reject it`)
-    //     }
-
-    //     if (totalWithdraw.lt(totalDeposit)) {
-    //         throw Error('Something went wrong')
-    //     }
-    // }
-
-    // let balance = BigNumber.from(0);
-
-    // if (position.withdraw[0].sourceToken.toLowerCase() === '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'.toLowerCase()) {
-    //     balance = await sourceChainProvider.getBalance(bridger);
-
-    // } else {
-    //     const erc20 = getContract<Erc20>(position.withdraw[0].sourceToken, abi.erc20, sourceChainProvider);
-    //     balance = await erc20.balanceOf(addresses[sourceChainId].gnosisSafe);
-    // }
-
-    // if (balance.lt(position.withdraw[0].amount)) {
-    //     throw new LiquidityError()
-    // }
-
-
-    // const { data } = await contract.populateTransaction.withdrawRequested(
-    //     actionId,
-    //     bridger,
-    //     position.withdraw[0].sourceToken,
-    //     position.withdraw[0].targetToken,
-    //     position.withdraw[0].amount,
-    //     targetChainId,
-    //     transaction.requestTransactionHash,
-    //     metadata,
-    // );
-
-    // transactions.push({
-    //     to: contractAddress,
-    //     data: data!,
-    //     value: '0',
-    //     operation: OperationType.Call,
-    // });
-
-    return { transactions, logs }
-}