Smart Contracts on Producthunt daily

chainlink

Thu, 30 Oct 2025 15:27:33 +0800

smartcontractkit/chainlink

Chainlink expands the capabilities of smart contracts by enabling access to real-world data and off-chain computation while maintaining the security and reliability guarantees inherent to blockchain technology.

This repo contains the Chainlink core node and contracts. The core node is the bundled binary available to be run by node operators participating in a decentralized oracle network. All major release versions have pre-built docker images available for download from the Chainlink dockerhub. If you are interested in contributing please see our contribution guidelines. If you are here to report a bug or request a feature, please check currently open Issues. For more information about how to get started with Chainlink, check our official documentation.

Community

Chainlink has an active and ever growing community. Discord is the primary communication channel used for day to day communication, answering development questions, and aggregating Chainlink related content. Take a look at the community docs for more information regarding Chainlink social accounts, news, and networking.

Build Chainlink

Install Go 1.23, and add your GOPATH’s bin directory to your PATH
- Example Path for macOS export PATH=$GOPATH/bin:$PATH & export GOPATH=/Users/$USER/go
Install NodeJS v20 & pnpm v10 via npm.
- It might be easier long term to use nvm to switch between node versions for different projects. For example, assuming $NODE_VERSION was set to a valid version of NodeJS, you could run: nvm install $NODE_VERSION && nvm use $NODE_VERSION
Install Postgres (>= 12.x). It is recommended to run the latest major version of postgres.
- Note if you are running the official Chainlink docker image, the highest supported Postgres version is 16.x due to the bundled client.
- You should configure Postgres to use SSL connection (or for testing you can set ?sslmode=disable in your Postgres query string).
Download Chainlink: git clone https://github.com/smartcontractkit/chainlink && cd chainlink
Build and install Chainlink: make install
Run the node: chainlink help

For the latest information on setting up a development environment, see the Development Setup Guide.

Build from PR

To build an unofficial testing-only image from a feature branch or PR. You can do one of the following:

Send a workflow dispatch event from our docker-build workflow.
Add the build-publish label to your PR and then either retry the docker-build workflow, or push a new commit.

Build Plugins

Plugins are defined in yaml files within the plugins/ directory. Each plugin file is a yaml file and has a plugins. prefix name. Plugins are installed with loopinstall.

To install the plugins, run:

`1`	`make install-plugins`

Some plugins (such as those in plugins/plugins.private.yaml) reference private GitHub repositories. To build these plugins, you must have a GITHUB_TOKEN environment variable set, or preferably use the gh GitHub CLI tool to use the GitHub CLI credential helper like:

1
2

# Sets up a credential helper.
gh auth setup-git

Then you can build the plugins with:

`1`	`make install-plugins-private`

Docker Builds

To build the experimental “plugins” Chainlink docker image, you can run this from the root of the repository:

1
2
3

# The GITHUB_TOKEN is required to access private repos which are used by some plugins.
export GITHUB_TOKEN=$(gh auth token) # requires the `gh` cli tool.
make docker-plugins

Ethereum Execution Client Requirements

In order to run the Chainlink node you must have access to a running Ethereum node with an open websocket connection. Any Ethereum based network will work once you’ve configured the chain ID. Ethereum node versions currently tested and supported:

[Officially supported]

Parity/Openethereum (NOTE: Parity is deprecated and support for this client may be removed in future)
Geth
Besu

[Supported but broken] These clients are supported by Chainlink, but have bugs that prevent Chainlink from working reliably on these execution clients.

Nethermind Blocking issues:
- ~~https://github.com/NethermindEth/nethermind/issues/4384~~
Erigon Blocking issues:
- https://github.com/ledgerwatch/erigon/discussions/4946
- https://github.com/ledgerwatch/erigon/issues/4030#issuecomment-1113964017

We cannot recommend specific version numbers for ethereum nodes since the software is being continually updated, but you should usually try to run the latest version available.

Running a local Chainlink node

