adapters

Documentation

Overview

Package adapters contain the core adapters used by the Chainlink node.

HTTPGet

The HTTPGet adapter is used to grab the JSON data from the given URL.

{ "type": "HTTPGet", "url": "https://some-api-example.net/api" }

HTTPPost

Sends a POST request to the specified URL and will return the response.

{ "type": "HTTPPost", "url": "https://weiwatchers.com/api" }

JSONParse

The JSONParse adapter will obtain the value(s) for the given field(s).

{ "type": "JSONParse", "path": ["someField"] }

EthBytes32

The EthBytes32 adapter will take the given values and format them for the Ethereum blockhain.

{ "type": "EthBytes32" }

EthInt256

The EthInt256 adapter will take a given signed 256 bit integer and format it to hex for the Ethereum blockchain.

{ "type": "EthInt256" }

EthUint256

The EthUint256 adapter will take a given 256 bit integer and format it in hex for the Ethereum blockchain.

{ "type": "EthUint256" }

EthTx

The EthTx adapter will write the data to the given address and functionSelector.

{
  "type": "EthTx",
  "address": "0x0000000000000000000000000000000000000000",
  "functionSelector": "0xffffffff"
}

Multiplier

The Multiplier adapter multiplies the given input value times another specified value.

{ "type": "Multiply", "times": 100 }

Bridge

The Bridge adapter is used to send and receive data to and from external adapters. The adapter will POST to the target adapter URL with an "id" field for the TaskRunID and a "data" field. For example:

{"id":"b8004e2989e24e1d8e4449afad2eb480","data":{}}

Index

• Variables
• type Adapter
• type AdapterWithMinConfs
  • func For(task models.TaskSpec, store *store.Store) (AdapterWithMinConfs, error)
• type Bridge
  • func (ba *Bridge) MinConfs() uint64
  • func (ba *Bridge) Perform(input models.RunResult, _ *store.Store) models.RunResult
• type Copy
  • func (c *Copy) Perform(input models.RunResult, store *store.Store) models.RunResult
• type EthBytes32
  • func (*EthBytes32) Perform(input models.RunResult, _ *store.Store) models.RunResult
• type EthInt256
  • func (*EthInt256) Perform(input models.RunResult, _ *store.Store) models.RunResult
• type EthTx
  • func (etx *EthTx) Perform(input models.RunResult, store *store.Store) models.RunResult
• type EthUint256
  • func (*EthUint256) Perform(input models.RunResult, _ *store.Store) models.RunResult
• type HTTPGet
  • func (hga *HTTPGet) Perform(input models.RunResult, _ *store.Store) models.RunResult
• type HTTPPost
  • func (hpa *HTTPPost) Perform(input models.RunResult, _ *store.Store) models.RunResult
• type JSONParse
  • func (jpa *JSONParse) Perform(input models.RunResult, _ *store.Store) models.RunResult
• type MinConfsWrappedAdapter
  • func (wa MinConfsWrappedAdapter) MinConfs() uint64
• type Multiplier
  • func (m *Multiplier) UnmarshalJSON(input []byte) error
• type Multiply
  • func (ma *Multiply) Perform(input models.RunResult, _ *store.Store) models.RunResult
• type NoOp
  • func (noa *NoOp) Perform(input models.RunResult, _ *store.Store) models.RunResult
• type NoOpPend
  • func (noa *NoOpPend) Perform(input models.RunResult, _ *store.Store) models.RunResult
• type Sleep
  • func (adapter *Sleep) Perform(input models.RunResult, str *store.Store) models.RunResult
• type Wasm
  • func (wasm *Wasm) Perform(input models.RunResult, _ *store.Store) models.RunResult

Variables

