zanolib

zanolib

Go library for Zano cryptocurrency operations, including address parsing, offline transaction signing, and zero-knowledge proof generation.

Features

• Address handling — parse, create, and manipulate Zano addresses (standard, integrated, auditable)
• Offline transaction signing — sign transactions generated by a view-only simplewallet without exposing the spend key to the network
• Deposit scanning — detect incoming outputs for a wallet directly from a Zano daemon's JSON-RPC, decode amounts/assets, and recover integrated-address payment IDs (view key only)
• Sending — build, sign and broadcast transactions from scanned deposits (decoy ring selection, multi-asset, fee handling) entirely from the library
• Cryptographic primitives — CLSAG-GGX ring signatures, Bulletproof+ range proofs, BGE asset surjection proofs, balance proofs
• Serialization — full EPEE binary serialization compatible with Zano's C++ implementation

Install

go get github.com/KarpelesLab/zanolib

Offline Signatures

Compatible Zano version: 2.1.0.382 – 2.1.19.477 (the ZC→ZC transaction format is unchanged across this range)

This library allows loading unsigned transactions produced by a view-only simplewallet and signing them offline. There are a few caveats:

• The unsigned transaction is a binary format not meant to be portable — it only works between specific versions of Zano. This library is tested against the versions above and may not work with newer versions. Blob files aren't versioned so structure changes cannot be detected automatically.
• For now this library only supports ZC→ZC transactions.

Usage

import (
	"crypto/rand"
	"os"

	"github.com/KarpelesLab/zanolib"
)

// Initialize a wallet from a securely stored spend secret.
// Set flags to 1 for auditable wallets.
wallet, err := zanolib.LoadSpendSecret(secret, 0)
if err != nil {
	// handle error
}

// Parse the unsigned transaction produced by simplewallet.
ftp, err := wallet.ParseFTP(unsignedTxBlob)
if err != nil {
	// handle error
}

// Inspect ftp to verify this is the transaction you want to sign.
// ...

// Sign the transaction.
finalized, err := wallet.Sign(rand.Reader, ftp, nil)
if err != nil {
	// handle error
}

// Encrypt and write to disk for broadcast via the view-only wallet.
signed, err := wallet.Encrypt(finalized)
if err != nil {
	// handle error
}
os.WriteFile("zano_tx_signed", signed, 0600)

Deposit Scanning

zanolib can scan the chain for outputs paid to a wallet without running a local daemon — it fetches raw transactions over JSON-RPC from any Zano node and detects/decodes received outputs locally using only the view secret key. The caller stores each watched address together with the last block height it scanned, then resumes from there.

Wallet.ScanTx is the pure, offline core (it takes a parsed transaction and returns the owned outputs plus the decrypted payment ID). The zanorpc package adds a JSON-RPC client and a Scanner driver that walks confirmed block ranges.

import (
	"context"

	"github.com/KarpelesLab/zanolib"
	"github.com/KarpelesLab/zanolib/zanorpc"
)

// A view-only wallet is enough to detect deposits.
wallet, _ := zanolib.LoadSpendSecret(secret, 0)

scanner := zanorpc.NewScanner(wallet, "") // "" = public modchain gateway; or pass a daemon base URL like "http://127.0.0.1:11211"

// Resume from the last height you persisted, up to the current confirmed tip.
last, err := scanner.ScanRange(context.Background(), fromHeight, toHeight, func(d zanorpc.Deposit) error {
	// d.Out.Amount, d.Out.AssetId, d.Out.IsNative — what was received
	// d.PaymentId — integrated-address payment id (attributes the deposit to a user)
	// d.TxId, d.Height, d.GlobalIndex — where it landed (GlobalIndex lets you spend it later)
	creditUser(d)
	return nil
})
// persist `last` as the new watermark; on restart re-scan a small tail to absorb reorgs

Notes:

• Attribution: give each user a distinct integrated address; d.PaymentId maps a deposit back to the user. Per-wallet addresses work too (then payment IDs are simply absent).
• Assets: native ZANO and confidential assets are both decoded; d.Out.AssetId / d.Out.IsNative identify which.
• Confirmations / reorgs: scan only finalized heights and re-scan a small tail on restart. Mempool (0-conf) scanning and spent/key-image tracking are not included.

Sending

With a full wallet (spend secret), the library can build, sign and broadcast a transaction that spends scanned deposits — including decoy ring selection (via getrandom_outs3.bin), multi-asset transfers, and fee handling. zanorpc.Client.SweepTo sends a set of deposits to a recipient, deducting the fee from the native amount:

import (
	"context"

	"github.com/KarpelesLab/zanolib"
	"github.com/KarpelesLab/zanolib/zanorpc"
)

wallet, _ := zanolib.LoadSpendSecret(secret, 0) // full wallet (can sign)
client := zanorpc.New("") // "" = modchain gateway; or a daemon base URL

// deposits: a []*zanorpc.Deposit gathered from scanning (see Deposit Scanning)
signed, raw, status, err := client.SweepTo(
	context.Background(), wallet, deposits,
	"Zx...recipient...", // destination address
	10_000_000_000,      // fee in native atomic units (0.01 ZANO)
	true,                // broadcast
)
// status == "OK" once accepted into the mempool

For finer control, Wallet.BuildTransfer assembles and signs an arbitrary set of TransferInputs and TransferDests (you supply the decoy rings), returning a ready-to-serialize transaction. Native ZANO and confidential assets can be mixed in a single transaction; the fee is the native surplus and every non-native asset must balance.

License

See LICENSE file.