Chainlink node CRON job. How does it get paid?

Question

these are the docs

https://docs.chain.link/docs/jobs/types/cron/

type            = "cron"
schemaVersion   = 1
schedule        = "CRON_TZ=UTC * */20 * * * *"
externalJobID       = "0EEC7E1D-D0D2-476C-A1A8-72DFB6633F01"
observationSource   = """
    fetch    [type="http" method=GET url="https://chain.link/ETH-USD"]
    parse    [type="jsonparse" path="data,price"]
    multiply [type="multiply" times=100]

    fetch -> parse -> multiply
"""

But what I am wondering is how the job connects to the Oracle contract. How does it connect with the user contract to get paid. Where and how do we send the data once job is complete at specified increment.

Does the job start when the job is posted on the node side. Or does it start the clock once a user contract calls it?

Any help would be much appreciated. I trying to run through the types of jobs to familarize myself with the capbilities of a chainlink node.

Answer 1

A Chron job executes a job based on a chron defined schedule. This means it's triggered based on some condition that the Chainlink node evaluates, and not triggered externally via a smart contract. Because of this, the node isn't paid in LINK tokens for processing the request like it does for API calls, because it's initiating a request itself as opposed to receiving a request (and payment) from on-chain. A node can't initiate a job on its own and then expect to receive payment from a consuming contract, if you require such functionality then you can try to have some logic in the function called to withdraw some LINK. But be careful of who can call this function.

If you want to send data on-chain to a smart contract once the job is completed, you need to manually define an ethtx task at the end of the cron job.

Here's an extended version of your job that sends the result back to a function called someFunction at the contract deployed at address 0xa36085F69e2889c224210F603D836748e7dC0088. The data can be in any format, as long as the abi of the function matches what's being encoded in the job. ie if the function expects a bytes param, you need to ensure your encoding a bytes param, if it expects a uint param, then you need to encode a uint param. In this example, a bytes parameter is used

    type            = "cron"
schemaVersion   = 1
name = "GET > bytes32 (cron)"
schedule        = "CRON_TZ=UTC @every 1m"
observationSource   = """
    fetch    [type="http" method=GET url="https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD"]
    parse    [type="jsonparse" path="USD"]
    multiply [type="multiply" times=100]
  encode_response [type="ethabiencode"
             abi="(uint256 data)"
             data="{\\"data\\": $(multiply) }"] 
   encode_tx [type="ethabiencode"
              abi="someFunction(bytes32 data)"
              data="{ \\"data\\": $(encode_response) }"]

   submit_tx  [type="ethtx"
               to="0x6495C9684Cc5702522A87adFd29517857FC99f45"
               data="$(encode_tx)"]

    fetch -> parse -> multiply -> encode_response -> encode_tx -> submit_tx
"""

And here's the consuming contract for the cron job above:

// SPDX-Lincense-Identifier: MIT
pragma solidity ^0.8.7;

contract Cron {

    bytes32 public currentPrice; 

    function someFunction(bytes32 _price) public {
        currentPrice = _price;
    }
}

To answer your other question, the is active as soon as it's created on the node, and will start evaluating the triggering conditions for it to active a run, based on the schedule defined