var (
	// TaskTypeCopy is the identifier for the Copy adapter.
	TaskTypeCopy = models.MustNewTaskType("copy")
	// TaskTypeEthBytes32 is the identifier for the EthBytes32 adapter.
	TaskTypeEthBytes32 = models.MustNewTaskType("ethbytes32")
	// TaskTypeEthInt256 is the identifier for the EthInt256 adapter.
	TaskTypeEthInt256 = models.MustNewTaskType("ethint256")
	// TaskTypeEthUint256 is the identifier for the EthUint256 adapter.
	TaskTypeEthUint256 = models.MustNewTaskType("ethuint256")
	// TaskTypeEthTx is the identifier for the EthTx adapter.
	TaskTypeEthTx = models.MustNewTaskType("ethtx")
	// TaskTypeHTTPGet is the identifier for the HTTPGet adapter.
	TaskTypeHTTPGet = models.MustNewTaskType("httpget")
	// TaskTypeHTTPPost is the identifier for the HTTPPost adapter.
	TaskTypeHTTPPost = models.MustNewTaskType("httppost")
	// TaskTypeJSONParse is the identifier for the JSONParse adapter.
	TaskTypeJSONParse = models.MustNewTaskType("jsonparse")
	// TaskTypeMultiply is the identifier for the Multiply adapter.
	TaskTypeMultiply = models.MustNewTaskType("multiply")
	// TaskTypeNoOp is the identifier for the NoOp adapter.
	TaskTypeNoOp = models.MustNewTaskType("noop")
	// TaskTypeNoOpPend is the identifier for the NoOpPend adapter.
	TaskTypeNoOpPend = models.MustNewTaskType("nooppend")
	// TaskTypeSleep is the identifier for the Sleep adapter.
	TaskTypeSleep = models.MustNewTaskType("sleep")
	// TaskTypeWasm is the wasm interpereter adapter
	TaskTypeWasm = models.MustNewTaskType("wasm")
)

Types

type Adapter

type Adapter interface {
	Perform(models.RunResult, *store.Store) models.RunResult
}

Adapter interface applies to all core adapters. Each implementation must return a RunResult.

type AdapterWithMinConfs

type AdapterWithMinConfs interface {
	Adapter
	MinConfs() uint64
}

AdapterWithMinConfs is the interface required for an adapter to be run in the job pipeline. In addition to the Adapter interface, implementers must specify the number of confirmations required before the Adapter can be run.

func For

func For(task models.TaskSpec, store *store.Store) (AdapterWithMinConfs, error)

For determines the adapter type to use for a given task.

type Bridge

type Bridge struct {
	models.BridgeType
	Params *models.JSON
}

Bridge adapter is responsible for connecting the task pipeline to external adapters, allowing for custom computations to be executed and included in runs.

func (*Bridge) MinConfs

func (ba *Bridge) MinConfs() uint64

MinConfs specifies the number of block confirmations needed for the Bridge to run. This method enables the Bridge to meet the adapters.AdapterWithMinConfs interface.

func (*Bridge) Perform

func (ba *Bridge) Perform(input models.RunResult, _ *store.Store) models.RunResult

Perform sends a POST request containing the JSON of the input RunResult to the external adapter specified in the BridgeType. It records the RunResult returned to it, and optionally marks the RunResult pending.

If the Perform is resumed with a pending RunResult, the RunResult is marked not pending and the RunResult is returned.

type Copy

type Copy struct {
	CopyPath []string `json:"copyPath"`
}

Copy obj keys refers to which value to copy inside `data`, each obj value refers to where to copy the value to inside `data`

func (*Copy) Perform

func (c *Copy) Perform(input models.RunResult, store *store.Store) models.RunResult

Perform returns the copied values from the desired mapping within the `data` JSON object

type EthBytes32

type EthBytes32 struct{}

EthBytes32 holds no fields.

func (*EthBytes32) Perform

func (*EthBytes32) Perform(input models.RunResult, _ *store.Store) models.RunResult

Perform returns the hex value of the first 32 bytes of a string so that it is in the proper format to be written to the blockchain.

For example, after converting the string "16800.01" to hex encoded Ethereum ABI, it would be: "0x31363830302e3031000000000000000000000000000000000000000000000000"

type EthInt256

type EthInt256 struct{}

EthInt256 holds no fields

func (*EthInt256) Perform

func (*EthInt256) Perform(input models.RunResult, _ *store.Store) models.RunResult

Perform returns the hex value of a given string so that it is in the proper format to be written to the blockchain.

For example, after converting the string "-123.99" to hex encoded Ethereum ABI, it would be: "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff85"

type EthTx

type EthTx struct {
	Address          common.Address          `json:"address"`
	FunctionSelector models.FunctionSelector `json:"functionSelector"`
	DataPrefix       hexutil.Bytes           `json:"dataPrefix"`
}

EthTx holds the Address to send the result to and the FunctionSelector to execute.

func (*EthTx) Perform

func (etx *EthTx) Perform(input models.RunResult, store *store.Store) models.RunResult

