1 of 24

Tools & Libraries

Network interaction SDKs

Here all interaction SDKs are listed that are maintained for the Secret Network

Secret.js (JavaScript)

A toolkit very similar to CosmJs that allows people to create and sign contract executions, integrate wallets and more.

Documentation for Secret.Js is separately hosted under: https://secretjs.scrt.network/

SecretPy (Python)

The Secret Software Development Kit (SDK) in Python is a simple library toolkit for building software that can interact with the Secret blockchain and provides simple abstractions over core data structures, serialization, key management, and API request generation.

Features

Written in Python offering extensive support libraries
Versatile support for key management solutions
Exposes the Secret Rest API through LCD/REST client

See the full documentation, code and usage examples here: https://github.com/secretanalytics/secret-sdk-python

SecretK (Kotlin)

A Kotlin multiplatform Encryption and REST client for Secret Network utilizing gRPC gateway endpoints.

Supported Features:

Contract Queries
Simulate Contract Execution To Estimate Gas
Contract Execution (MsgExecuteContract)
Contract Code Upload (MsgStoreCode)
Contract Instantiate (MsgInstantiateContract)
Contract Migrate (MsgMigrateContract)
Contract Update Admin (MsgUpdateAdmin)
Contract Clear Admin (MsgClearAdmin)
Bank Send (MsgSend)
Web: Delegate signing transactions to Kepler or Metamask browser wallets

Supported Targets:

JVM
js
iOS
macOS
TODO: linux

Swift/Objective-C Support

An experimental swift pacakge for use with iOS and macOS is available as well.

See the full documentation, code and usage examples here For help and questions please ask Luca Spinazzola from Eqoty Labs.

Secret.NET

Secret.NET (full port of the secret.js Client) is a .NET SDK for writing applications that interact with the Secret Network blockchain.

Written in C# / .NET 6 including MAUI Support.
Can be used in MAUI Apps on Android, iOS, Windows and Mac.
Provides simple abstractions over core data structures.
Supports every possible message and transaction type.
Exposes every possible query type.
Handles input/output encryption/decryption for Secret Contracts.
The SDK has a wallet built in and does not currently require / support external wallets.
Custom APIs / clients for specific smart contracts can be easily created and the additional packages for tokens / SNIP20 or NFT / SNIP721 (see below) can serve as an example for this.

You can find the source code and full version of the docs at https://github.com/0xxCodemonkey/SecretNET/

Additional packages

In addition the following complementary packages are available, which act as a layer on top of the Secret.NET:

SecretNET.Token supports all methods of the reference implementation of the SNIP20 contract.
SecretNET.NFT supports all methods of the reference implementation of the SNIP721 contract.

Install / Add Secret.NET to a project

All packages are available via NuGet and can be easily installed nuget.exe -CLI:

nuget install SecretNET
nuget install SecretNET.Token
nuget install SecretNET.NFT

NuGet-Paket-Manager-Console:

Install-Package SecretNET
Install-Package SecretNET.Token
Install-Package SecretNET.NFT

What is .NET MAUI?

.NET Multi-platform App UI (.NET MAUI) is a cross-platform framework for creating native mobile and desktop apps with C# and XAML.

Using .NET MAUI, you can develop apps that can run on Android, iOS, macOS, and Windows from a single shared code-base.

.NET MAUI is open-source and is the evolution of Xamarin.Forms, extended from mobile to desktop scenarios, with UI controls rebuilt from the ground up for performance and extensibility.

Using .NET MAUI, you can create multi-platform apps using a single project, but you can add platform-specific source code and resources if necessary. One of the key aims of .NET MAUI is to enable you to implement as much of your app logic and UI layout as possible in a single code-base.

Who .NET MAUI is for

.NET MAUI is for developers who want to:

Write cross-platform apps in XAML and C#, from a single shared code-base in Visual Studio.
Share UI layout and design across platforms.
Share code, tests, and business logic across platforms.

More informations about .NET MAUI:

Snippets

In this section we will provide examples to common usage patterns of Secret.NET

Deploying a Contract

using SecretNET;
using SecretNET.Common;
using SecretNET.Common.Storage;
using SecretNET.Tx;

// Select a storage provider for the wallet
// Docs: https://github.com/0xxCodemonkey/SecretNET#creating--initializing-the-wallet
var storageProvider = new AesEncryptedFileStorage("", "SuperSecurePassword");
var createWalletOptions = new CreateWalletOptions(storageProvider);

