EVER SDK
Developer ToolsEver PlatformForum
  • Ever SDK
  • Quick start (JavaScript)
  • Add EVER to your backend
  • Reference
    • Types and Methods
      • Modules
      • Module abi
      • Module boc
      • Module client
      • Module crypto
      • Module debot
      • Module net
      • Module processing
      • Module proofs
      • Module tvm
      • Module utils
    • Error API
    • Error Codes
    • JavaScript Reference
    • Rust Reference
  • Samples
    • JavaScript Samples
  • guides
    • Installation
      • Add SDK to your App
    • Configuration
      • Endpoint Configuration
      • Message Expiration
      • Message Retry
      • Config Reference
    • Work with contracts
      • Add Contract to your App
      • Use your own Giver
      • Deploy
      • Run on-chain
      • Run ABI Get Method
      • Run Fift Get Method
      • Query/Subscribe for messages(events)
      • Decode Messages(Event)
      • External Signing
      • Emulate Transaction
      • Estimate Fees
      • Validate address, convert address
      • Monitor Messages
      • Trace message processing with REMP
    • Crypto
      • Mnemonics and Keys
    • Queries and subscriptions
      • Use-cases
      • How to work with net module
      • net.query syntax
      • Data pagination
      • Subscribe to Updates
      • Query Collection
      • Aggregate Collection
  • For Binding Developers
    • How to work with Application Objects in binding generators
    • JSON Interface to Ton Client
  • Links
    • Ever SDK repository
    • AppKit JS documentation
Powered by GitBook
On this page
  • Supported languages
  • Rust (core library)
  • Official Javascript(Typescript) binding
  • Community bindings
  • If you did not find the language you need
  • Use-cases
  • Quick Start
  • How to avoid Soft Breaking Problems
  • Build client library
  • Build artifacts
  • Run tests
  • Download precompiled binaries

Was this helpful?

Ever SDK

NextQuick start (JavaScript)

Last updated 9 months ago

Was this helpful?

Client libraries for DApp development in TVM blockchains (Everscale, Gosh, TON, Venom Blockchain, etc.).

Core Ever-SDK client library is written in Rust, with bindings in 11 programming languages.

Get quick help in our telegram channel:

Supported languages

Rust (core library)

Repository: https://github.com/everx-labs/ever-sdk

What is Core Client Library?

Core Client Library is written in Rust that can be dynamically linked. It provides all heavy-computation components and functions, such as TON Virtual Machine, TON Transaction Executor, ABI-related functions, boc-related functions, crypto functions.

The decision to create the Rust library was made after a period of time using pure JavaScript to implement these use cases.

We ended up with very slow work of pure JavaScript and decided to move all this to Rust library and link it to Javascript as a compiled binary including a wasm module for browser applications.

Also, this approach provided an opportunity to easily create bindings for any programming language and platform, thus, to make it possible to develop distributed applications (DApps) for any possible use-cases, such as: mobile DApps, web DApps, server-side DApps, enterprise DApp etc.

Client Library exposes all the functionality through a few of exported functions. All interaction with library is performed using JSON-RPC like protocol.

Official Javascript(Typescript) binding

Platform
Package

core package for all platforms

Node.js

Web

React-Native

React-Native with JSI support

Community bindings

Language
Repository

Clojure

Golang

Java

Kotlin

Lua

.NET

PHP

Python

Ruby

Scala

Swift

If you did not find the language you need

  • write your own binding to chosen language and share it with community.

Use-cases

With Ever-SDK you can implement logic of any complexity on TVM compatible blockchains (Everscale, Gosh, TON, Venom, etc.).

  • Create and send messages to blockchain

  • Process messages reliably (supports retries and message expiration mechanics)

  • Supports TON Solidity and ABI compatible contracts

  • Emulate transactions locally

  • Run get methods

  • Get account state

  • Query blockchain data (blocks, transactions, messages)

  • Subscribe to events and any other blockchain updates (literally)

  • Sign data/check signature, calculate hashes (sha256, sha512), encrypt/decrypt data

  • Validate addresses

  • Work with blockchain native types (bag of cells or BOCs): encode, decode, calculate hash, etc

  • Works on top of GraphQL API and compatible with Evernode-SE/DS, Evercloud.

Quick Start

How to avoid Soft Breaking Problems

Soft Breaking is API changes that include only new optional fields in the existing structures. These changes are fully backward compatible for JSON Interface.

But in Rust such changes can produce some problems with an old client code.

Look at the example below:

  1. There is an API v1.0 function foo and the corresponding params structure:

#[derive(Default)]
struct ParamsOfFoo {
    pub foo: String,
}

pub fn foo(params: ParamsOfFoo)
  1. Application uses this function in this way:

foo(ParamsOfFoo {
    foo: "foo".into(),
});
  1. API v.1.1 introduces new field in ParamsOfFoo:

#[derive(Default)]
struct ParamsOfFoo {
    pub foo: String,
    pub bar: Option<String>,
}

From the perspective of JSON-interface it isn't breaking change because the new parameter is optional. But code snippet (2) will produce Rust compilation error.

  1. To avoid such problems we recommend to use default implementation inside structure initialisation:

foo(ParamsOfFoo {
    foo: "foo".into(),
    ..Default::default(),
});

For all Ton Client API structures Default trait is implemented.

Build client library

The best way to build client libraries is to use build scripts from this repo.

Note: The scripts are written in JavaScript, so you have to install Node.js (v.10 or newer) to run them. Also make sure you have the latest version of Rust installed.

To build a binary for a specific target (or binding), navigate to the relevant folder and run node build.js.

The resulting binaries are placed to bin folder in the gz-compressed format.

Note that the build script generates binaries compatible with the platform used to run the script. For example, if you run it on macOS, you get binaries targeted at Darwin (macOS) platform.

Note: You need latest version of rust. Upgrade it with rustup update command. Check version with rustc --version, it should be above or equal to 1.47.0.

Build artifacts

Rebuild api.json:

cd evercli
cargo run api -o ../tools

Rebuild docs:

cd tools
npm i
tsc
node index docs -o ../docs

Rebuild modules.ts:

cd tools
npm i
tsc
node index binding -l ts -o ../../ever-sdk-js/packages/core/src

Run tests

To run test suite use standard Rust test command

cargo test

Evernode SE is used by default with address http://localhost and port 80. If you launch it on another port you need to specify it explicitly like this: http://localhost:port. If you have Evernode SE running on another address or if you need to run tests on a real Everscale network, use the following environment variables to override the default parameters

TON_USE_SE: true/false - flag defining if tests run against Evernode SE or a real network (DApp Server)
TON_NETWORK_ADDRESS - Dapp server or Evernode SE addresses separated by comma.
TON_GIVER_SECRET - Giver secret key. If not defined, default Evernode SE giver keys are used
TON_GIVER_ADDRESS - Address of the giver to use for prepaying accounts before deploying test contracts. If not defined, the address is calculated using `GiverV2.tvc` and configured public key
EVERCLOUD_AUTH_PROJECT – Evercloud project id used to authorise tests that requires main net interaction 

Download precompiled binaries

Instead of building library yourself, you can download the latest precompiled binaries from EverX SDK Binaries Store.

Platform
Major
Download links

Win32

0

1

macOS

0

1

1

Linux

0

1

Downloaded archive is gzipped file

Repository:

You need to install core package and the package with binary for your platform.

use library module json_interface which provides access to library functions through JSON-RPC interface. This interface exports several extern "C" functions. So you can build a dynamic or static link library and link it to your application as any other external libraries. The JSON Interface is fully "C" compliant. You can find description in section .

If you choose using JSON Interface please read this document . Here you can find directions how to use json_interface and write your own binding.

Get your endpoint at or run Evernode-SE (local node) or Dapp Server (self-hosted blockchain node).

See the list of available TVM networks:

SDK tests need endpoint to run on. Such an API is exposed by a which runs in real networks and by local blockchain .

,

,

(x86_64)

(aarch64)

If you want an older version of library (e.g. 0.25.0 for macOS), you need to choose a link to your platform from the list above and replace 0 with a version:

JavaScript SDK
See the documentation.
JSON Interface
JSON Interface
dashboard.evercloud.dev
https://docs.everplatform.dev/products/evercloud/networks-endpoints
Quick Start (Javascript binding)
Error descriptions
JavaScript SDK Types and Methods (API Reference)
Core Types and Methods (API Reference)
Guides
EVER OS API
DApp Server
Evernode SE
https://binaries.everx-labs.io/tonclient_0_25_0_darwin.gz
@eversdk/core
@eversdk/lib-node
@eversdk/lib-web
@eversdk/lib-react-native
@eversdk/lib-react-native-jsi
serge-medvedev/tonos-client-clojure
radianceteam/ton-client-go
markgenuine/ever-client-go
radianceteam/ton-client-java
laugan/java4ever-binding
mdorofeev/ton-client-kotlin
serge-medvedev/tonos-client-lua
everscale-actions/everscale-dotnet
extraton/php-ton-client
radianceteam/ton-client-php
move-ton/ton-client-py
nerzh/ton-client-ruby
radianceteam/ton-client-scala
nerzh/ton-client-swift
ever_client.lib
ever_client.dll
ever_client.lib
ever_client.dll
libton_client.dylib
libton_client.dylib
libton_client.dylib
libton_client.so
libton_client.so
Ever SDK
Supported languages
Rust (core library)
Official Javascript(Typescript) binding
Community bindings
If you did not find the language you need
Use-cases
Quick Start
How to avoid Soft Breaking Problems
Build client library
Build artifacts
Run tests
Download precompiled binaries