Perform creates the run result for the transaction if the existing run result is not currently pending. Then it confirms the transaction was confirmed on the blockchain.

type EthUint256

type EthUint256 struct{}

EthUint256 holds no fields.

func (*EthUint256) Perform

func (*EthUint256) Perform(input models.RunResult, _ *store.Store) models.RunResult

Perform returns the hex value of a given string so that it is in the proper format to be written to the blockchain.

For example, after converting the string "123.99" to hex encoded Ethereum ABI, it would be: "0x000000000000000000000000000000000000000000000000000000000000007b"

type HTTPGet

type HTTPGet struct {
	URL models.WebURL `json:"url"`
}

HTTPGet requires a URL which is used for a GET request when the adapter is called.

func (*HTTPGet) Perform

func (hga *HTTPGet) Perform(input models.RunResult, _ *store.Store) models.RunResult

Perform ensures that the adapter's URL responds to a GET request without errors and returns the response body as the "value" field of the result.

type HTTPPost

type HTTPPost struct {
	URL models.WebURL `json:"url"`
}

HTTPPost requires a URL which is used for a POST request when the adapter is called.

func (*HTTPPost) Perform

func (hpa *HTTPPost) Perform(input models.RunResult, _ *store.Store) models.RunResult

Perform ensures that the adapter's URL responds to a POST request without errors and returns the response body as the "value" field of the result.

type JSONParse

type JSONParse struct {
	Path []string `json:"path"`
}

JSONParse holds a path to the desired field in a JSON object, made up of an array of strings.

func (*JSONParse) Perform

func (jpa *JSONParse) Perform(input models.RunResult, _ *store.Store) models.RunResult

Perform returns the value associated to the desired field for a given JSON object.

For example, if the JSON data looks like this:

{
  "data": [
    {"last": "1111"},
    {"last": "2222"}
  ]
}

Then ["0","last"] would be the path, and "111" would be the returned value

type MinConfsWrappedAdapter

type MinConfsWrappedAdapter struct {
	Adapter
	ConfiguredConfirmations uint64
}

MinConfsWrappedAdapter allows for an adapter to be wrapped so that it meets the AdapterWithMinConfsInterface.

func (MinConfsWrappedAdapter) MinConfs

func (wa MinConfsWrappedAdapter) MinConfs() uint64

MinConfs specifies the number of block confirmations needed to run the adapter.

type Multiplier

type Multiplier float64

Multiplier represents the number to multiply by in Multiply adapter.

func (*Multiplier) UnmarshalJSON

func (m *Multiplier) UnmarshalJSON(input []byte) error

UnmarshalJSON implements json.Unmarshaler.

type Multiply

type Multiply struct {
	Times Multiplier `json:"times"`
}

Multiply holds the a number to multiply the given value by.

func (*Multiply) Perform

func (ma *Multiply) Perform(input models.RunResult, _ *store.Store) models.RunResult

Perform returns the input's "value" field, multiplied times the adapter's "times" field.

For example, if input value is "99.994" and the adapter's "times" is set to "100", the result's value will be "9999.4".

type NoOp

type NoOp struct{}

NoOp adapter type holds no fields

func (*NoOp) Perform

func (noa *NoOp) Perform(input models.RunResult, _ *store.Store) models.RunResult

Perform returns the empty RunResult

type NoOpPend

type NoOpPend struct{}

NoOpPend adapter type holds no fields

func (*NoOpPend) Perform

func (noa *NoOpPend) Perform(input models.RunResult, _ *store.Store) models.RunResult

Perform on this adapter type returns an empty RunResult with an added field for the status to indicate the task is Pending.

type Sleep

type Sleep struct {
	Until models.Time `json:"until"`
}

Sleep adapter allows a job to do nothing for some amount of wall time.

func (*Sleep) Perform

func (adapter *Sleep) Perform(input models.RunResult, str *store.Store) models.RunResult

Perform returns the input RunResult after waiting for the specified Until parameter.

type Wasm

type Wasm struct {
	WasmT string `json:"wasmt"`
}

Wasm represents a wasm binary encoded as base64 or wasm encoded as text (a lisp like language).

func (*Wasm) Perform

func (wasm *Wasm) Perform(input models.RunResult, _ *store.Store) models.RunResult

Perform ships the wasm representation to the SGX enclave where it is evaluated.