Developer kit and API reference

Build on Dznye Chain: the JavaScript developer kit, how transactions are signed, every transaction type, and every API endpoint, with working examples.

Everything on Dznye Chain is plain HTTP and JSON. Every change is a transaction you sign yourself, so there is no account to register with us and no secret key ever leaves your machine. This page covers the developer kit first, then the details underneath it.

Addresses: the node is https://api.dznye.com (also https://chain.dznye.com/api). The chain is named dznye-1, and its genesis file is at /dznye-1.genesis.json.

The developer kit

One file, a few plain calls. It works in browsers and in Node 24, with no installs.

import { connect, newKey } from 'https://developers.dznye.com/js/chain/sdk.js';   // in Node: './chain/src/sdk.ts'

const dz = connect('https://api.dznye.com', { sponsor: 'https://wallet.dznye.com/sponsor' });
const me = await newKey();                                   // { address, secret }: keep the secret safe

await dz.setName(me, 'my-app');                              // people can now send to @my-app
await dz.send(me, '@alex', '1.5');                           // 1.5 DZY to whoever is @alex
const gold = await dz.makeToken(me, { symbol: 'GOLD', name: 'Game gold', supply: '1000' });
await dz.send(me, '@alex', '10', { asset: gold });           // any token
await dz.trade(me, { give: [gold, '10'], want: ['DZY', '2'] });
const shop = await dz.deploy(me, programJson);               // a contract
await dz.call(me, shop, 'buy', [], { pay: '0.25' });         // call it, sending 0.25 DZY with it
await dz.view(shop, 'sold');                                 // ask it something, free
await dz.events(shop);                                       // what it announced

All the calls

Paying fees for your users

An app can pay the fee for its own users. The user signs naming the app as payer, and the app adds its signature. Both signatures cover the same transaction, so neither can change it.

import { Client } from './chain/src/client.ts';
const c = new Client('https://api.dznye.com');
const tx = await c.prepare(userKey, 'transfer', { asset: tokenId, to, amount: 5 }, { payer: appKey.address });
await c.submit(await Client.sponsor(appKey, tx));

The public welcome fund does this for everyday actions: GET /sponsor returns its address and limits, and POST /sponsor {"tx": …} pays for a transaction that names it as payer. See fees and the welcome fund.

Simulate before you send

Wallets and apps can check any signed transaction first:

POST /simulate   { "tx": { …signed transaction… } }
→ { "ok": true,  "fee": 1000, "gasUsed": 240 }                 it would work
→ { "ok": false, "failed": "only the owner can take it out" }  it would run, then fail (and still cost its gas)
→ { "ok": false, "refused": "not enough balance" }             it is invalid and would be refused (free)

Nothing is sent and nothing changes. It is rate-limited to 120 a minute per address.

How a transaction is signed

If you are not using the kit, this is all there is:

1. Build { chain, from, nonce, type, data }. chain is dznye-1; from is your address; nonce is the nextNonce from GET /account/<address>.
2. Make the message: "dzy-tx:" + canon({ chain, from, nonce, type, data, signer, payer }). canon writes JSON with keys sorted, no spaces, whole numbers only. Leave out fields that are absent.
3. Sign the message with Ed25519 and your secret key. Add the result as sig (hex).
4. POST /tx { "tx": { …, "sig": "…" } }.

The nonce makes every transaction unique, and the chain name inside the signature means a transaction cannot be replayed on another chain. Amounts are whole numbers of the smallest unit (1 DZY = 1,000,000). If a device key (not the first key) signs, add signer with its address; if another account pays the fee, add payer and its signature as payerSig over "dzy-pay:" + message; if the account needs several keys, add their signatures as cosigs.

Transaction types

API reference

Reading

Writing

Limits

• Sending transactions: 60 a minute per address. Reading is open.
• A transaction is at most 2,000 characters (a contract deploy at most 14,000). A validator holds at most 64 waiting transactions per account.
• Browsers on any website may read the API (CORS is open).

Errors you will see

Check the chain yourself

Everything above can be verified: download the blocks and replay them. See run a node.