// Import wallet from mnemonic phrase
// Use key created snippet "Create a new Wallet"
Wallet wallet = null;
if (await storageProvider.HasPrivateKey())
{
    var storedMnemonic = await storageProvider.GetFirstMnemonic();
    Console.WriteLine("Use stored mnemonic: " + storedMnemonic);
    wallet = await Wallet.Create(storedMnemonic, options: createWalletOptions);
    Console.WriteLine("wallet.Address: " + wallet.Address);
}

// get infos from https://docs.scrt.network/secret-network-documentation/development/connecting-to-the-network
var gprcUrl = "https://grpc.testnet.secretsaturn.net";
var chainId = "pulsar-3";

// Create a connection to Secret Network node
// Pass in a wallet that can sign transactions
// Docs: https://github.com/0xxCodemonkey/SecretNET#creating--initializing-the-wallet
var secretClient = new SecretNetworkClient(gprcUrl, chainId, wallet: wallet);

// Upload the wasm of a simple contract
byte[] wasmByteCode = File.ReadAllBytes(@"mysimplecounter.wasm.gz");

// MsgStoreCode
var msgStoreCodeCounter = new MsgStoreCode(
      wasmByteCode,
      source: "", // Source is a valid absolute HTTPS URI to the contract's source code, optional
      builder: ""  // Builder is a valid docker image name with tag, optional
      );

var storeCodeResponse = await secretClient.Tx.Compute.StoreCode(msgStoreCodeCounter, new TxOptions() { GasLimit = 2_000_000 });

var codeId = storeCodeResponse.Response.CodeId;

// contract hash, useful for contract composition
var contractCodeHash = await secretClient.Query.Compute.GetCodeHashByCodeId(codeId);

// Create an instance of the Counter contract, providing a starting count
var msgInitContract = new MsgInstantiateContract(
                        codeId: codeId,
                        label: $"My Counter {codeId}",
                        initMsg: new { count = 100 },
                        codeHash: contractCodeHash); // optional but way faster


var initContractResponse = await secretClient.Tx.Compute.InstantiateContract(msgInitContract, new TxOptions() { GasLimit = 200_000 });


//Find the contract_address in the logs
var contractAddress = initContractResponse?.Response?.Address;

var msgExecuteContract = new MsgExecuteContract(
                            contractAddress: contractAddress,
                            msg: new { increment = new { } },
                            codeHash: contractCodeHash);

var tx = await secretClient.Tx.Compute.ExecuteContract(msgExecuteContract, new TxOptions() { GasLimit = 200_000 });

Send Native Coin

using SecretNET;
using SecretNET.Common;
using SecretNET.Common.Storage;
using SecretNET.Tx;

// Select a storage provider for the wallet
// Docs: https://github.com/0xxCodemonkey/SecretNET#creating--initializing-the-wallet
var storageProvider = new AesEncryptedFileStorage("", "SuperSecurePassword");
var createWalletOptions = new CreateWalletOptions(storageProvider);

// Import wallet from mnemonic phrase
// Use key created snippet "Create a new Wallet"
Wallet wallet = null;
if (await storageProvider.HasPrivateKey())
{
    var storedMnemonic = await storageProvider.GetFirstMnemonic();
    Console.WriteLine("Use stored mnemonic: " + storedMnemonic);
    wallet = await Wallet.Create(storedMnemonic, options: createWalletOptions);
    Console.WriteLine("wallet.Address: " + wallet.Address);
}

// get infos from https://docs.scrt.network/secret-network-documentation/development/connecting-to-the-network
var gprcUrl = "https://grpc.testnet.secretsaturn.net";
var chainId = "pulsar-3";

// Create a connection to Secret Network node
// Pass in a wallet that can sign transactions
// Docs: https://github.com/0xxCodemonkey/SecretNET#creating--initializing-the-wallet
var secretClient = new SecretNetworkClient(gprcUrl, chainId, wallet: wallet);

var tx = await secretClient.Tx.Bank.Send(
                      toAddress: "secret1j8u7n4v93kjyqa7wzzrgjule8gh4adde36mnwd",
                      amount: 1000000,
                      denom: "uscrt",
                      txOptions: new TxOptions() { GasLimit = 2_000_000 }
                      );

Console.WriteLine("Transaction: ", tx);

Query a Contract

// Query the current count
Console.WriteLine("Querying contract for current count");
await secretClient.Query.Compute.QueryContract<string>(
        contractAddress, 
        new { get_count = new { } }, 
        contractCodeHash);