NOTE: By default, chainlink will run in TLS mode. For local development you can disable this by using a dev build using make chainlink-dev and setting the TOML fields:

[WebServer]
SecureCookies = false
TLS.HTTPSPort = 0

[Insecure]
DevWebServer = true

Alternatively, you can generate self signed certificates using tools/bin/self-signed-certs or manually.

To start your Chainlink node, simply run:

`1`	`chainlink node start`

By default this will start on port 6688. You should be able to access the UI at http://localhost:6688/.

Chainlink provides a remote CLI client as well as a UI. Once your node has started, you can open a new terminal window to use the CLI. You will need to log in to authorize the client first:

`1`	`chainlink admin login`

(You can also set ADMIN_CREDENTIALS_FILE=/path/to/credentials/file in future if you like, to avoid having to login again).

Now you can view your current jobs with:

`1`	`chainlink jobs list`

To find out more about the Chainlink CLI, you can always run chainlink help.

Check out the doc pages on Jobs to learn more about how to create Jobs.

Configuration

Node configuration is managed by a combination of environment variables and direct setting via API/UI/CLI.

Check the official documentation for more information on how to configure your node.

External Adapters

External adapters are what make Chainlink easily extensible, providing simple integration of custom computations and specialized APIs. A Chainlink node communicates with external adapters via a simple REST API.

For more information on creating and using external adapters, please see our external adapters page.

Verify Official Chainlink Releases

We use cosign with OIDC keyless signing during the Build, Sign and Publish Chainlink workflow.

It is encourage for any node operator building from the official Chainlink docker image to verify the tagged release version was did indeed built from this workflow.

You will need cosign in order to do this verification. Follow the instruction here to install cosign.

# tag is the tagged release version - ie. 2.16.0
cosign verify index.docker.io/smartcontract/chainlink:${tag} \
      --certificate-oidc-issuer https://token.actions.githubusercontent.com \
      --certificate-identity "https://github.com/smartcontractkit/chainlink/.github/workflows/build-publish.yml@refs/tags/v${tag}"

Development

Running tests

Install pnpm 10 via npm
Install gencodec and jq to be able to run go generate ./... and make abigen
Install mockery

make mockery

Using the make command will install the correct version.

Generate and compile static assets:

`1`	`make generate`

Prepare your development environment:

The tests require a postgres database. In turn, the environment variable CL_DATABASE_URL must be set to value that can connect to _test database, and the user must be able to create and drop the given _test database.

Note: Other environment variables should not be set for all tests to pass

There helper script for initial setup to create an appropriate test user. It requires postgres to be running on localhost at port 5432. You will be prompted for the postgres user password

`1`	`make setup-testdb`

This script will save the CL_DATABASE_URL in .dbenv

Changes to database require migrations to be run. Similarly, pull‘ing the repo may require migrations to run. After the one-time setup above:

1
2

source .dbenv
make testdb

If you encounter the error database accessed by other users (SQLSTATE 55006) exit status 1 and you want force the database creation then use

1
2

source .dbenv
make testdb-force

Run tests:

`1`	`go test ./...`

Notes

The parallel flag can be used to limit CPU usage, for running tests in the background (-parallel=4) - the default is GOMAXPROCS
The p flag can be used to limit the number of packages tested concurrently, if they are interferring with one another (-p=1)
The -short flag skips tests which depend on the database, for quickly spot checking simpler tests in around one minute

Race Detector

As of Go 1.1, the runtime includes a data race detector, enabled with the -race flag. This is used in CI via the tools/bin/go_core_race_tests script. If the action detects a race, the artifact on the summary page will include race.* files with detailed stack traces.

It will not issue false positives, so take its warnings seriously.

For local, targeted race detection, you can run:

1
2

GORACE="log_path=$PWD/race" go test -race ./core/path/to/pkg -count 10
GORACE="log_path=$PWD/race" go test -race ./core/path/to/pkg -count 100 -run TestFooBar/sub_test

