How can I create OCW that won't activates every block, but will activates only when I call function that it represents?

Question

I wanna create OCW that will send a http request to the API and get the response and use this response in runtime code to call extrinsic with this data. This OCW should triggers only when I want to call it, not every block. So, my question is What is the best way to create it? And what is the best architecture decision for this task, should I create another pallet for OCW or I can just write some functionality in already existing pallet and mark this code as #offchain_worker (pseudo) for example for future use? Thanks!

Answer 1

There are 3 levels of answer to this question. As OCW being a commonly misunderstood topic, it is a very good question.

Simple Answer

First, a crude and objectively inefficient answer. You can use the onchain storage that the pallet already gives to you, to trigger the offchain worker. So, an extrinsic would set a storage value, and only when this storage is set the offchain worker would run.

(the following is a pseudo-code, mostly compatibel with FRAME)

// provide ways to set this via extrinsics, as you prefer
#[pallet::storage]
pub type RunWorker = StorageValue<()>;

#[pallet::hooks]
impl Hooks for Pallet {
  fn offchain_worker() -> {
    if !RunWorker::get() { return }
    // rest
  }
}

This method is only reasonable when you want to have some kind of onchain proof (eg. the existence of RunWorker) that offchain workers should have been run. You can then use this to build some kind of an accountability around some nodes (eg. validators) to actually run the offchain workers.

If this is not required, this is mostly a misuse of onchain storage and I won't advice it.

Offchain Workers are off chain..

Which means, in principle, nodes are free to run it whenever they want. The substrate-cli already allows you to configure this to some extent. But it is worth emphasizing that this is an OFF CHAIN operation. It has no impact on the main execution of the chain. It CANNOT alter the state. A block author can decide to not run the offchain worker and it is totally acceptable.

The question would then be, are the execution of these offchain workers important? do all nodes have to run them? How are you going to impose this on thousands of permissionless sovereign node operators? This is where my previous answer might be helpful.

But, if not, the offchain_worker is merely a runtime api that is executed by the node software. You can build further offchain machinery that, for example, allow a node to listen for normal HTTP requests, and upon receiving them, they execute the offchain workers on the next block.

This has not been done to the best of my knowledge, but if it is really want you want, we can discuss an implementation for it.

Does It Have to be a WASM OCW?

Given the above complexities, it is worth asking yourself, does this operation have to be done as a part of a WASM OCW blob that is part of the runtime? can it not just be a PJS-API (combined with any other web/http framework that you wish) script that lives elsewhere, and is executed whenever you want?