Create a new Wallet

using SecretNET;
using SecretNET.Common;
using SecretNET.Common.Storage;
using System;

// Select a storage provider for the wallet
// Docs: https://github.com/0xxCodemonkey/SecretNET#creating--initializing-the-wallet
var storageProvider = new AesEncryptedFileStorage("", "SuperSecurePassword");
var createWalletOptions = new CreateWalletOptions(storageProvider);

// Create a new account
var wallet = await Wallet.Create(options: createWalletOptions);

// get infos from https://docs.scrt.network/secret-network-documentation/development/connecting-to-the-network
var gprcUrl = "https://grpc.testnet.secretsaturn.net"; 
var chainId = "pulsar-3";

// Create a readonly connection to Secret Network node (does not attach the wallet)
var secretClient = new SecretNetworkClient(gprcUrl, chainId, wallet: null); // without a wallet

var response = await secretClient.Query.Bank.Balance(wallet.Address);

Console.WriteLine("Mnemonic: " + (await storageProvider.GetMnemonic(wallet.Address)));
Console.WriteLine("Address: " + wallet.Address);
Console.WriteLine($"Balance: {(float.Parse(response.Amount) / 1000000f)} SCRT"); // 1,000,00 uscrt = 1 SCRT

Permits

Sign a Permit and use in a query

var permit = await secretClient.Permit.Sign(
    owner: wallet.Address,
    chainId: secretClient.ChainId,
    permitName: "test",
    allowedContracts: new string[] { contractAddress },
    permissions: new PermissionType[] {
        PermissionType.Owner,
        PermissionType.Balance
    });

var snip20Client = new SecretNET.Token.Snip20Client(secretClient); // SecretNET.Token 
var query = await snip20Client.Query.GetBalance(contractAddress, permit: permit, codeHash: permitContractCodeHash);

Verify a Permit

var permit = await secretClient.Permit.Sign(
    owner: wallet.Address,
    chainId: secretClient.ChainId,
    permitName: "test",
    allowedTokens: new string[] { "abcdef" },
    permissions: new PermissionType[] {
        PermissionType.Owner
    });

var result = secretClient.Permit.Verify(
  permit,
  wallet.Address,
  "abcdef",
  new PermissionType[] { PermissionType.Owner }
);

SNIP20

SecretNET.Token is a layer on top of the Secret.NET which supports all methods of the reference implementation of the SNIP20 contract.

nuget install SecretNET.Token

Transfer SNIP-20 tokens

var snip20Client = new SecretNET.Token.Snip20Client(secretClient);

var txExec = await snip20Client.Tx.Transfer(
                       contractAddress,
                       recipient,
                       amount, // int as string
                       codeHash,
                       txOptions: new TxOptions() { GasLimit = 5_000_000 }
                    );

Send SNIP-20 Tokens

var txExec = await snip20Client.Tx.Send(
                       contractAddress,
                       recipient,
                       amount, // int as string
                       codeHash,
                       txOptions: new TxOptions() { GasLimit = 5_000_000 }
                    );

Set Viewing Key and Query Balance

var txExec = await snip20Client.Tx.SetViewingKey(
                    contractAddress,
                    "hello",
                    txOptions: new TxOptions() { GasLimit = 100_000 });

var txQuery = await snip20Client.Query.GetBalance(
                    contractAddress, 
                    viewingKey: "hello", 
                    codeHash: codeHash
                    );

Query Token Parameters

var txQuery = await await snip20Client.Query.GetTokenInfo(
                    contractAddress, 
                    codeHash: codeHash
                    );

Get Transaction History

var txQuery = await snip20Client.Query.GetTransactionHistory(
                    contractAddress, 
                    pageSize: 10,
                    viewingKey: "hello",                     
                    codeHash: codeHash
                    );

SNIP721

SecretNET.NFT is a layer on top of the Secret.NET which supports all methods of the reference implementation of the SNIP721 contract.

nuget install SecretNET.NFT

Add Minter

var snip721Client = new SecretNET.NFT.Snip721Client(secretClient); // SecretNET.NFT 

var addMinterMsg = new SecretNET.NFT.AddMinterRequest(minters: new[] { "" });
var addMinter = await snip721Client.Tx.AddMinter(
                msg: new SecretNET.NFT.MsgAddMinter(addMinterMsg, contractAddress, codeHash), 
                txOptions: new TxOptions() { GasLimit = 100_000 });