https://go.dev/doc/articles/race_detector

Fuzz tests

As of Go 1.18, fuzz tests func FuzzXXX(*testing.F) are included as part of the normal test suite, so existing cases are executed with go test.

Additionally, you can run active fuzzing to search for new cases:

`1`	`go test ./pkg/path -run=XXX -fuzz=FuzzTestName`

https://go.dev/doc/fuzz/

Go Modules

This repository contains three Go modules:

  flowchart RL
    github.com/smartcontractkit/chainlink/v2
    github.com/smartcontractkit/chainlink/integration-tests --> github.com/smartcontractkit/chainlink/v2
    github.com/smartcontractkit/chainlink/core/scripts --> github.com/smartcontractkit/chainlink/v2

The integration-tests and core/scripts modules import the root module using a relative replace in their go.mod files, so dependency changes in the root go.mod often require changes in those modules as well. After making a change, go mod tidy can be run on all three modules using:

`1`	`make gomodtidy`

Code Generation

Go generate is used to generate mocks in this project. Mocks are generated with mockery and live in core/internal/mocks.

Nix

A shell.nix is provided for use with the Nix package manager. By default,we utilize the shell through Nix Flakes.

Nix defines a declarative, reproducible development environment. Flakes version use deterministic, frozen (flake.lock) dependencies to gain more consistency/reproducibility on the built artifacts.

To use it:

Install nix package manager in your system.

Enable flakes support

Run nix develop. You will be put in shell containing all the dependencies.

Optionally, nix develop --command $SHELL will make use of your current shell instead of the default (bash).
You can use direnv to enable it automatically when cd-ing into the folder; for that, enable nix-direnv and use flake on it.

Create a local postgres database:

mkdir -p $PGDATA && cd $PGDATA/
initdb
pg_ctl -l postgres.log -o "--unix_socket_directories='$PWD'" start
createdb chainlink_test -h localhost
createuser --superuser --password chainlink -h localhost
# then type a test password, e.g.: chainlink, and set it in shell.nix CL_DATABASE_URL

When re-entering project, you can restart postgres: cd $PGDATA; pg_ctl -l postgres.log -o "--unix_socket_directories='$PWD'" start Now you can run tests or compile code as usual.
When you’re done, stop it: cd $PGDATA; pg_ctl -o "--unix_socket_directories='$PWD'" stop

Changesets

We use changesets to manage versioning for libs and the services.

Every PR that modifies any configuration or code, should most likely accompanied by a changeset file.

To install changesets:

Install pnpm if it is not already installed - docs.
Run pnpm install.

Either after or before you create a commit, run the pnpm changeset command to create an accompanying changeset entry which will reflect on the CHANGELOG for the next release.

The format is based on Keep a Changelog,

and this project adheres to Semantic Versioning.

Tips

For more tips on how to build and test Chainlink, see our development tips page.

Contributing

Contributions are welcome to Chainlink’s source code.

Please check out our contributing guidelines for more details.

Thank you!

WasmEdge

Fri, 18 Jul 2025 15:35:26 +0800

WasmEdge/WasmEdge

中文 | 正體中文 | 日本語で読む

🤩 WasmEdge is the easiest and fastest way to run LLMs on your own devices. 🤩

WasmEdge is a lightweight, high-performance, and extensible WebAssembly runtime. It is the fastest Wasm VM. WasmEdge is an official sandbox project hosted by the CNCF. LlamaEdge is an application framework built on top of WasmEdge to run GenAI models (e.g., LLM, speech-to-text, text-to-image, and TTS) across GPUs on servers, personal computers, and edge devices. Additional use cases include microservices on the edge cloud, serverless SaaS APIs, embedded functions, smart contracts, and smart devices.

Quick start guides

🚀 Install WasmEdge
👷🏻‍♂️ Build and contribute to WasmEdge
⌨️ Run a standalone Wasm program or a JavaScript program from CLI or Docker
🤖 Chat with an open source LLM via LlamaEdge
🔌 Embed a Wasm function in your Go, Rust, or C app
🛠 Manage and orchestrate Wasm runtimes using Kubernetes, data streaming frameworks, and blockchains
📚 Check out our official documentation

