Fuel Mint support Part 1 - Implement HyperFuel query selection for Mint receipts

.github/workflows/build_and_test.yml

@@ -122,15 +122,11 @@ jobs:
           pnpm hardhat compile --verbose
           pnpm res:build
 
-      - name: test_codegen test TS types
-        if: steps.changes.outputs.testChanges == 'true'
-        working-directory: scenarios/test_codegen
-        run: pnpm ts:test
-
       - name: test_codegen test
         if: steps.changes.outputs.testChanges == 'true'
         working-directory: scenarios/test_codegen
         run: |
+          pnpm ts:test
           pnpm test
 
       - name: erc20_multichain_factory build
@@ -157,4 +153,5 @@ jobs:
         if: steps.changes.outputs.testChanges == 'true'
         working-directory: scenarios/fuel_test
         run: |
+          pnpm ts:test
           pnpm test

.gitignore

@@ -11,4 +11,3 @@ scenarios/**/*.res.js
 scenarios/**/*.gen.ts
 scenarios/**/lib/*
 scenarios/**/node_modules/*
-scenarios/**/generated

codegenerator/cli/npm/envio/fuel.schema.json

@@ -99,11 +99,11 @@
       "type": "object",
       "properties": {
         "name": {
-          "description": "A reference to a struct in the ABI or a unique name for the provided log_id",
+          "description": "Name of the event in the HyperIndex generated code",
           "type": "string"
         },
         "logId": {
-          "description": "A reference to a log_id in the ABI",
+          "description": "An identifier of a logged type from ABI. Used for indexing LogData receipts. The option can be omitted when the event name matches the logged struct/enum name.",
           "type": [
             "string",
             "null"

codegenerator/cli/src/config_parsing/human_config.rs

@@ -525,13 +525,12 @@ pub mod fuel {
     #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, JsonSchema)]
     #[serde(rename_all = "camelCase", deny_unknown_fields)]
     pub struct EventConfig {
-        #[schemars(
-            description = "A reference to a struct in the ABI or a unique name for the provided \
-                           log_id"
-        )]
+        #[schemars(description = "Name of the event in the HyperIndex generated code")]
         pub name: String,
         #[serde(skip_serializing_if = "Option::is_none")]
-        #[schemars(description = "A reference to a log_id in the ABI")]
+        #[schemars(
+            description = "An identifier of a logged type from ABI. Used for indexing LogData receipts. The option can be omitted when the event name matches the logged struct/enum name."
+        )]
         pub log_id: Option<String>,
     }
 }

codegenerator/cli/templates/dynamic/codegen/src/RegisterHandlers.res.hbs