Mint SNIP721 Token

var mintNftMsg = SecretNET.NFT.MintNftRequest.Create(tokenId: "1");
var mintNft = await snip721Client.Tx.MintNft(
                msg: new SecretNET.NFT.MsgMintNft(mintNftMsg, contractAddress, codeHash), 
                txOptions: new TxOptions() { GasLimit = 200_000 });

Transfer SNIP721 Token

var transferNftMsg = new SecretNET.NFT.TransferNftRequest(recipient, tokenId);
var transferNft = await snip721Client.Tx.TransferNft(
                msg: new SecretNET.NFT.MsgTransferNft(transferNftMsg, contractAddress, codeHash), 
                txOptions: new TxOptions() { GasLimit = 50_000 });

Query Tokens with Permit

var permit = await secretClient.Permit.Sign(
    owner: wallet.Address,
    chainId: secretClient.ChainId,
    permitName: "test",
    allowedContracts: new string[] { contractAddress },
    permissions: new PermissionType[] {
        PermissionType.Owner
    });

var tokens = await snip721Client.Query.GetTokens(contractAddress, wallet.Address, permit: permit, codeHash: codeHash);

Query Tokens with Viewing Key

var txExec = await snip20Client.Tx.SetViewingKey(
                    contractAddress,
                    "hello",
                    txOptions: new TxOptions() { GasLimit = 100_000 });

var tokens = await snip721Client.Query.GetTokens(contractAddress, wallet.Address, viewingKey: "hello", codeHash: codeHash);

Shade.Js

Shade protocol made their own JavaScript SDK to help people interact with specifically their Contracts. It serves as a great example for Contract Interaction or can be forked to make a similar SDK for your own application. https://github.com/securesecrets/shadejs

LocalSecret - Devnet docker

A local, instant, zero-config Secret Network blockchain.

What Is LocalSecret?

LocalSecret is a complete Secret Network testnet and ecosystem containerized with Docker. It simplifies the way secret contract developers test their contracts in a sandbox before they deploy them on a testnet or mainnet.

LocalSecret comes preconfigured with opinionated, sensible defaults for standard testing environments. If other projects mention testing on LocalSecret, they are referring to the settings defined in this repo.

Advantages Of LocalSecret Vs. A Public Testnet

Easily modifiable world states
Quick to reset for rapid iterations
Simple simulations of different scenarios
Controllable validator behavior

Prerequisites

Docker
Supported known architectures: x86_64, amd64

Install LocalSecret

docker pull ghcr.io/scrtlabs/localsecret

Start LocalSecret

docker run -it -p 9091:9091 -p 26657:26657 -p 1317:1317 -p 5000:5000 \
  --name localsecret ghcr.io/scrtlabs/localsecret

Unfortunately, even LocalSecret inside a docker cannot be run on an M1 Mac. This is due to requiring SGX which can only work on x86 processors. As a workaround, we recommend using a LocalSecret instance in a Gitpod environment.

This environment is set up in such a way that can be accessed remotely as well.

To get started, simply click here.

To connect, prepend the port number with the Gitpod URL. e.g., if my workspace is at https://scrtlabs-gitpoddevenv-shqyv12iyrv.ws-eu54.gitpod.io then I would be able to connect to the RPC service at https://26657-scrtlabs-gitpoddevenv-shqyv12iyrv.ws-eu54.gitpod.io

In order to follow the guide, simply replace the localhost endpoint with your own.

e.g., Instead of http://localhost:26657 you will be using https://26657-scrtlabs-gitpoddevenv-shqyv12iyrv.ws-eu54.gitpod.io

In addition, the chain-id for this LocalSecret instance will be secret-testnet-1 and not secretdev-1

You've now officially created a local Secret Network testnet with chain-id secretdev-1. 🎉

Your environment now contains:

Protocol

Endpoint

Usage

RPC

http://localhost:26657

secretcli, Keplr, cosmjs

gRPC-web

http://localhost:9091

secretjs@v1.4 (deprecated)

SCRT Faucet

http://localhost:5000

To get SCRT

LCD

http://localhost:1317

secretjs, Keplr, secretjs@v0.17.5 (deprecated)

You can also use docker run --rm to launch LocalSecret. This will delete the container once you exit the terminal, but it also means that you can't edit the node's config as stopping the container automatically deletes it.

Usage

Here are some examples of how to use LocalSecret with secretcli, secret.js, and Keplr.

Access And Configure Secretcli

To access secretcli from inside the docker container:

docker exec -it localsecret secretcli [command]

To configure & test your local secretcli binary:

secretcli config chain-id secretdev-1
secretcli config node http://localhost:26657
secretcli config output json

SGX_MODE=SW secretcli status

The environment variable SGX_MODE=SW must be applied when using a local secretcli binary.

Faucet (AKA Getting SCRT)

To send some SCRT to the example secret address secret1e6mqxtwgaps7vz3qfa3fcekhh7a02hvfjvtqpt we have to options:

Using The Faucet On Port 5000

ADDRESS="secret1e6mqxtwgaps7vz3qfa3fcekhh7a02hvfjvtqpt"

curl "http://localhost:5000/faucet?address=${ADDRESS}"

The faucet drips 1000 SCRT at a time.

Using A Genesis Account

Inside the docker container there are accounts a, b, c & d that are pre-seeded with SCRT and can be used to send some to your address.

ADDRESS="secret1e6mqxtwgaps7vz3qfa3fcekhh7a02hvfjvtqpt"

docker exec -it localsecret secretd tx bank send a ${ADDRESS} 1000000000uscrt -y

Connect To LocalSecret With secret.js

Connect to the chain through LocalSecret's LCD endpoint.

npm i secretjs or yarn add secretjs, then:

import { SecretNetworkClient } from "secretjs";

const secretjs = new SecretNetworkClient({
  chainId: "secretdev-1",
  url: "http://localhost:1317",
});

Read the full secret.js docs here.

Keplr

To add a custom chain to Keplr, use this code:

await window.keplr.experimentalSuggestChain({
  chainId: "secretdev-1",
  chainName: "LocalSecret",
  rpc: "http://localhost:26657",
  rest: "http://localhost:1317",
  bip44: {
    coinType: 529,
  },
  bech32Config: {
    bech32PrefixAccAddr: "secret",
    bech32PrefixAccPub: "secretpub",
    bech32PrefixValAddr: "secretvaloper",
    bech32PrefixValPub: "secretvaloperpub",
    bech32PrefixConsAddr: "secretvalcons",
    bech32PrefixConsPub: "secretvalconspub",
  },
  currencies: [
    {
      coinDenom: "SCRT",
      coinMinimalDenom: "uscrt",
      coinDecimals: 6,
      coinGeckoId: "secret",
    },
  ],
  feeCurrencies: [
    {
      coinDenom: "SCRT",
      coinMinimalDenom: "uscrt",
      coinDecimals: 6,
      coinGeckoId: "secret",
    },
  ],
  stakeCurrency: {
    coinDenom: "SCRT",
    coinMinimalDenom: "uscrt",
    coinDecimals: 6,
    coinGeckoId: "secret",
  },
  coinType: 529,
  gasPriceStep: {
    low: 0.1,
    average: 0.25,
    high: 1,
  },
  features: ["secretwasm", "stargate", "ibc-transfer", "ibc-go"],
});

Different instances of LocalSecret need to be re-added to Keplr, so you need to first delete the old LocalSecret from Keplr and then re-run this^ code to add the current LocalSecret.

Learn how to connect Keplr with secret.js.

Configure LocalSecret

Modifying Node Configuration

You can modify the node configuration of your validator in the ~/.secretd/config/config.toml and ~/.secretd/config/app.toml files inside the container.

To enter the docker container to access them, run:

docker exec -it localsecret bash

You can then use commands like sed & perl to edit these files, or install text editors like vim & nano using apt install -y vim nano.

Applying The Changes

To apply changes that are made to the config file, restart LocalSecret by running:

docker stop localsecret
docker start -a localsecret

Speed Up Block Time

LocalSecret is often used alongside a script written with the secret.js as a convenient way to do integration tests. You can greatly improve the experience by speeding up the block time.

To decrease block times, run LocalSecret with the FAST_BLOCKS=true environment varibale:

docker run -it -e FAST_BLOCKS=true -p 9091:9091 -p 26657:26657 -p 1317:1317 -p 5000:5000 \
  --name localsecret ghcr.io/scrtlabs/localsecret

To complement this, when testing with secret.js you can lower broadcastCheckIntervalMs to 100 from the default of 6000 (example).

Accounts

LocalSecret is pre-configured with one validator and 4 accounts with SCRT balances. You can import them into your own testing environment for easier prototyping.

Account

Address

Mnemonic

secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450s03

grant rice replace explain federal release fix clever romance raise often wild taxi quarter soccer fiber love must tape steak together observe swap guitar

