// First we create a DataSource - component
// that defines where to get the data and what data should we get.
const dataSource = new DataSourceBuilder()
  // Provide Subsquid Network Gateway URL.
  .setGateway('https://v2.archive.subsquid.io/network/starknet-mainnet')
  // Subsquid Network is always a few thousand blocks behind the head.
  // We must use regular RPC endpoint to get through the last mile
  // and stay on top of the chain.
  // This is a limitation, and we promise to lift it in the future!
  .setRpc(process.env.STARKNET_NODE == null ? undefined : {
    client: new StarknetRpcClient({
      url: process.env.STARKNET_NODE,
      // rateLimit: 100 // requests per sec
    }),
    strideConcurrency: 10
  })
  // Starting from the block where the USDC contract was deployed
  .setBlockRange({from: 3135})
  //
  // Block data returned by the data source has the following structure:
  //
  // interface Block {
  //   header: BlockHeader
  //   transactions: Transaction[]
  //   events: Event[]
  // }
  //
  // For each block item we can specify a set of fields we want to fetch via `.setFields()` method.
  // Think about it as of SQL projection.
  //
  // Accurate selection of only required fields can have a notable positive impact
  // on performance when data is sourced from Subsquid Network.
  //
  // It is possible to override default selection by setting undesired fields to `false`.
  .setFields({
    block: { // block header fields
      timestamp: true
    },
    transaction: { // transaction fields
      transactionHash: true
    },
    event: {
      fromAddress: true,
      data: true
    }
  })
  // By default, block can be skipped if it doesn't contain explicitly requested items.
  //
  // We request items via `.addXxx()` methods.
  //
  // Each `.addXxx()` method accepts item selection criteria
  // and also allows to request related items.
  //
  .addEvent({
    fromAddress: [USDC_ADDRESS],
    transaction: true // fetch transactions that gave rise to the selected events
  })
  .build()

// Below we create a `TypeormDatabase`.
//
// It provides restricted subset of [TypeORM EntityManager API](https://typeorm.io/working-with-entity-manager)
// as a persistent storage interface and works with any Postgres-compatible database.
//
// Note, that we don't pass any database connection parameters.
// That's because `TypeormDatabase` expects a certain project structure
// and environment variables to pick everything it needs by convention.
// Companion `@subsquid/typeorm-migration` tool works in the same way.
//
// For full configuration details please consult
// https://github.com/subsquid/squid-sdk/blob/278195bd5a5ed0a9e24bfb99ee7bbb86ff94ccb3/typeorm/typeorm-config/src/config.ts#L21
const database = new TypeormDatabase()

// Now we are ready to start data processing
run(dataSource, database, async ctx => {
  let transfers: Transfer[] = []

  for (let block of ctx.blocks) {
    for (let event of block.events) {
      transfers.push(new Transfer({
        id: `${block.header.height}-${event.transactionIndex}-${event.eventIndex}`,
        block: block.header.height,
        from: event.data[0],
        to: event.data[1],
        value: event.data[2] ? BigInt(event.data[2]) : undefined,
      }))
    }
  }

  await ctx.store.insert(transfers)
})