An open-source terminal wallet for the CREDITS network that runs next to a node, on Linux, Windows and macOS: keys kept on the machine, transfers, delegations, and smart contracts compiled, deployed and called through the local node. No browser, no web server, no open ports.
Status: milestone 4: accounts, key store, the node's own key as the account of a node's wallet, status, balances, transfers with optional user data, delegations, tokens (every token held with its contract address, also without the node's token cache; info, transfers), the history from the local node or a remote full node with the token transfers and a CSV export, smart contracts (templates, compile, deploy, methods, getters, calls, payments, the contract list), the network identity of community nodes, the terminal interface and the scriptable commands; reproducible release archives, shipped in the community node packages from release community.17 on. What is left for later: docs/spec.md §10.
User guide: docs/guide.md (in Italian: docs/guide.it.md).
Part of the CreditsCommunity projects, next to the community node.
- With the community node: every package from release community.17 on has
credits-wallet(credits-wallet.exeon Windows) in itscsnodefolder, next to the node, with this guide aswallet-guide.md; the Docker image has it on thePATH. Next to its node the wallet uses the node's own key as the accountnode(below); the node's set-up offers it, or makes the node's key from a 24-word phrase when the node has none yet. - On its own: the releases have an
archive for Linux x86-64 (static), Windows x64 and macOS Apple Silicon, and
SHA256SUMS.
See the guide.
Needs Go 1.26 or later (go.mod names the toolchain, go1.27.4, which go fetches by itself) and the Thrift compiler 0.19.0 as thrift on the PATH
(sudo apt install thrift-compiler on Ubuntu 24.04; it must match github.com/apache/thrift v0.19.0
in go.mod).
git clone --recurse-submodules https://github.com/CreditsCommunity/wallet.git
cd wallet
go generate ./thrift # Go code of the node API, from the IDL submodule (not committed)
go build -o credits-wallet ./cmd/credits-wallet
go test ./...The node API's definitions are the git submodule third-party/thrift-interface-definitions
(CreditsCommunity/thrift-interface-definitions, branch community/network-id, the commit the
community node pins: the original definitions plus the two optional network-identity fields of the
diagnostic API); after a plain clone run git submodule update --init (an older clone: git submodule sync first, the URL changed). Cross-compiling needs no C compiler:
CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build ./cmd/credits-wallet.
The offline transfer test runs the node's fake node (testdata/fake_node.py) and needs python3
with the packages of testdata/requirements.txt (pinned with hashes:
pip install --require-hashes -r testdata/requirements.txt in a venv); without them it is skipped.
./credits-wallet # the terminal interface
./credits-wallet status # the node: last block, round, synced, network
./credits-wallet account new main # a new account: write down its 24 words
./credits-wallet account import old ~/keys.json # then delete the plain file
./credits-wallet --config wallet.toml account list # in csnode: the node's key is the account "node"
./credits-wallet account node-key new # the node has no key yet: make it from 24 words
./credits-wallet account export main --format node --out csnode # an account's key as the node's
./credits-wallet balance # every account
./credits-wallet history main --csv main.csv
./credits-wallet send main u6PJ8DtQuPFnfmwHbGFULQ4u4EgjDiyYKjVEsynXq2w 12.5 # SPENDS REAL CS ON MAINNET
./credits-wallet send main u6PJ8D…q2w 12.5 --data "invoice 42" # with user data (public)
./credits-wallet delegate main NODE_ADDRESS 1000 # delegate, no time limit
./credits-wallet delegate main NODE_ADDRESS 500 --until 2027-01-31 # until a UTC date
./credits-wallet undelegate main NODE_ADDRESS 1000 # withdraw (no-limit delegations)
./credits-wallet delegations main # made and received
./credits-wallet tokens main # token balances
./credits-wallet token send main TOKEN_ADDRESS u6PJ8D…q2w 250.5 # a call of the token's transfer()
./credits-wallet history main --tokens # token transfers
./credits-wallet contract new Counter Counter.java # a template
./credits-wallet contract compile Counter.java # errors with their line
./credits-wallet contract deploy main Counter.java # SPENDS CS ON MAINNET
./credits-wallet contract methods CONTRACT # types, getters
./credits-wallet contract get CONTRACT getValue # free, changes nothing
./credits-wallet contract call main CONTRACT add 4 # a signed call
./credits-wallet contract pay main CONTRACT 3 --data "thanks" # CS to its payable()
./credits-wallet contract list main
./credits-wallet backup export /media/usb/wallet.dat # every account, under the wallet password
./credits-wallet backup import /media/usb/wallet.dat # its wallet's password, lists, restores
./credits-wallet wallet migrate # a wallet from before: one password
./credits-wallet wallet password # change the wallet password
./credits-wallet helpGlobal flags, anywhere on the line: --node HOST:PORT, --profile NAME, --config FILE, --json,
--password-file FILE, --history-node HOST:PORT.
One password for the whole wallet. The wallet password, chosen with the first account, opens
every account: the interface asks it once, each command once. The node's key is the exception: a
plain NodePrivate.txt needs no password, and a key the node encrypted keeps the node's own
password. A wallet from before (a password per account) asks at its first start to choose the
wallet password, which may be one of the accounts' passwords, and each other account's password
once (wallet migrate on the command line); an account whose password you do not have stays as it
is ("old password") and can be moved later (M). wallet password (or P) changes it.
The terminal interface opens locked: it lists the accounts' names and addresses only, and the
wallet password unlocks the wallet and the chosen account (nothing of an account is shown before).
Signing in the session asks no password again (on mainnet you still type send on the full
review); [l] locks the wallet, [a] switches account (no password while the wallet is open), and
the wallet locks by itself (the open wallet too, with no account unlocked) after
lock_after_minutes without a key press (top of config.toml, default 10; 0 never locks, so
anyone at the terminal could open any account and sign). The account locks after another
is created or imported. The commands ask the wallet password once, when they sign.
In the terminal interface: [s] send (with an optional Data field), [d] delegations (n delegate,
w withdraw the selected one), [t] tokens (s send the selected token, a a token by its
address), [h] history (t token transfers, e CSV export), [c] contracts (o open a .java,
n new from a template, a a contract by address; on a source e edits it in your editor, d
deploys; on a contract Enter reads a getter or signs a call, g get, c call), [S] node status,
[b] backup (also on the unlock screen: e export, i import), [P] change the wallet password,
[M] move the accounts with an old password under the wallet password.
- Run a node with its API on (
[api] port=9090in itsconfig.ini, the default); the wallet talks to127.0.0.1:9090. credits-wallet statusmust saysynced: yes; the wallet refuses to send otherwise.- Create an account (
account new NAME, or[n]in the interface: the first one also chooses the wallet password, typed twice) and write its 24 words on paper: they are shown once on the terminal (never in the output,--jsonincluded), you type three of them back, and they restore the account (account import NAMEand type them). The screen is cleared afterwards, but a terminal's scrollback, tmux/screen or a session log may keep them. After the check the wallet asks whether to save the words to a file as well (default no): the file goes to~/credits-recovery-NAME.txtor a path you type, never in the data folder or a folder holding key files (the words beside the encrypted keys would make the password useless), mode 600, never overwriting; copy it to paper or an offline USB key and delete it from the computer. Without a terminal (scripts)account newneeds--words-file FILE(a new file, mode 600) or--show-words(the words in the output). Or import an existing key: a base58 key, the keys JSON of the official web and desktop wallets (delete the plain file afterwards), or a 24-word phrase. Next to a node, the node's own key is already an account (see "The node's key" below): no import needed, and never delete the node'sNodePrivate.txt(the node needs it).yin the interface copies the account's address (OSC 52, over SSH too; it is also shown whole on its own line for Shift+drag), andaccount address NAMEprints it alone forxclip,pbcopyorclip. - Send: paste the recipient with the terminal's paste (Ctrl+Shift+V, right click): it is trimmed,
a leading
credits:is dropped, anything but an address is refused, and the address is shown with its first and last 6 characters highlighted to compare with the source. The review shows the recipient, the amount and the fee; on mainnet it asks you to typesend(the commands then ask the password; the interface asked it when you unlocked the account).
- Data folder:
~/.credits-wallet(Linux, macOS),%APPDATA%\credits-wallet(Windows), or$CREDITS_WALLET_HOME. Key files are inaccounts/, one per account, mode 600. - The wallet password opens
accounts/wallet.key, a random master key sealed with Argon2id (3 passes, 256 MiB, 4 threads, a random salt) and XChaCha20-Poly1305; the master key encrypts each account file (XChaCha20-Poly1305, a random nonce each). One derivation opens the whole wallet.wallet.keyis needed by every account: it is in every backup. Lost or replaced, the accounts are listed as orphaned and nothing new is created untilbackup importputs them back (the orphaned files are kept inaccounts/.orphaned/). There is no way to recover a forgotten password: keep the 24 words. Format, migration and change of password: docs/spec.md 4.2. account import NAME FILEalso takes an encrypted key file (another wallet's export): its own password opens it, then it goes under the wallet password.account export NAMEwrites the key as an encrypted file of its own, under the wallet password by default or another one you type (--out FILE);--format base58prints the secret key after the wallet password;--format officialwrites the official wallets' unencrypted keys JSON, with a warning.backup export FILE.dat(bthenein the interface) writes every account into one file: the account files andwallet.key, the names and the local token and contract lists, all encrypted with the wallet password (Argon2id with the key files' parameters and its own salt, XChaCha20-Poly1305, the versioned header as associated data). The backup is only as strong as the wallet password, and a change of the wallet password does not re-encrypt backups already made: they keep opening with the old password. Never the node's key (NodePrivate.txtstays in the node's folder) norconfig.toml. A new file, mode 600, never in the data folder or next to key files: keep it off the computer, on a USB key.backup import FILE.dat(btheni) asks the password of the wallet the backup comes from, lists the accounts and restores them once confirmed, under this wallet's password (asked once if it differs;--wallet-password-filefor scripts): an address already in the wallet is skipped, a name taken by another address gets a new name (asked, or--rename-suffix S). Format: docs/spec.md 4.5.
Next to its node the wallet is the node's wallet: it uses the node's own key pair, in place, as
the account node, listed first, the default, and marked NODE KEY. That is always an explicit
choice: the package's csnode/wallet.toml (whose profile says node_key = "NodePrivate.txt" when the set-up was told to use the node's key),
node_key in a node profile of config.toml, --node-key FILE, or the node's Docker image
(CREDITS_WALLET_NODE_KEY); never a guess from the current folder, where someone could have
planted a key pair. The key file and its folder must be yours (or root's) and writable by nobody
else, and the wallet says the account's address and file the first time it reads it. The node's rewards and the delegations it receives go to that address,
and operators usually keep their stake there.
NodePrivate.txtis read where the node reads it: never copied into the key store, never encrypted by the wallet (the node needs its file), no password asked to sign with a plain key.node_key = "off"turns it off.- A key the node encrypted (
--encryptkey, or "[1] Encrypt with password" at the node's first start) is opened with the node's password: on the interface's unlock screen, or when a command signs. The wallet implements the node's format (Argon2id 1 GiB with the node's fixed salt, original ChaCha20-Poly1305; docs/spec.md 4.3), checks the key againstNodePublic.txt, and never writes the opened key anywhere or exports it in clear. - A key in the current folder is never used by itself. The interface, started in a folder with
NodePrivate.txtand no node's key configured, shows its address and path and offers: use it for this session, use it and remember it (node_keywritten into the active profile ofconfig.toml, comments and other settings kept), ignore it, or ignore it for good. The commands print a one-line hint (--node-key NodePrivate.txt) and never use it. - The node's key is kept in clear on the server, because the node needs it: CS on it are as
exposed as the server. Keep on it only what the node needs, and savings in a separate account
(
account new). - No key yet:
account node-key new(orgin the interface) makes it from a new 24-word phrase, shown and checked as foraccount new, and writesNodePrivate.txtandNodePublic.txtin the node's folder, in exactly the node's format (mode 600, never over an existing file, never through a link, refused while the node runs): the node uses it at its first start, and its identity has a paper backup. The recovery file never goes in the node's folder. - An account's key as the node's:
account export NAME --format node --out CSNODE_FOLDERwrites it in the node's format; it never overwrites the node's key.--replacereplaces the node's identity (the node stopped; the old files kept asNodePrivate.txt.bak-DATEandNodePublic.txt.bak-DATE, mode 600). The node's identity follows its key: its address, the delegations it received, its history as a trusted node and its rewards. account import NAME NodePrivate.txtstill makes an encrypted copy in the key store, but the original stays in clear for the node, so the copy protects nothing more.account node-keyshows the key's file, its address, whetherNodePublic.txtmatches, whether the node is running and the.bak-*backups (old keys in clear: move them offline, then delete them);account node-key repairwrites a missing or mismatchingNodePublic.txt(the node stopped). A key file other users can read is used with a warning:chmod 600 NodePrivate.txt.
The wallet assumes mainnet unless the configuration declares the node a test or private
network; mainnet is shown in red and asks for the full confirmation. credits-wallet config prints
an example config.toml (put it in the data folder):
node = "local"
[nodes.local]
address = "127.0.0.1:9090"
network = "mainnet" # or "testnet", "private"--node with an address that no profile declares is treated as mainnet.
Use separate accounts for test networks. A signed transaction does not say which network it is for: one signed on a test network can be replayed on mainnet by whoever runs or watches that test node, if the account exists there (every key does) with the same next inner id. Never use an account that holds CS on mainnet on another network.
A community node from release community.17 on tells its network through its diagnostic API
([api] diag_port in its config.ini, 9088 in the release packages). The wallet asks it
(diag = "HOST:PORT" in the profile, by default the node's host with port 9088, diag = "off" not
to ask) and refuses to send when the node is on mainnet and the profile says testnet or private,
or the other way round (a profile without network counts as mainnet: declare a test network). A
profile can also pin the network: network_uuid = "…" (the uuid status shows), and
require_network_uuid = true sends only when the node confirms its network. An official node or
an older release does not tell its network: the configuration decides (but a pinned or required
uuid then refuses). Every confirmation says whether the node confirmed the network; status shows
what the node says.
send --yes skips the question, for scripts only; without a terminal the wallet refuses to send
without it. --password-file FILE reads the password from the first line of FILE: the password is
then on disk in clear, so the wallet refuses the file unless it is chmod 600 (Linux, macOS); keep
it on an encrypted disk, and use it only where unattended sending is really needed. --json
prints machine-readable results (and errors). history --csv FILE never replaces an existing
file unless --force is given.
delegate ACCOUNT NODE AMOUNT delegates at least 5 CS to a node without a time limit, or with
--until DATE until that UTC date (2027-01-31, "2027-01-31 18:00", or RFC 3339 with an offset);
the nodes release a delegation with a time limit by themselves once it expires. undelegate withdraws
CS from a delegation without a time limit (at most its amount, at least 5 CS). delegations lists
what an account delegated and received, with the expiry. On mainnet each asks for the same
confirmation as send.
send … --data TEXT attaches a text (UTF-8, at most 4096 bytes, no control characters but newline
and tab) to a transfer. It is public: anyone can read it on the chain. The history shows it, and
the CSV has it in its data column (a text that starts like a spreadsheet formula gets a ' in
front).
tokens ACCOUNT (and [t] in the interface) lists every token the account holds, each with its full
contract address, decimals and balance, and the look-alike warnings; the main screen shows the
balances and the count. The list comes from the node's token cache (tokens_cache=true in the
[api] section of its config.ini, off by default), plus the tokens of the local token list (below)
that the cache does not name: a cache turned on after the node pruned, or on a node started from a
snapshot, knows every token but may miss holders whose last use of a token is older than the
node's oldest block. Without it the wallet uses the token cache of
the profile's history_node (balances still from the local node), or else finds the tokens in the
account's history (the latest 1000 transactions on the history node and the local node: the
contracts it called, deployed, paid or sent tokens of) and in its local token list
(tokens/<address>.json in the data folder: the tokens you added with token add or sent with the
wallet, nothing else), and reads each balance from the contract (balanceOf, free). A token the
account only received is marked "received from ADDRESS: not added by you". Such a list is labelled "found
from history (may be incomplete on a pruned node)": tokens received from others are not in the
account's own history. token add ACCOUNT TOKEN keeps a token listed (0 included), token remove
takes it off. In the interface y copies the selected address (OSC 52), a adds a token, x removes it. token balance TOKEN ACCOUNT reads one balance from the token contract. token info TOKEN shows code, name and
decimals (and supply and holders with the cache). token send ACCOUNT TOKEN TO AMOUNT signs a call of
the token's transfer(to, amount): the amount may have at most the token's decimals and must be
within the token balance; the CS balance must cover the signed max fee (1 CS), which the node holds
while the call runs, and the fee is about 0.0175 CS plus the execution. A token is identified only by
its contract address: anyone can deploy a token that calls itself "CS" or copies another token's
code. The confirmation shows the full address and warns about such look-alikes; check the address.
Contracts are Java classes compiled by the node's contract executor (see the node's
samples/contracts).
contract templates lists the examples the wallet carries (the node's samples: Counter, TestToken,
Token, TipJar, Faucet); contract new NAME FILE writes one. contract compile FILE asks the node to
compile it and lists the errors as FILE:LINE: message, or the classes and methods.
contract deploy ACCOUNT FILE compiles again, shows the review (the contract's address, derived
from the account, the inner id and the byte code; the fee, about 0.1 CS for a small contract; the
signed max fee, 1 CS) and, on mainnet, asks you to type send and the password. Once the deploy is
in a block the wallet waits until the node lists the contract and saves it in the account's local
contract list (contracts/ in the data folder: public data only). Sources up to 48 KiB, deploys
below 50 KiB (larger ones cost 17.87 CS).
contract methods CONTRACT lists the methods with their types (the node does not tell which ones
only read: its API drops the contracts' @Getter annotations; methods are marked "getter" only by
a node that passes them on). contract get CONTRACT METHOD ARGS… runs a method without a transaction: free,
nothing is kept (--from ACCOUNT sets the caller the contract sees). contract call ACCOUNT CONTRACT METHOD ARGS… signs a call, about 0.0175 CS plus the execution; the arguments are converted
to the types the method declares (put -- before an argument that starts with -), and the result
and the contract's state are shown. In the terminal interface the review lists every argument in
full; when it is taller than the screen, scroll it to the end (PgDn) before signing. A method that throws is refused by the node; the fee is paid.
contract pay ACCOUNT CONTRACT AMOUNT [--data TEXT] sends CS to a contract: the node runs its
payable(), which may refuse them (they come back, the fee is paid). contract info CONTRACT shows
the deployer and the state (the public fields: the node shows no others); contract list ACCOUNT the contracts the account deployed (the node's
list and the local one). Everything a contract says about itself (names, results, state) is shown
escaped.
A pruned node keeps only its latest blocks. The wallet says from which block the node's history starts ("history from block N") and how many transactions the account has in all; older ones are on full nodes. A node profile can read its history from a remote full node:
[nodes.local]
address = "127.0.0.1:9090"
history_node = "203.0.113.7:9090" # read-only: history and token transfers, never used to sendor --history-node HOST:PORT on the line (--history-node local for the node itself). That node
receives the account's public address only; every history output names the source it comes from.
history --csv FILE writes the CS transactions and the token transfers in one table.
- What the wallet protects: keys at rest (encrypted key files, mode 600 in a folder of mode
700; the wallet warns when the data folder or
accounts/is open to other users), keys in use (decrypted only to sign, then overwritten; in the interface, held locked for the unlocked session only), and the user against mistakes (mainnet assumed, explicit confirmation, the signed max fee shown, refusal while the node is not synced). - What it cannot protect against: malware or another user with access to your account on this machine (they can read the terminal, replace the binary, or swap a key file for one of their own, so that what you receive goes to them); a forgotten password (keep the 24 words).
- Memory: Go cannot guarantee that secrets are wiped. The wallet zeroes the byte slices it
controls; the interface keeps the unlocked key in memory of its own, locked against swapping, out
of core dumps and inaccessible between signatures, zeroed on lock and exit (it says so when the
system refuses the lock). Copies may remain: the TUI's text inputs hold passwords and pasted keys
as immutable strings,
crypto/ed25519keeps the expanded key it signs with on the heap without zeroing it, Argon2id's working memory is freed and not wiped, and a core dump or swap may hold any of them. Disable core dumps and use encrypted swap on machines holding funds. - The node: the wallet trusts the node it talks to for balances, fees, inner ids, sync state and history, but never sends it a secret; see docs/spec.md, "Trust in the node".
- Windows: the wallet does not set ACLs itself.
%APPDATA%\credits-walletis private to the user by default; withCREDITS_WALLET_HOMEoutside the user's profile the wallet warns, and the folder's permissions are yours to check (Properties > Security).
go test ./...: the node's key files byte for byte as the node writes them (withNODE_KEY_CHECKset tointernal/keys/testdata/node-key-check.cppbuilt against the node, read by the node's own code), the node's encrypted key files (testdata/node-encrypted-vectors.json, encrypted and opened by the node's code; withNODE_KEY_CRYPTset tointernal/keys/testdata/node-key-crypt.cppbuilt the same way, a round trip both ways), the unlock screen, the session and its locks, the wallet password (one password, the migration and the change of password, each interrupted at every step and resumed, the import and export of a single key, the node key's exception), the found-key prompt, the backup file (round trip, wrong password, damaged and truncated files, refused places, existing addresses and name clashes, the interface's flow), signing (byte-identical to the node's samples, and for user data, delegations, token calls, deploys and contract addresses totestdata/sign-vectors.txt, made bytestdata/sign-vectors.pythe way the node'sci/testnet/fund.py,samples/python/token_client.pyandsamples/clients/python/credits_client.pybuild them), key store, amounts, the network-identity rules, the commands againsttestdata/fake_node.py(contracts and its diag API included), the screens at 80x24..github/workflows/ci.yml: vet, govulncheck, the tests, the four cross-compiled builds..github/workflows/release.yml: the release archives (below); on pull requests it only builds..github/workflows/privnet.yml(pull requests to main, on demand):ci/privnet/e2e.shstarts a private network of 5 community nodes with their contract executors and runs the wallet's commands end to end: the last node started with a key the wallet made (account node-key new), the node's key as an account (a send signed without a password, the refusals while a node runs), the export to the node's format with--replace(that node started again with the exported key), transfers, delegations, history, the network identity, and the contracts deployed, called and paid with the wallet (TestToken, Counter, TipJar). The executor comes from the community release package pinned in the workflow (tag, commit and package SHA-256, bumped deliberately); the node is the release commit built with-DCREDITS_TESTNET=ON(the package's node is a mainnet build, which cannot fund a private network), cached per release, so only the first run after a release builds it. Locally:NODE_BIN=… PKG=…/csnode NODE_FILES=… IDL=third-party/thrift-interface-definitions WALLET=./credits-wallet ci/privnet/e2e.sh(see the script's header).
A tag wallet-vX.Y.Z (on main) publishes a release; wallet-vX.Y.Z-rcN a pre-release, from any
branch. .github/workflows/release.yml cross-compiles linux-amd64, windows-amd64 and darwin-arm64
on one Linux runner with CGO off (ci/release/build.sh), runs each binary on its own system
(version must print the tag's version), builds the tag again on a second runner (the same
SHA256SUMS or nothing is published), then publishes the archives and SHA256SUMS. Only the push
of a tag publishes. Each archive
holds credits-wallet-X.Y.Z/ with the binary, README.md, LICENSE, guide.md and guide.it.md.
The build is reproducible: -trimpath -buildvcs=true (the commit is recorded, go version -m credits-wallet), fixed ldflags (-s -w -buildid= -X main.version=X.Y.Z), every archived file dated
at the commit's time, owned by 0:0, in name order. To check a release:
git checkout wallet-v0.1.0 && git submodule update --init
go generate ./thrift # Thrift 0.19.0
ci/release/build.sh 0.1.0 dist # Go 1.27.4 (go.mod's toolchain)
diff dist/SHA256SUMS <(curl -sSL https://github.com/CreditsCommunity/wallet/releases/download/wallet-v0.1.0/SHA256SUMS)The community node pins the release it ships in packaging/wallet-tag and the archives' hashes in
packaging/wallet-sha256: release a wallet tag first, then bump both files, then release the node.
Right after the repository goes public, protect the release tags with a ruleset (no deletion, no update; rulesets are not available on this private repository):
gh api -X POST repos/CreditsCommunity/wallet/rulesets --input - <<'EOF'
{"name": "release tags", "target": "tag", "enforcement": "active",
"conditions": {"ref_name": {"include": ["refs/tags/wallet-v*"], "exclude": []}},
"rules": [{"type": "deletion"}, {"type": "update"}, {"type": "non_fast_forward"}]}
EOFAGPL-3.0, as the node. testdata/fake_node.py, testdata/sign-expected.txt and
testdata/test-key.txt come from the community node's samples/clients/testdata;
testdata/sign-vectors.py follows the node's ci/testnet/fund.py, samples/python/token_client.py and
samples/clients/python/credits_client.py; the contract templates in internal/templates/java are the
node's samples/contracts (commit 079e788d), unchanged;
ci/privnet/e2e.sh is a subset of the node's ci/testnet/run.sh; the contract-call and argument
code of internal/tx comes from the node's samples/clients/go. The keys in
testdata/ and internal/keys/testdata/ are public test values: never send funds to them.