secret1fc3fzy78ttp0lwuujw7e52rhspxn8uj52zfyne

jelly shadow frog dirt dragon use armed praise universe win jungle close inmate rain oil canvas beauty pioneer chef soccer icon dizzy thunder meadow

secret1ajz54hz8azwuy34qwy9fkjnfcrvf0dzswy0lqq

chair love bleak wonder skirt permit say assist aunt credit roast size obtain minute throw sand usual age smart exact enough room shadow charge

secret1ldjxljw7v4vk6zhyduywh04hpj0jdwxsmrlatf

word twist toast cloth movie predict advance crumble escape whale sail such angry muffin balcony keen move employ cook valve hurt glimpse breeze brick

Smart contract - Tools/Utils

This is a group of tools that help you develop Smart contracts by skipping on boilerplate code.

Secret Toolkit

This Rust package is a collection of sub-packages that contain common tools used in development of Secret Contracts running on the Secret Network.

While the packages in this repository are designed with Secret Network's runtime in mind, some of them may work well with the vanilla CosmWasm libraries and runtimes as well, or only require minimal modifications to be compatible with them.

See usage and docs at: https://github.com/scrtlabs/secret-toolkit

CW-Plus

This is a collection of specification and contracts designed for use on real networks. They are designed not just as examples, but to solve real-world use cases, and to provide a reusable basis to build many custom contracts.

Version by SCRT labs: https://github.com/scrtlabs/cw-plus

Version by Secure Secrets: https://github.com/securesecrets/cw-plus

Rebranded version by Secure Secrets: https://github.com/securesecrets/secret-plus-utils

Warning: Compatibility of with Secret Contracts may be limited due to the missing iterator function

Fadroma - SC framework

Fadroma (built by hack.bg) introduces core workflows for smart contract development and deployment on Cosmos-based platforms, specifically Secret Network! Fadroma helps developers avoid platform specific boilerplate code - automating the repetitive workflow steps by providing essential smart contract building blocks that empower developers to both maintain high development velocity and deliver a reliable product.

Fadroma is currently being developed as an in-house framework facilitating the Sienna Network project. In order to bring Fadroma to a larger developer audience, development hours are being dedicated to improving test coverage, documentation, stabilizing APIs, and ensuring compatibility with a wide range of use cases and underlying platforms.

Get started with Fadroma here: https://github.com/hackbg/fadroma/blob/stable/guide/basic-project-setup.md

Fadroma Features

The following is the list of some of the important initial feature of Fadroma - creating a unique and fluid development experience.

Fadroma Prelude - reexport of platform libraries, with added types for frequently used building blocks:

ContractLink, a data type that contains a contract address and code hash
Humanize and Canonize - traits to convert structures that contain HumanAddr to their CanonicalAddr equivalent and vice versa
ViewingKey and Permit viewing key and permit with custom permissions
Uint256 - 256-bit equivalents of the CosmWasm numeric types, etc.

Fadroma Derive: a derive macro that generates boilerplate code like message definitions and dispatch init/handle/query functions, as well as wasm32 entry points - empowering contract creation out of separate subsystems.

Fadroma Components - implementations of frequently used smart contract functionality:

Fadroma Admin: TX sender-based admin auth
Fadroma VK: viewing key-based auth
Fadroma Permit: query permit-based auth
Fadroma Killswitch: pause or permanently disable contracts
Fadroma Token: A SNIP-20 implementation forked from the reference implementation and rebuilt as a trait.
This allows individual token contract functions to be overriden without having to copy the entire codebase.
Furthermore, it enables token functionality to be added to service contracts, obviating the need for a separate contract to represent the service token.

Fadroma Ensemble: fast integration testing of multiple smart contracts in Rust by mocking the CosmWasm API - useful for testing application logic when it is distributed among several contracts.and having them run instantaneously during development.

Fadroma Ops: Node.js-based operations framework for managing the smart contract lifecycle. Provides a rich vocabulary of classes for modeling your smart contract deployment workflow.

Fadroma Build: compile smart contracts from the working tree or a past point in Git history.
Fadroma Localnet: run a localnet for development,
Fadroma Receipts: keep track of uploads and instantiations. It is possible to update an existing deployment by specifying its id from the receipts and adding additional instances or executing messages all from code.
Fadroma Schema: generate TypeScript definitions from the JSON Schema exported by contracts.
Fadroma Bundle: Execute multiple messages in a single transaction or generate an unsigned transaction for manual multi-signing.
100% test coverage
Docker Compose integration for a portable development environment based on familiar tools.