Introduction

The WasmEdge Runtime provides a well-defined execution sandbox for its contained WebAssembly bytecode program. The runtime offers isolation and protection for operating system resources (e.g., file system, sockets, environment variables, processes) and memory space. The most important use case for WasmEdge is to safely execute user-defined or community-contributed code as plug-ins in a software product (e.g., SaaS, software-defined vehicles, edge nodes, or even blockchain nodes). It enables third-party developers, vendors, suppliers, and community members to extend and customize the software product. Learn more here

Performance

A Lightweight Design for High-performance Serverless Computing, published on IEEE Software, Jan 2021. https://arxiv.org/abs/2010.07115
Performance Analysis for Arm vs. x86 CPUs in the Cloud, published on infoQ.com, Jan 2021. https://www.infoq.com/articles/arm-vs-x86-cloud-performance/
WasmEdge is the fastest WebAssembly Runtime in Suborbital Reactr test suite, Dec 2021

Features

WasmEdge can run standard WebAssembly bytecode programs compiled from C/C++, Rust, Swift, AssemblyScript, or Kotlin source code. It runs JavaScript, including 3rd party ES6, CJS, and NPM modules, in a secure, fast, lightweight, portable, and containerized sandbox. It also supports mixing of those languages (e.g., to use Rust to implement a JavaScript API), the Fetch API, and Server-side Rendering (SSR) functions on edge servers.

WasmEdge supports all standard WebAssembly features and many proposed extensions. It also supports a number of extensions tailored for cloud-native and edge computing uses (e.g., the WasmEdge network sockets,Postgres and MySQL-based database driver, and the WasmEdge AI extension).

Learn more about technical highlights of WasmEdge.

Integrations and management

WasmEdge and its contained wasm program can be started from the CLI as a new process, or from an existing process. If started from an existing process (e.g., from a running Go or Rust program), WasmEdge will simply run inside the process as a function. Currently, WasmEdge is not yet thread-safe. In order to use WasmEdge in your own application or cloud-native frameworks, please refer to the guides below.

Community

Contributing

We welcome contributions from the community! Please check out our:

Contributing Guide for how to get started
Governance documentation for project decision-making processes
Code of Conduct for community standards

Want to become a maintainer? See our Contributor Ladder.

Roadmap

Check out our project roadmap to see the upcoming features and plans for WasmEdge.

Contact

If you have any questions, feel free to open a GitHub issue on a related project or to join the following channels:

Mailing list: Send an email to WasmEdge@googlegroups.com
Discord: Join the WasmEdge Discord server!
Slack: Join the #WasmEdge channel on the CNCF Slack
X (formerly Twitter): Follow @realwasmedge on X

Adopters

Check out our list of Adopters who are using WasmEdge in their projects.

Community Meeting

We host a monthly community meeting to showcase new features, demo new use cases, and a Q&A part. Everyone is welcome!

Time: The first Tuesday of each month at 11PM Hong Kong Time/ 7AM PST.

Public meeting agenda/notes | Zoom link

Smart Contracts on Producthunt daily

chainlink

smartcontractkit/chainlink

Community

Build Chainlink

Build from PR

Build Plugins

Docker Builds

Ethereum Execution Client Requirements

Running a local Chainlink node

Configuration

External Adapters

Verify Official Chainlink Releases

Development

Running tests

Notes

Race Detector

Fuzz tests

Go Modules

Code Generation

Nix

Changesets

Tips

Contributing

WasmEdge

WasmEdge/WasmEdge

🤩 WasmEdge is the easiest and fastest way to run LLMs on your own devices. 🤩

Quick start guides

Introduction

Performance

Features

Integrations and management

Community

Contributing

Roadmap

Contact

Adopters

Community Meeting

License