@@ -136,12 +136,33 @@ let registerContractHandlers = (
             {{#with chain_config.network_config.hyperfuel_config as | hyperfuel_config |}}
             module(HyperFuelWorker.Make({
               let chain = chain
-              let contracts = contracts
               let endpointUrl = "{{hyperfuel_config.endpoint_url}}"
               let eventModLookup =
                 contracts
                 ->Belt.Array.flatMap(contract => contract.events)
                 ->EventModLookup.fromArrayOrThrow(~chain)
+              let contracts: array<HyperFuelWorker.contract> = [
+                {{#each chain_config.codegen_contracts as | contract |}}
+                {
+                  name: "{{contract.name.capitalized}}",
+                  addresses: [
+                    {{#each contract.addresses as | address |}}
+                    "{{address}}"->Address.unsafeFromString,
+                    {{/each}}
+                  ],
+                  events: [
+                    {{#each contract.events as | event |}}
+                    {
+                      name: "{{event.name.capitalized}}",
+                      logId: Types.{{contract.name.capitalized}}.{{event.name.capitalized}}.sighash,
+                      {{!-- mint: {{#if event.mint}}true{{else}}false{{/if}}, --}}
+                      eventMod: module(Types.{{contract.name.capitalized}}.{{event.name.capitalized}}),
+                    },
+                    {{/each}}
+                  ]
+                },
+                {{/each}}
+              ]
             }))
             {{/with}}
             {{/if}}

codegenerator/cli/templates/static/codegen/src/bindings/Fuel.res

@@ -1,4 +1,17 @@
-type receiptType = | @as(6) LogData
+// 0 = Call
+// 1 = Return,
+// 2 = ReturnData,
+// 3 = Panic,
+// 4 = Revert,
+// 5 = Log,
+// 6 = LogData,
+// 7 = Transfer,
+// 8 = Transferout,
+// 9 = ScriptResult,
+// 10 = MessageOut,
+// 11 = Mint,
+// 12 = Burn,
+type receiptType = | @as(6) LogData | @as(11) Mint | @as(12) Burn
 
 @module("./vendored-fuel-abi-coder.js")
 external transpileAbi: Js.Json.t => Ethers.abi = "transpileAbi"

codegenerator/cli/templates/static/codegen/src/eventFetching/chainWorkers/HyperFuelWorker.res

@@ -3,10 +3,129 @@ open Belt
 
 exception EventRoutingFailed
 
+type event = {
+  name: string,
+  logId?: string,
+  mint?: bool,
+  eventMod: module(Types.Event),
+}
+
+type contract = {
+  name: string,
+  addresses: array<Address.t>,
+  events: array<event>,
+}
+
+let makeGetRecieptsSelectionOrThrow = (~contracts: array<contract>) => {
+  let logDataReceiptTypeSelection: array<Fuel.receiptType> = [LogData]
+  let mintReceiptTypeSelection: array<Fuel.receiptType> = [Mint]
+
+  // only transactions with status 1 (success)
+  let txStatusSelection = [1]
+
+  let mint: ref<[#None | #Wildcard | #NonWildcard]> = ref(#None)
+  let nonWildcardRbsByContract = Js.Dict.empty()
+  let wildcardRbs = []
+
+  let wildcardMintSelection = (
+    {
+      receiptType: mintReceiptTypeSelection,
+      txStatus: txStatusSelection,
+    }: HyperFuelClient.QueryTypes.receiptSelection
+  )
+  let maybeWildcardLogSelection = switch wildcardRbs {
+  | [] => None
+  | wildcardRbs =>
+    Some(
+      (
+        {
+          receiptType: logDataReceiptTypeSelection,
+          txStatus: txStatusSelection,
+          rb: wildcardRbs,
+        }: HyperFuelClient.QueryTypes.receiptSelection
+      ),
+    )
+  }
+
+  contracts->Array.forEach(contract => {
+    let nonWildcardRbs = []
+    contract.events->Array.forEach(event => {
+      let module(Event) = event.eventMod
+      let {isWildcard} = Event.handlerRegister->Types.HandlerTypes.Register.getEventOptions
+      switch event {
+      | {mint: true} => mint := (isWildcard ? #Wildcard : #NonWildcard)
+      | {logId} => {
+          let rb = logId->BigInt.fromStringUnsafe
+          if isWildcard {
+            wildcardRbs->Array.push(rb)->ignore
+          } else {
+            nonWildcardRbs->Array.push(rb)->ignore
+          }
+        }
+      | _ => Js.Exn.raiseError(`Event ${Event.name} is not a mint or log`)
+      }
+    })
+    nonWildcardRbsByContract->Js.Dict.set(contract.name, nonWildcardRbs)
+  })
+
+  (~contractAddressMapping, ~shouldApplyWildcards) => {
+    let selection: array<HyperFuelClient.QueryTypes.receiptSelection> = []
+
+    //Instantiate each time to add new registered contract addresses
+    contracts->Array.forEach(contract => {
+      switch contractAddressMapping->ContractAddressingMap.getAddressesFromContractName(
+        ~contractName=contract.name,
+      ) {
+      | [] => ()
+      | addresses => {
+          if mint.contents == #NonWildcard {
+            selection
+            ->Js.Array2.push({
+              rootContractId: addresses,
+              receiptType: mintReceiptTypeSelection,
+              txStatus: txStatusSelection,
+            })
+            ->ignore
+          }
+          switch nonWildcardRbsByContract->Utils.Dict.dangerouslyGetNonOption(contract.name) {
+          | None => ()
+          | Some(nonWildcardRbs) =>
+            selection
+            ->Js.Array2.push({
+              rootContractId: addresses,
+              receiptType: logDataReceiptTypeSelection,
+              txStatus: txStatusSelection,
+              rb: nonWildcardRbs,
+            })
+            ->ignore
+          }
+        }
+      }
+    })
+
+    if shouldApplyWildcards {
+      if mint.contents == #Wildcard {
+        selection
+        ->Array.push(wildcardMintSelection)
+        ->ignore
+      }
+      switch maybeWildcardLogSelection {
+      | None => ()
+      | Some(wildcardLogSelection) =>
+        selection
+        ->Array.push(wildcardLogSelection)
+        ->ignore
+      }
+    }
+
+    selection
+  }
+}
+
 module Make = (
   T: {
     let chain: ChainMap.Chain.t
-    let contracts: array<Config.contract>
+    let contracts: array<contract>
     let endpointUrl: string
     let eventModLookup: EventModLookup.t
   },
@@ -90,22 +209,7 @@ module Make = (
     }
   }
 
-  let wildcardLogSelection = T.contracts->Belt.Array.keepMap((contract): option<
-    HyperFuel.contractReceiptQuery,
-  > => {
-    let wildcardRb = contract.events->Belt.Array.keepMap(event => {
-      let module(Event) = event
-      let {isWildcard} = Event.handlerRegister->Types.HandlerTypes.Register.getEventOptions
-      isWildcard ? Some(Event.sighash->BigInt.fromStringUnsafe) : None
-    })
-    switch wildcardRb {
-    | [] => None
-    | _ =>
-      Some({
-        rb: wildcardRb,
-      })
-    }
-  })
+  let getRecieptsSelectionOrThrow = makeGetRecieptsSelectionOrThrow(~contracts=T.contracts)
 
   let getNextPage = async (
     ~fromBlock,
@@ -128,40 +232,17 @@ module Make = (
     )
 
     //Instantiate each time to add new registered contract addresses
-    let contractsReceiptQuery = T.contracts->Belt.Array.keepMap((contract): option<
-      HyperFuel.contractReceiptQuery,
-    > => {
-      switch contractAddressMapping->ContractAddressingMap.getAddressesFromContractName(
-        ~contractName=contract.name,
-      ) {
-      | [] => None
-      | addresses =>
-        Some({
-          addresses,
-          rb: contract.events->Array.keepMap(eventMod => {
-            let module(Event: Types.Event) = eventMod
-            let {isWildcard} = Event.handlerRegister->Types.HandlerTypes.Register.getEventOptions
-            isWildcard ? None : Some(Event.sighash->BigInt.fromStringUnsafe)
-          }),
-        })
-      }
-    })
-
-    let contractsReceiptQuery = shouldApplyWildcards
-      ? contractsReceiptQuery->Array.concat(wildcardLogSelection)
-      : contractsReceiptQuery
+    let recieptsSelection = getRecieptsSelectionOrThrow(
+      ~contractAddressMapping,
+      ~shouldApplyWildcards,
+    )
 
     let startFetchingBatchTimeRef = Hrtime.makeTimer()
 
     //fetch batch
     let pageUnsafe = await Helpers.queryLogsPageWithBackoff(
       () =>
-        HyperFuel.queryLogsPage(
-          ~serverUrl=T.endpointUrl,
-          ~fromBlock,
-          ~toBlock,
-          ~contractsReceiptQuery,
-        ),
+        HyperFuel.queryLogsPage(~serverUrl=T.endpointUrl, ~fromBlock, ~toBlock, ~recieptsSelection),
       logger,
     )
 

codegenerator/cli/templates/static/codegen/src/eventFetching/hyperfuel/HyperFuel.res

@@ -46,11 +46,6 @@ type blockNumberAndHash = {
 
 type logsQueryPage = hyperSyncPage<item>
 
-type contractReceiptQuery = {
-  addresses?: array<Address.t>,
-  rb: array<bigint>,
-}
-
 type missingParams = {
   queryName: string,
   missingParams: array<string>,
@@ -89,27 +84,15 @@ let queryErrorToMsq = (e: queryError): string => {
 type queryResponse<'a> = result<'a, queryError>
 
 module LogsQuery = {
-  let receiptTypeSelection: array<Fuel.receiptType> = [LogData]
-  // only transactions with status 1 (success)
-  let txStatusSelection = [1]
-
   let makeRequestBody = (
     ~fromBlock,
     ~toBlockInclusive,
-    ~contractsReceiptQuery: array<contractReceiptQuery>,
+    ~recieptsSelection,
   ): HyperFuelClient.QueryTypes.query => {
-    let receipts = contractsReceiptQuery->Js.Array2.map((
-      q
-    ): HyperFuelClient.QueryTypes.receiptSelection => {
-      rootContractId: ?q.addresses,
-      receiptType: receiptTypeSelection,
-      rb: q.rb,
-      txStatus: txStatusSelection,
-    })
     {
       fromBlock,
       toBlockExclusive: toBlockInclusive + 1,
-      receipts,
+      receipts: recieptsSelection,
       fieldSelection: {
         receipt: [
           TxId,
@@ -198,16 +181,13 @@ module LogsQuery = {
     }
   }
 
-  let queryLogsPage = async (
-    ~serverUrl,
-    ~fromBlock,
-    ~toBlock,
-    ~contractsReceiptQuery,
-  ): queryResponse<logsQueryPage> => {
+  let queryLogsPage = async (~serverUrl, ~fromBlock, ~toBlock, ~recieptsSelection): queryResponse<
+    logsQueryPage,
+  > => {
     let query: HyperFuelClient.QueryTypes.query = makeRequestBody(
       ~fromBlock,
       ~toBlockInclusive=toBlock,
-      ~contractsReceiptQuery,
+      ~recieptsSelection,
     )
 
     let hyperFuelClient = CachedClients.getClient(serverUrl)

codegenerator/cli/templates/static/codegen/src/eventFetching/hyperfuel/HyperFuel.resi

@@ -26,11 +26,6 @@ type blockNumberAndHash = {
 
 type logsQueryPage = hyperSyncPage<item>
 
-type contractReceiptQuery = {
-  addresses?: array<Address.t>,
-  rb: array<bigint>,
-}
-
 type missingParams = {
   queryName: string,
   missingParams: array<string>,
@@ -47,7 +42,7 @@ let queryLogsPage: (
   ~serverUrl: string,
   ~fromBlock: int,
   ~toBlock: int,
-  ~contractsReceiptQuery: array<contractReceiptQuery>,
+  ~recieptsSelection: array<HyperFuelClient.QueryTypes.receiptSelection>,
 ) => promise<queryResponse<logsQueryPage>>
 
 let queryBlockData: (