Fadroma CLI: Command-line entrypoint for creating new projects and running default and custom management commands.

(init) Start a project
(add) Add contracts to it
(compile) Compile them

Hidden Gems

Quick breakdown of additional tools to use for development

There are many tools created by various ecosystem contributors. These tools can be incredibly useful in different situations.

If you have a tool that you think could be added here, let us know on GitHub or Discord!

https://scrthost.xiphiar.com/txdecrypter/
https://snip20history.trivium.network/
https://permits.scrtlabs.com/
https://bech32.scrtlabs.com
https://scrthost.xiphiar.com/
Collection of awesome things related to CosmWasm smart contracts.
https://github.com/scrtlabs/CosmWasm-Simulator - Simulator for CosmWasm transactions. Helpful when trying to debug on-chain behavior
Smart Contract Interface
- Browser interface for smart contracts by btn.group
Panic
- Monitor a validator on the Secret Network with an active telegram bot, email or phone call through Twilio
Secret Contract code verifier
- Tool to verify the WASM public binary of any contract against its source code. Make sure live contracts do what the Git repo says they do.

Other

The following section will detail useful tools for developing Secret Contracts

Secret IDE

The Secret IDE is an all-inclusive environment for developing and deploying smart contracts on Secret Network. It's the best tool to get started with and the best tool to use, even if you're already a pro.

Currently, the Secret IDE is in public beta testing, and you can find all the information you need to get started with it here: https://github.com/digiline-io/Secret-IDE-Plugin

Polar

Polar is development framework for building secret contracts. The aim of the project is to make Secret contracts development process simple, efficient and scalable. User can focus on logic of secret contract and not much about further steps in development. It facilitates features such as initiating project repo from contract templates, easy compilation of contracts, deployment and contract testing framework.

For the full docs see: https://docs.arufaresearch.com/getting-started/

LocalSecret - Devnet docker

A local, instant, zero-config Secret Network blockchain.

What Is LocalSecret?

Advantages Of LocalSecret Vs. A Public Testnet

Easily modifiable world states
Quick to reset for rapid iterations
Simple simulations of different scenarios
Controllable validator behavior

Prerequisites

Docker
Supported known architectures: x86_64, amd64

Install LocalSecret

docker pull ghcr.io/scrtlabs/localsecret

Start LocalSecret

docker run -it -p 9091:9091 -p 26657:26657 -p 1317:1317 -p 5000:5000 \
  --name localsecret ghcr.io/scrtlabs/localsecret

This environment is set up in such a way that can be accessed remotely as well.

To get started, simply click here.

In order to follow the guide, simply replace the localhost endpoint with your own.

e.g., Instead of http://localhost:26657 you will be using https://26657-scrtlabs-gitpoddevenv-shqyv12iyrv.ws-eu54.gitpod.io

In addition, the chain-id for this LocalSecret instance will be secret-testnet-1 and not secretdev-1

You've now officially created a local Secret Network testnet with chain-id secretdev-1. 🎉

Your environment now contains:

Protocol

Endpoint

Usage

RPC

http://localhost:26657

secretcli, Keplr, cosmjs

gRPC-web

http://localhost:9091

secretjs@v1.4 (deprecated)

SCRT Faucet

http://localhost:5000

To get SCRT

LCD

http://localhost:1317

secretjs, Keplr, secretjs@v0.17.5 (deprecated)

Usage

Here are some examples of how to use LocalSecret with secretcli, secret.js, and Keplr.

Access And Configure Secretcli

To access secretcli from inside the docker container:

docker exec -it localsecret secretcli [command]

To configure & test your local secretcli binary:

secretcli config chain-id secretdev-1
secretcli config node http://localhost:26657
secretcli config output json

SGX_MODE=SW secretcli status

The environment variable SGX_MODE=SW must be applied when using a local secretcli binary.

Faucet (AKA Getting SCRT)

To send some SCRT to the example secret address secret1e6mqxtwgaps7vz3qfa3fcekhh7a02hvfjvtqpt we have to options:

Using The Faucet On Port 5000

ADDRESS="secret1e6mqxtwgaps7vz3qfa3fcekhh7a02hvfjvtqpt"

curl "http://localhost:5000/faucet?address=${ADDRESS}"

The faucet drips 1000 SCRT at a time.

Using A Genesis Account

