@sentio/sdk 2.3.6-rc.1 → 2.4.0

package/src/eth/tests/types/internal/tokenexchange-test-utils.ts

@@ -0,0 +1,244 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { LogParams } from "ethers/providers";
+import {
+  TokenExchangeEventObject,
+  AddLiquidityEventObject,
+  RemoveLiquidityEventObject,
+  RemoveLiquidityOneEventObject,
+  RemoveLiquidityImbalanceEventObject,
+  CommitNewAdminEventObject,
+  NewAdminEventObject,
+  CommitNewFeeEventObject,
+  NewFeeEventObject,
+  RampAEventObject,
+  StopRampAEventObject,
+} from "./TokenExchange.js";
+import { getTokenExchangeContract } from "./tokenexchange-processor.js";
+const mockField = {
+  blockHash:
+    "0x0000000000000000000000000000000000000000000000000000000000000000",
+  blockNumber: 0,
+  logIndex: 0,
+  removed: false,
+  transactionHash:
+    "0x0000000000000000000000000000000000000000000000000000000000000000",
+  transactionIndex: 0,
+};
+
+export function mockTokenExchangeLog(
+  contractAddress: string,
+  event: TokenExchangeEventObject
+): LogParams {
+  const contract = getTokenExchangeContract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "TokenExchange(address,int128,uint256,int128,uint256)",
+    [
+      event.buyer,
+      event.sold_id,
+      event.tokens_sold,
+      event.bought_id,
+      event.tokens_bought,
+    ]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockAddLiquidityLog(
+  contractAddress: string,
+  event: AddLiquidityEventObject
+): LogParams {
+  const contract = getTokenExchangeContract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "AddLiquidity(address,uint256[3],uint256[3],uint256,uint256)",
+    [
+      event.provider,
+      event.token_amounts,
+      event.fees,
+      event.invariant,
+      event.token_supply,
+    ]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockRemoveLiquidityLog(
+  contractAddress: string,
+  event: RemoveLiquidityEventObject
+): LogParams {
+  const contract = getTokenExchangeContract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "RemoveLiquidity(address,uint256[3],uint256[3],uint256)",
+    [event.provider, event.token_amounts, event.fees, event.token_supply]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockRemoveLiquidityOneLog(
+  contractAddress: string,
+  event: RemoveLiquidityOneEventObject
+): LogParams {
+  const contract = getTokenExchangeContract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "RemoveLiquidityOne(address,uint256,uint256)",
+    [event.provider, event.token_amount, event.coin_amount]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockRemoveLiquidityImbalanceLog(
+  contractAddress: string,
+  event: RemoveLiquidityImbalanceEventObject
+): LogParams {
+  const contract = getTokenExchangeContract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "RemoveLiquidityImbalance(address,uint256[3],uint256[3],uint256,uint256)",
+    [
+      event.provider,
+      event.token_amounts,
+      event.fees,
+      event.invariant,
+      event.token_supply,
+    ]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockCommitNewAdminLog(
+  contractAddress: string,
+  event: CommitNewAdminEventObject
+): LogParams {
+  const contract = getTokenExchangeContract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "CommitNewAdmin(uint256,address)",
+    [event.deadline, event.admin]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockNewAdminLog(
+  contractAddress: string,
+  event: NewAdminEventObject
+): LogParams {
+  const contract = getTokenExchangeContract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "NewAdmin(address)",
+    [event.admin]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockCommitNewFeeLog(
+  contractAddress: string,
+  event: CommitNewFeeEventObject
+): LogParams {
+  const contract = getTokenExchangeContract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "CommitNewFee(uint256,uint256,uint256)",
+    [event.deadline, event.fee, event.admin_fee]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockNewFeeLog(
+  contractAddress: string,
+  event: NewFeeEventObject
+): LogParams {
+  const contract = getTokenExchangeContract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "NewFee(uint256,uint256)",
+    [event.fee, event.admin_fee]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockRampALog(
+  contractAddress: string,
+  event: RampAEventObject
+): LogParams {
+  const contract = getTokenExchangeContract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "RampA(uint256,uint256,uint256,uint256)",
+    [event.old_A, event.new_A, event.initial_time, event.future_time]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockStopRampALog(
+  contractAddress: string,
+  event: StopRampAEventObject
+): LogParams {
+  const contract = getTokenExchangeContract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "StopRampA(uint256,uint256)",
+    [event.A, event.t]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}

package/src/eth/tests/types/membershipstakerv3.ts

@@ -0,0 +1,7 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+export * from "./internal/membershipstakerv3-processor.js";
+export * from "./internal/MembershipStakerV3.js";
+export * from "./internal/membershipstakerv3-test-utils.js";

package/src/eth/tests/types/pyth.ts

@@ -0,0 +1,7 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+export * from "./internal/pyth-processor.js";
+export * from "./internal/Pyth.js";
+export * from "./internal/pyth-test-utils.js";

package/src/eth/tests/types/seaport.ts

@@ -0,0 +1,7 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+export * from "./internal/seaport-processor.js";
+export * from "./internal/Seaport.js";
+export * from "./internal/seaport-test-utils.js";

package/src/eth/tests/types/tokenexchange.ts

@@ -0,0 +1,7 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+export * from "./internal/tokenexchange-processor.js";
+export * from "./internal/TokenExchange.js";
+export * from "./internal/tokenexchange-test-utils.js";

package/src/sui/sui-processor.ts

@@ -5,6 +5,7 @@ import { ServerError, Status } from 'nice-grpc'
 import { SuiContext } from './context.js'
 import { MoveEvent, SuiTransactionResponse, getMoveCallTransaction, MoveCall } from '@mysten/sui.js'
 import { CallHandler, EventFilter, EventHandler, FunctionNameAndCallFilter } from '../move/index.js'
+import { getMoveCalls } from './utils.js'
 
 class IndexConfigure {
   address: string
@@ -129,13 +130,7 @@ export class SuiBaseProcessor {
           tx
         )
         if (tx) {
-          const calls: MoveCall[] = tx.certificate.data.transactions.flatMap((tx) => {
-            const call = getMoveCallTransaction(tx)
-            if (call) {
-              return [call]
-            }
-            return []
-          })
+          const calls: MoveCall[] = getMoveCalls(tx)
           if (calls.length !== 1) {
             throw new ServerError(Status.INVALID_ARGUMENT, 'Unexpected number of call transactions ' + calls.length)
           }

package/src/sui/utils.ts

@@ -0,0 +1,11 @@
+import { SuiTransactionResponse, getMoveCallTransaction, MoveCall } from '@mysten/sui.js'
+
+export function getMoveCalls(tx: SuiTransactionResponse) {
+  return tx.certificate.data.transactions.flatMap((tx) => {
+    const call = getMoveCallTransaction(tx)
+    if (call) {
+      return [call]
+    }
+    return []
+  })
+}

package/src/testing/aptos-facet.ts

@@ -0,0 +1,111 @@
+import { Transaction_UserTransaction, TransactionPayload_EntryFunctionPayload } from '../aptos/index.js'
+import { DataBinding, HandlerType } from '@sentio/protos'
+import { getChainId } from '../aptos/network.js'
+import { TestProcessorServer } from './test-processor-server.js'
+import { AptosNetwork, Event } from '@sentio/sdk/aptos'
+import { parseMoveType } from '../aptos/types.js'
+
+export class AptosFacet {
+  server: TestProcessorServer
+  constructor(server: TestProcessorServer) {
+    this.server = server
+  }
+
+  testEntryFunctionCall(transaction: Transaction_UserTransaction, network: AptosNetwork = AptosNetwork.MAIN_NET) {
+    return this.testEntryFunctionCalls([transaction], network)
+  }
+
+  testEntryFunctionCalls(transactions: Transaction_UserTransaction[], network: AptosNetwork = AptosNetwork.MAIN_NET) {
+    const bindings = []
+    for (const trans of transactions) {
+      const binding = this.buildEntryFunctionCallBinding(trans, network)
+      if (!binding) {
+        throw Error('Invalid test transaction: ' + JSON.stringify(trans))
+      }
+      bindings.push(binding)
+    }
+    return this.server.processBindings({
+      bindings: bindings,
+    })
+  }
+
+  private buildEntryFunctionCallBinding(
+    transaction: Transaction_UserTransaction,
+    network: AptosNetwork = AptosNetwork.MAIN_NET
+  ): DataBinding | undefined {
+    const payload = transaction.payload as TransactionPayload_EntryFunctionPayload
+    for (const config of this.server.contractConfigs) {
+      if (config.contract?.chainId !== getChainId(network)) {
+        continue
+      }
+      for (const callConfig of config.moveCallConfigs) {
+        for (const callFilter of callConfig.filters) {
+          if (config.contract.address + '::' + callFilter.function === payload.function) {
+            return {
+              data: {
+                aptCall: {
+                  transaction,
+                },
+              },
+              handlerIds: [callConfig.handlerId],
+              handlerType: HandlerType.APT_CALL,
+            }
+          }
+        }
+      }
+    }
+    return undefined
+  }
+
+  testEvent(
+    transaction: Transaction_UserTransaction,
+    event: number | Event,
+    network: AptosNetwork = AptosNetwork.MAIN_NET
+  ) {
+    if (typeof event !== 'number') {
+      const transaction2: Transaction_UserTransaction = {} as any
+      Object.assign(transaction2, transaction)
+      transaction = transaction2
+      transaction.events = [event]
+      event = 0
+    }
+    const binding = this.buildEventBinding(transaction, event, network)
+    if (!binding) {
+      throw Error('Invalid test event: ' + JSON.stringify(transaction))
+    }
+    return this.server.processBinding(binding)
+  }
+
+  private buildEventBinding(
+    transaction: Transaction_UserTransaction,
+    eventIdx: number,
+    network: AptosNetwork = AptosNetwork.MAIN_NET
+  ): DataBinding | undefined {
+    // const allEvents = new Set(transaction.events.map(e => e.type))
+    for (const config of this.server.contractConfigs) {
+      if (config.contract?.chainId !== getChainId(network)) {
+        continue
+      }
+      for (const eventConfig of config.moveEventConfigs) {
+        for (const eventFilter of eventConfig.filters) {
+          if (
+            config.contract.address + '::' + eventFilter.type ===
+            parseMoveType(transaction.events[eventIdx].type).qname
+          ) {
+            transaction.events = [transaction.events[eventIdx]]
+            return {
+              data: {
+                aptEvent: {
+                  transaction,
+                },
+              },
+              handlerIds: [eventConfig.handlerId],
+              handlerType: HandlerType.APT_EVENT,
+            }
+          }
+        }
+      }
+    }
+    return undefined
+  }
+}

package/src/testing/eth-facet.ts

@@ -0,0 +1,233 @@
+import { TestProcessorServer } from './test-processor-server.js'
+import { DataBinding, HandlerType, ProcessBindingResponse } from '@sentio/protos'
+import { Trace } from '../eth/trace.js'
+import { BlockParams, LogParams, Network, Networkish } from 'ethers/providers'
+import { Block } from 'ethers'
+
+export class EthFacet {
+  server: TestProcessorServer
+
+  constructor(server: TestProcessorServer) {
+    this.server = server
+  }
+
+  testTrace(trace: Trace, network: Networkish = 1): Promise<ProcessBindingResponse> {
+    return this.testTraces([trace], network)
+  }
+
+  testTraces(traces: Trace[], network: Networkish = 1): Promise<ProcessBindingResponse> {
+    const bindings = []
+    for (const trace of traces) {
+      const binding = this.buildTraceBinding(trace, network)
+      if (!binding) {
+        throw Error('Invalid test trace: ' + JSON.stringify(trace))
+      }
+      bindings.push(binding)
+    }
+    return this.server.processBindings({
+      bindings: bindings,
+    })
+  }
+
+  buildTraceBinding(trace: Trace, network: Networkish = 1): DataBinding | undefined {
+    if (trace.type !== 'call' || !trace.action.input) {
+      throw Error('Invalid test trace: ' + JSON.stringify(trace))
+    }
+    const signature = trace.action.input.slice(0, 10)
+
+    for (const contract of this.server.contractConfigs) {
+      if (contract.contract?.chainId !== Network.from(network).chainId.toString()) {
+        continue
+      }
+      if (trace.action.to?.toLowerCase() !== contract.contract?.address.toLowerCase()) {
+        continue
+      }
+      for (const config of contract.traceConfigs) {
+        if (config.signature == signature) {
+          return {
+            data: {
+              ethTrace: {
+                trace,
+                timestamp: new Date(),
+              },
+            },
+            handlerIds: [config.handlerId],
+            handlerType: HandlerType.ETH_TRACE,
+          }
+        }
+      }
+    }
+    return undefined
+  }
+
+  testLog(log: LogParams, network: Networkish = 1): Promise<ProcessBindingResponse> {
+    return this.testLogs([log], network)
+  }
+
+  testLogs(logs: LogParams[], network: Networkish = 1): Promise<ProcessBindingResponse> {
+    const bindings = []
+    for (const log of logs) {
+      const binding = this.buildLogBinding(log, network)
+      if (!binding) {
+        throw Error('Invalid test log: ' + JSON.stringify(log))
+      }
+      bindings.push(binding)
+    }
+    return this.server.processBindings({
+      bindings: bindings,
+    })
+  }
+
+  buildLogBinding(log: LogParams, network: Networkish = 1): DataBinding | undefined {
+    for (const contract of this.server.contractConfigs) {
+      if (contract.contract?.chainId !== Network.from(network).chainId.toString()) {
+        continue
+      }
+      if (log.address.toLowerCase() !== contract.contract?.address.toLowerCase()) {
+        continue
+      }
+      for (const config of contract.logConfigs) {
+        for (const filter of config.filters) {
+          // if (filter.topics.length != log.topics.length) {
+          //   continue
+          // }
+
+          let match = true
+          for (const topicIdx in filter.topics) {
+            const logTopic = log.topics[topicIdx]
+            const possibleTopic = filter.topics[topicIdx].hashes
+            if (possibleTopic.length === 0) {
+              // match all
+              continue
+            }
+            if (possibleTopic.find((e) => e.toLowerCase() === logTopic.toLowerCase())) {
+              // find one
+              continue
+            }
+            match = false
+            break
+          }
+          if (match) {
+            return {
+              data: {
+                ethLog: { log, timestamp: new Date() },
+              },
+              handlerIds: [config.handlerId],
+              handlerType: HandlerType.ETH_LOG,
+            }
+          }
+        }
+      }
+    }
+    return undefined
+  }
+  testAccountLog(address: string, log: LogParams, network: Networkish = 1): Promise<ProcessBindingResponse> {
+    return this.testAccountLogs(address, [log], network)
+  }
+
+  testAccountLogs(address: string, logs: LogParams[], network: Networkish = 1): Promise<ProcessBindingResponse> {
+    const bindings = []
+    for (const log of logs) {
+      const binding = this.buildAccountLogBinding(address, log, network)
+      if (!binding) {
+        throw Error('Invalid test log: ' + JSON.stringify(log))
+      }
+      bindings.push(binding)
+    }
+    return this.server.processBindings({
+      bindings: bindings,
+    })
+  }
+
+  buildAccountLogBinding(address: string, log: LogParams, network: Networkish = 1): DataBinding | undefined {
+    for (const account of this.server.accountConfigs) {
+      if (account.chainId !== Network.from(network).chainId.toString()) {
+        continue
+      }
+      if (address.toLowerCase() !== account.address.toLowerCase()) {
+        continue
+      }
+      for (const config of account.logConfigs) {
+        for (const filter of config.filters) {
+          // if (filter.topics.length != log.topics.length) {
+          //   continue
+          // }
+
+          let match = true
+          for (const topicIdx in filter.topics) {
+            const logTopic = log.topics[topicIdx]
+            const possibleTopic = filter.topics[topicIdx].hashes
+            if (possibleTopic.length === 0) {
+              // match all
+              continue
+            }
+            if (possibleTopic.find((e) => e.toLowerCase() === logTopic.toLowerCase())) {
+              // find one
+              continue
+            }
+            match = false
+            break
+          }
+          if (match) {
+            return {
+              data: {
+                ethLog: { log, timestamp: new Date() },
+              },
+              handlerIds: [config.handlerId],
+              handlerType: HandlerType.ETH_LOG,
+            }
+          }
+        }
+      }
+    }
+    return undefined
+  }
+
+  testBlock(
+    block: Partial<BlockParams> & { number: number },
+    network: Networkish = 1
+  ): Promise<ProcessBindingResponse> {
+    return this.testBlocks([block], network)
+  }
+
+  testBlocks(blocks: Partial<BlockParams> & { number: number }[], network: Networkish = 1) {
+    const bindings = []
+    for (const block of blocks) {
+      const binding = this.buildBlockBinding(block, network)
+      if (!binding) {
+        throw Error('Invalid test block: ' + JSON.stringify(block))
+      }
+      bindings.push(binding)
+    }
+    return this.server.processBindings({
+      bindings: bindings,
+    })
+  }
+
+  buildBlockBinding(block: Partial<Block> & { number: number }, network: Networkish = 1): DataBinding {
+    const binding: DataBinding = {
+      data: {
+        ethBlock: { block },
+      },
+      handlerType: HandlerType.ETH_BLOCK,
+      handlerIds: [],
+    }
+    for (const contract of this.server.contractConfigs) {
+      if (contract.contract?.chainId !== Network.from(network).chainId.toString()) {
+        continue
+      }
+      const longBlockNumber = block.number
+      if (longBlockNumber < contract.startBlock) {
+        continue
+      }
+      if (contract.endBlock !== 0n && longBlockNumber >= contract.endBlock) {
+        continue
+      }
+
+      for (const config of contract.intervalConfigs) {
+        binding.handlerIds.push(config.handlerId)
+      }
+    }
+    return binding
+  }
+}

package/src/testing/solana-facet.ts

@@ -0,0 +1,25 @@
+import { TestProcessorServer } from './test-processor-server.js'
+import { Data_SolInstruction, HandlerType, ProcessBindingResponse } from '@sentio/protos'
+
+export class SolanaFacet {
+  server: TestProcessorServer
+
+  constructor(server: TestProcessorServer) {
+    this.server = server
+  }
+
+  testInstructions(instructions: Data_SolInstruction[]): Promise<ProcessBindingResponse> {
+    return this.server.processBindings({
+      bindings: instructions.map((instruction) => {
+        return {
+          data: {
+            raw: new Uint8Array(),
+            solInstruction: instruction,
+          },
+          handlerIds: [],
+          handlerType: HandlerType.SOL_INSTRUCTION,
+        }
+      }),
+    })
+  }
+}