Inside the docker container there are accounts a, b, c & d that are pre-seeded with SCRT and can be used to send some to your address.

ADDRESS="secret1e6mqxtwgaps7vz3qfa3fcekhh7a02hvfjvtqpt"

docker exec -it localsecret secretd tx bank send a ${ADDRESS} 1000000000uscrt -y

Connect To LocalSecret With secret.js

Connect to the chain through LocalSecret's LCD endpoint.

npm i secretjs or yarn add secretjs, then:

import { SecretNetworkClient } from "secretjs";

const secretjs = new SecretNetworkClient({
  chainId: "secretdev-1",
  url: "http://localhost:1317",
});

Read the full secret.js docs here.

Keplr

To add a custom chain to Keplr, use this code:

await window.keplr.experimentalSuggestChain({
  chainId: "secretdev-1",
  chainName: "LocalSecret",
  rpc: "http://localhost:26657",
  rest: "http://localhost:1317",
  bip44: {
    coinType: 529,
  },
  bech32Config: {
    bech32PrefixAccAddr: "secret",
    bech32PrefixAccPub: "secretpub",
    bech32PrefixValAddr: "secretvaloper",
    bech32PrefixValPub: "secretvaloperpub",
    bech32PrefixConsAddr: "secretvalcons",
    bech32PrefixConsPub: "secretvalconspub",
  },
  currencies: [
    {
      coinDenom: "SCRT",
      coinMinimalDenom: "uscrt",
      coinDecimals: 6,
      coinGeckoId: "secret",
    },
  ],
  feeCurrencies: [
    {
      coinDenom: "SCRT",
      coinMinimalDenom: "uscrt",
      coinDecimals: 6,
      coinGeckoId: "secret",
    },
  ],
  stakeCurrency: {
    coinDenom: "SCRT",
    coinMinimalDenom: "uscrt",
    coinDecimals: 6,
    coinGeckoId: "secret",
  },
  coinType: 529,
  gasPriceStep: {
    low: 0.1,
    average: 0.25,
    high: 1,
  },
  features: ["secretwasm", "stargate", "ibc-transfer", "ibc-go"],
});

Different instances of LocalSecret need to be re-added to Keplr, so you need to first delete the old LocalSecret from Keplr and then re-run this^ code to add the current LocalSecret.

Learn how to connect Keplr with secret.js.

Configure LocalSecret

Modifying Node Configuration

You can modify the node configuration of your validator in the ~/.secretd/config/config.toml and ~/.secretd/config/app.toml files inside the container.

To enter the docker container to access them, run:

docker exec -it localsecret bash

You can then use commands like sed & perl to edit these files, or install text editors like vim & nano using apt install -y vim nano.

Applying The Changes

To apply changes that are made to the config file, restart LocalSecret by running:

docker stop localsecret
docker start -a localsecret

Speed Up Block Time

LocalSecret is often used alongside a script written with the secret.js as a convenient way to do integration tests. You can greatly improve the experience by speeding up the block time.

To decrease block times, run LocalSecret with the FAST_BLOCKS=true environment varibale:

docker run -it -e FAST_BLOCKS=true -p 9091:9091 -p 26657:26657 -p 1317:1317 -p 5000:5000 \
  --name localsecret ghcr.io/scrtlabs/localsecret

To complement this, when testing with secret.js you can lower broadcastCheckIntervalMs to 100 from the default of 6000 (example).

Accounts

LocalSecret is pre-configured with one validator and 4 accounts with SCRT balances. You can import them into your own testing environment for easier prototyping.

Account

Address

Mnemonic

secret1ap26qrlp8mcq2pg6r47w43l0y8zkqm8a450s03

grant rice replace explain federal release fix clever romance raise often wild taxi quarter soccer fiber love must tape steak together observe swap guitar

secret1fc3fzy78ttp0lwuujw7e52rhspxn8uj52zfyne

jelly shadow frog dirt dragon use armed praise universe win jungle close inmate rain oil canvas beauty pioneer chef soccer icon dizzy thunder meadow

secret1ajz54hz8azwuy34qwy9fkjnfcrvf0dzswy0lqq

chair love bleak wonder skirt permit say assist aunt credit roast size obtain minute throw sand usual age smart exact enough room shadow charge

secret1ldjxljw7v4vk6zhyduywh04hpj0jdwxsmrlatf

word twist toast cloth movie predict advance crumble escape whale sail such angry muffin balcony keen move employ cook valve hurt glimpse breeze brick