VELR Public Minter

A secure, open-source public minting client for Velorium (VELR) on the Arkovia Proof-of-Stake blockchain.

VELR Public Minter is designed to allow participants to contribute computing power to the VELR minting process and earn newly minted VELR when they successfully produce a valid mint.

The project is built around one non-negotiable security principle:

Your Arkovia secret phrase should never leave your computer.

The minter performs hashing, account derivation, transaction verification, and transaction signing locally. An Arkovia node is used for public blockchain information, minting targets, unsigned transaction construction, and broadcasting already-signed transactions.

What Is Velorium?

Velorium (VELR) is a community-focused digital currency issued on the Arkovia Proof-of-Stake blockchain.

It is designed for virtual worlds, creators, communities, and digital economies, with an emphasis on open participation, ownership, and digital commerce.

VELR is implemented using Arkovia's Monetary System.

VELR Network Parameters

Property	Value
Name	Velorium
Code	VELR
Currency ID	`4450275230012573494`
Type	Exchangeable + Mintable
Type Value	`17`
Algorithm	SHA-256
Algorithm ID	`2`
Decimals	`2`
Initial Supply	`5,000,000,000 VELR`
Maximum Supply	`25,000,000,000 VELR`
Minimum Difficulty	`1`
Maximum Difficulty	`10`

Because VELR uses two decimal places:

100 QNT = 1.00 VELR
1 QNT   = 0.01 VELR

VELR is a Monetary System currency. VELR balances therefore reside inside normal Arkovia accounts using the ARK-... account format.

There is no separate VELR-... account namespace.

What Is Arkovia?

Arkovia is the blockchain network on which VELR is issued.

Its native network currency is ARKOS.

ARKOS provides the underlying economic infrastructure for transactions, fees, accounts, assets, Monetary System currencies, and other network activity.

Arkovia uses Proof-of-Stake for blockchain consensus.

VELR minting is therefore not blockchain mining and does not secure Arkovia.

VELR minting is a Monetary System distribution mechanism used to create additional VELR according to the rules encoded in the currency.

ARKOS Units

1 ARKOS = 100,000,000 NQT
1 NQT   = 0.00000001 ARKOS

Important Distinction: Minting vs. Forging

VELR minting should not be confused with Arkovia block forging.

Arkovia Forging

Arkovia uses Proof-of-Stake to:

produce blocks,
validate network activity,
maintain blockchain consensus,
and secure the network.

VELR Minting

VELR minting:

calculates SHA-256 hashes,
searches for hashes meeting the current VELR target,
creates valid Monetary System currencyMint transactions,
increases VELR's circulating supply,
and distributes newly minted VELR to successful minters.

Minting VELR does not provide Proof-of-Work security to Arkovia.

Project Goals

VELR Public Minter is being developed to provide a secure and approachable way for ordinary users to participate in VELR distribution.

The project is intended to eventually provide:

local VELR hashing,
automatic mint target retrieval,
secure local account derivation,
secure local transaction signing,
unsigned transaction verification,
signed transaction broadcasting,
configurable mint amounts,
hash-rate reporting,
accepted/rejected mint statistics,
VELR balance display,
ARKOS fee balance display,
supply statistics,
difficulty information,
automatic counter management,
start/stop controls,
desktop application packaging,
and user-friendly mining/minting status information.

The initial implementation is a Node.js command-line prototype.

Security Architecture

The security architecture is intentionally designed so the Arkovia secret phrase does not need to be transmitted to a remote server.

The intended flow is:

Arkovia Node
     |
     | Public blockchain information
     | Minting target
     v
VELR Public Minter
     |
     | Local SHA-256 hashing
     v
Valid Nonce Found
     |
     v
Arkovia Node
     |
     | Unsigned transaction only
     v
VELR Public Minter
     |
     | Independently verify transaction bytes
     | Sign transaction locally
     | Verify signature locally
     v
Signed Transaction
     |
     v
Arkovia Node
     |
     | Broadcast signed transaction
     v
Arkovia Blockchain

The secret phrase remains on the user's machine.

Secret Phrase Security

The VELR Public Minter must never intentionally transmit an Arkovia secret phrase to:

an Arkovia node,
a website,
Base44,
GitHub,
analytics services,
telemetry services,
error reporting services,
logging services,
remote APIs,
or any other third party.

Secret phrases must never be stored in:

source code,
Git repositories,
command-line arguments,
URLs,
browser history,
application logs,
debug output,
crash reports,
analytics events,
localStorage,
public configuration files,
or distributed .env files.

Public keys are not secret and may safely be sent to an Arkovia node when required.

Local Account Resolution

The public minter derives the user's Arkovia public key locally from their secret phrase.

Only the public key is sent to the Arkovia node.

The node's getAccountId API can then return:

Public Key
     |
     v
Numeric Arkovia Account ID
     +
ARK-... Reed-Solomon Address

This allows the minter to determine the account required for minting calculations without transmitting the secret phrase.

VELR Minting Algorithm

VELR currently uses:

SHA-256

Algorithm ID:

A VELR mint hash is calculated from a 40-byte input containing five unsigned 64-bit values.

The values are serialized in this exact order:

nonce
currencyId
units
counter
accountId

Each value is encoded as a 64-bit little-endian integer.

Conceptually:

SHA256(
    LE64(nonce)     ||
    LE64(currency)  ||
    LE64(units)     ||
    LE64(counter)   ||
    LE64(account)
)

The resulting SHA-256 hash is compared against the current minting target.

Target Comparison

The Arkovia Monetary System compares the generated hash against the target beginning with the highest indexed byte.

Conceptually:

for i = 31 down to 0:

    if hash[i] > target[i]:
        FAIL

    if hash[i] < target[i]:
        PASS

PASS if equal

This behavior is reproduced locally by the public minter.

Minting Difficulty

VELR was created with:

Minimum Difficulty: 1
Maximum Difficulty: 10

However, the effective difficulty returned by the live Arkovia minting target API can be substantially larger.

For example, live VELR testing has returned effective values such as:

Difficulty: 400

This is expected.

Effective minting difficulty is influenced by:

current mintable supply,
total mintable supply,
requested units,
currency difficulty parameters,
and Monetary System target calculations.

The minter therefore uses the live target returned by Arkovia rather than assuming difficulty must remain numerically between 1 and 10.

Mint Counter

Each account/currency combination maintains its own mint counter.

Arkovia's getMintingTarget response returns the current stored counter.

Therefore, the next mint must use:

nextCounter = currentCounter + 1

The same next counter must be used for:

local nonce searching,
unsigned transaction creation,
transaction verification,
and final mint submission.

Using a stale counter causes the network to reject the mint.

Local Hash Search

The public minter searches for a valid nonce locally.

Example:

Fetching current minting target...

Current Counter: 4115690
Difficulty: 400

Searching locally...

VALID NONCE FOUND

Nonce: 249
Attempts: 250
Elapsed: 6 ms

The hashing operation occurs locally.

The secret phrase is not involved in hash calculation.

Mint hashing requires only public/network information:

nonce,
currency ID,
requested units,
counter,
account ID,
target bytes.

Unsigned Transaction Architecture

Once a valid nonce is found, the minter requests an unsigned currencyMint transaction from an Arkovia node.

The request contains information such as:

requestType=currencyMint
currency=<currency ID>
nonce=<valid nonce>
units=<requested units>
counter=<next counter>
publicKey=<public key>
feeNQT=<fee>
deadline=<deadline>
broadcast=false

No secret phrase is required.

The node returns:

unsignedTransactionBytes

The transaction is not trusted automatically.

It must first pass independent local verification.

Why Unsigned Transactions Are Verified

A secure signing application should not blindly sign transaction bytes supplied by a remote node.

A malicious, compromised, or incorrectly configured node could theoretically return transaction data different from what the user intended.

For this reason, VELR Public Minter parses and validates critical fields before signing.

The verifier currently checks:

hexadecimal encoding,
minimum transaction length,
transaction type,
transaction subtype,
sender public key,
transaction deadline,
serialized recipient placeholder,
transaction amount,
transaction fee,
empty signature field,
attachment version,
nonce,
VELR currency ID,
mint units,
and mint counter.

If a critical value differs from what the minter requested, signing is aborted.

Currency Mint Transaction

Arkovia Monetary System currency mint transactions use:

Type:    5
Subtype: 7

The mint attachment is serialized by Arkovia in the following order:

nonce
currencyId
units
counter

Each field is encoded as a little-endian 64-bit integer.

This order is important when independently verifying transaction bytes.

Transaction Signature

Arkovia uses its Curve25519-based signing implementation.

The public minter reproduces the signing behavior used by the Arkovia/Nxt client.

Conceptually:

secretPhraseBytes = UTF8(secretPhrase)

digest = SHA256(secretPhraseBytes)

s = Curve25519.keygen(digest).s

m = SHA256(unsignedTransactionBytes)

x = SHA256(m || s)

y = Curve25519.keygen(x).p

h = SHA256(m || y)

v = Curve25519.sign(h, x, s)

signature = v || h

The resulting signature is:

64 bytes

The minter then verifies the signature locally before inserting it into the transaction.

Signature Placement

For the current Arkovia transaction format, the signature occupies bytes:

96 through 159

The unsigned transaction contains zero bytes in this field.

After local signing, the 64-byte signature replaces that empty signature region.

The signed transaction can then be submitted to:

requestType=broadcastTransaction

Only the signed transaction bytes are transmitted.

The secret phrase is not required for broadcasting.

Proven Live Mint

The prototype has successfully completed a real end-to-end VELR mint using the secure public-minter architecture.

The test successfully performed:

Fetch live minting target
        ↓
Calculate next counter
        ↓
Search for valid nonce locally
        ↓
Request unsigned transaction
        ↓
Verify unsigned transaction locally
        ↓
Derive signing key locally
        ↓
Sign transaction locally
        ↓
Verify signature locally
        ↓
Insert signature
        ↓
Broadcast signed transaction
        ↓
Arkovia accepts transaction
        ↓
VELR minted

First Public-Minter Architecture Live Test

Transaction:

16400002111779081054

Full hash:

5e8b3f9c078398e34675cfb15401792dda51e48d6a7ad584a23abb6171b992bb

Mint:

1.00 VELR

Mint units:

100 QNT

Fee:

1.00 ARKOS

Counter:

Nonce:

The transaction was accepted into an Arkovia block and confirmed on-chain.

This demonstrated that the local hashing, transaction parsing, transaction verification, signing, signature verification, signed-byte assembly, and broadcasting implementation are compatible with the live Arkovia network.

Minting Fees

VELR mint transactions require an Arkovia transaction fee.

During current testing:

1 mint transaction = 1 ARKOS fee

Users must therefore maintain enough ARKOS in their Arkovia account to pay mint transaction fees.

The minter should always clearly display the expected fee before a transaction is signed or broadcast.

Future versions should provide:

ARKOS balance display,
estimated fee usage,
mint efficiency information,
and warnings when the account does not have enough ARKOS.

Mint Amounts and Economics

The amount of VELR requested per mint significantly affects minting economics.

For example:

1.00 VELR per successful mint

with:

1.00 ARKOS transaction fee

would be inefficient for large-scale distribution.

Future versions of the minter will therefore investigate appropriate configurable mint-unit sizes while remaining within Arkovia Monetary System protocol rules.

Larger requested mint amounts can also affect effective difficulty.

The application must never assume that simply requesting more VELR produces the same probability of finding a valid nonce.

Current Project Structure

velr-public-minter/
│
├── README.md
├── package.json
│
├── docs/
│   └── SECURITY.md
│
├── scripts/
│   ├── test-live-mint.js
│   ├── test-local-signature.js
│   ├── test-mint-hash.js
│   ├── test-mint-search.js
│   ├── test-resolve-minter.js
│   ├── test-signed-mint-dry-run.js
│   ├── test-signing-key.js
│   └── test-unsigned-mint.js
│
└── src/
    ├── arkovia-api.js
    ├── arkovia-sign.js
    ├── curve25519.cjs
    ├── index.js
    ├── minter.js
    ├── mint-hasher.js
    └── transaction-verify.js

Core Modules

`src/arkovia-api.js`

Provides communication with an Arkovia node.

Current functionality includes:

blockchain status,
currency information,
minting target retrieval,
public-key account lookup,
unsigned currency mint creation,
signed transaction broadcasting.

Sensitive credentials must never be added to this module's remote API requests.

`src/mint-hasher.js`

Implements the VELR SHA-256 minting algorithm.

Responsibilities include:

building the 40-byte mint hash input,
unsigned 64-bit little-endian serialization,
SHA-256 hashing,
target comparison,
nonce searching.

`src/arkovia-sign.js`

Implements local Arkovia signing.

Responsibilities include:

deriving public keys,
signing transaction bytes,
verifying signatures,
inserting signatures into unsigned transactions.

Secret phrase processing occurs locally.

`src/transaction-verify.js`

Independently parses and verifies critical fields in node-provided unsigned currencyMint transactions.

Its purpose is to prevent the minter from blindly signing unexpected transaction data.

`src/minter.js`

Reusable public-minter runtime logic.

This module is being developed to provide account-independent minting functionality so that the application is not tied to a hard-coded VELR issuer account.

Requirements

Current development requires:

Node.js 20+

The prototype has been tested using:

Node.js v20.20.2

Installation

Clone the repository:

git clone https://github.com/mycreationhaven/VELR-Public-Minter.git

Enter the project:

cd VELR-Public-Minter

Install dependencies if/when package dependencies are added:

npm install

At the current prototype stage, much of the implementation relies on Node.js built-in functionality and included project source.

Running the Current Status Prototype

The current main status script can be run with:

node src/index.js

It retrieves information such as:

Arkovia blockchain status,
current blockchain height,
VELR currency information,
current supply,
maximum supply,
remaining mintable supply,
minting difficulty,
and live target information.

Development Test Scripts

The repository contains individual test scripts used while validating the minting architecture.

These scripts are primarily intended for development and protocol testing.

Mint Hash Test

node scripts/test-mint-hash.js

Tests known mint hashing behavior.

Mint Search Test

node scripts/test-mint-search.js

Retrieves a live target and performs a local nonce search without broadcasting a transaction.

Signing Key Test

node scripts/test-signing-key.js

Tests local public-key derivation.

Local Signature Test

node scripts/test-local-signature.js

Tests transaction signature creation and verification locally.

Unsigned Mint Test

node scripts/test-unsigned-mint.js

Tests creation of an unsigned mint transaction without broadcasting it.

Signed Mint Dry Run

node scripts/test-signed-mint-dry-run.js

Exercises the secure transaction flow through local signing without broadcasting the signed transaction.

Account Resolution Test

node scripts/test-resolve-minter.js

Tests local public-key derivation followed by public account lookup.

The secret phrase stays local.

Live Mint Test

node scripts/test-live-mint.js

WARNING: This development script can broadcast a real VELR mint transaction and spend ARKOS.

It requires explicit confirmation before broadcasting.

It should not be treated as the final end-user public-minter interface.

Development Status

The following components have been successfully implemented and tested:

Planned Public Minter Interface

The eventual desktop application may display information such as:

VELR PUBLIC MINTER

Account
ARK-XXXX-XXXX-XXXX-XXXXX

VELR Balance
12,345.67 VELR

ARKOS Balance
250.00 ARKOS

Current VELR Supply
5,000,000,000+ VELR

Maximum Supply
25,000,000,000 VELR

Remaining Mintable
19,999,999,000+ VELR

Difficulty
400

Requested Per Mint
1.00 VELR

Hash Rate
42,500 H/s

Current Counter
5,777,887

Hashes Attempted
1,245,921

Successful Mints
12

Rejected Mints
0

ARKOS Fees Spent
12.00 ARKOS

[ START MINTING ]

[ STOP ]

Exact interface details remain under development.

Continuous Minting

The final public minter is intended to automate the repeated process:

Get current target
        ↓
Calculate next counter
        ↓
Search for nonce
        ↓
Prepare unsigned transaction
        ↓
Verify transaction
        ↓
Sign locally
        ↓
Verify signature
        ↓
Broadcast
        ↓
Wait for network state
        ↓
Refresh target/counter
        ↓
Repeat

The implementation must handle changing blockchain state safely.

It must never continue signing stale transactions blindly.

Counter Race Protection

Mint counters can change between:

target retrieval

and:

transaction broadcast

A production minter therefore needs to recognize stale-counter situations and safely restart the mint attempt using fresh network data.

The software must not attempt to work around protocol validation.

Node Trust Model

The public minter intentionally treats the connected Arkovia node as untrusted for signing purposes.

The node may provide:

blockchain information,
currency information,
mint targets,
account information derived from public keys,
unsigned transaction bytes,
and transaction broadcasting.

The node must not receive the user's secret phrase.

Additionally, unsigned transaction bytes are verified locally before signing.

This reduces the amount of trust placed in the remote node.

Public Node Support

The current development environment uses a local Arkovia node.

Future releases are intended to support appropriately configured public Arkovia nodes.

Before public-node support is considered production-ready, the project should include:

HTTPS support,
configurable node endpoints,
node validation,
timeout handling,
connection health monitoring,
malformed-response protection,
transaction verification,
and appropriate retry behavior.

Privacy

The public minter should minimize data collection.

The intended application does not require centralized user accounts merely to mint VELR.

No telemetry or analytics should ever contain:

secret phrases,
private signing material,
transaction signing buffers,
passwords,
authentication tokens,
or other sensitive credentials.

If optional telemetry is ever introduced, it should be documented clearly and designed around privacy from the beginning.

Memory Security

JavaScript does not provide reliable guarantees that immutable strings can be securely zeroed from process memory.

Setting a variable such as:

secretPhrase = null;

removes a program reference but does not guarantee that all copies of the underlying secret have been overwritten in memory.

The current Node.js implementation should therefore be considered a prototype security architecture rather than a hardened hardware-wallet-grade signing environment.

Future desktop implementations should investigate stronger secret-handling mechanisms where practical.

Important User Safety Rules

Never:

Paste your Arkovia secret phrase into a website you do not completely trust.
Post your secret phrase in GitHub issues.
Put your secret phrase in source code.
Put your secret phrase in a Git commit.
Send your secret phrase through Discord.
Send your secret phrase through email.
Include your secret phrase in screenshots.
Pass your secret phrase as a command-line argument.
Put your secret phrase into a URL.
Share your secret phrase with someone claiming to provide support.

Anyone who obtains your secret phrase may be able to control the associated Arkovia account.

Git Security

Before every public release, the repository should be reviewed for accidental credentials.

Developers should specifically inspect for:

secretPhrase
secret_phrase
privateKey
private_key
password
apiKey
api_key
bearer
token

Finding these words does not automatically indicate a leaked credential because they may legitimately appear as variable names or security documentation.

Actual secret values must never be committed.

Release Security

Before distributing executable builds, releases should eventually include:

clean source checkpoint,
dependency review,
credential scan,
license review,
reproducible build documentation where practical,
release checksums,
signed releases where practical,
version tagging,
and release notes.

Users should be able to verify that they downloaded an authentic VELR Public Minter release.

Third-Party Code and Licensing

This project contains or derives interoperability behavior from the Arkovia/Nxt software ecosystem, including Curve25519-related client functionality.

Before binary public distribution, all applicable upstream licenses, notices, attribution requirements, source-distribution obligations, and other license requirements must be reviewed carefully.

The presence of source code in this repository should not be interpreted as a statement that upstream code is public domain.

Do not remove applicable upstream copyright or license notices.

Responsible Development

VELR Public Minter is under active development.

Until a production release is explicitly designated, users should assume:

interfaces may change,
minting parameters may change,
tests may perform real network operations when clearly marked,
security review is ongoing,
and development scripts may not provide production-level safeguards.

Always read script warnings before running development tools.

Roadmap

Phase 1 — Protocol Research

Identify Arkovia Monetary System minting implementation
Determine exact hash-input format
Determine byte order
Determine target comparison behavior
Determine counter behavior
Determine transaction attachment serialization

Phase 2 — Local Hashing

Implement SHA-256 mint hashing
Implement target comparison
Validate against known mint
Find valid live nonces

Phase 3 — Secure Transaction Architecture

Request unsigned transactions
Parse transaction bytes
Verify critical transaction fields
Implement local public-key derivation
Implement local signing
Verify signatures locally
Insert signatures into transactions

Phase 4 — Live Network Validation

Broadcast locally signed transaction
Confirm transaction acceptance
Confirm transaction on-chain
Confirm VELR supply increase

Phase 5 — Generic Public Minter

Resolve arbitrary Arkovia account from locally derived public key
Remove remaining hard-coded development account assumptions
Build reusable mint preparation
Build continuous mint loop
Implement stale-counter recovery
Add configurable mint units
Add balance monitoring
Add performance statistics

Phase 6 — Production CLI

Phase 7 — Desktop Application

Phase 8 — Public Release

Contributing

VELR Public Minter is being developed carefully because it handles blockchain transactions and local signing material.

Contributions should preserve the core security architecture:

SECRET PHRASE
     |
     v
LOCAL MACHINE ONLY

A contribution should never introduce a design requiring the user's secret phrase to be sent to a remote node or application server.

Security-related changes should be reviewed especially carefully.

Reporting Security Issues

Do not publish secret phrases, private keys, tokens, or other credentials in a GitHub issue.

If you discover a potential security vulnerability, avoid including real account credentials or sensitive information in public reports.

A dedicated private security-reporting process should be established before the first production release.

Disclaimer

VELR Public Minter is experimental software under active development.

Minting transactions may spend ARKOS transaction fees and interact with a live blockchain.

Users are responsible for:

protecting their Arkovia secret phrase,
maintaining secure computers,
verifying software authenticity,
understanding transaction fees,
and reviewing transaction details before authorizing live network activity.

No software can eliminate every security risk.

ARKOS

ARKOS — You created the world; now give it an economy.

VELR is part of the broader Arkovia digital economy ecosystem.

Repository

Official repository:

https://github.com/mycreationhaven/VELR-Public-Minter

Current Status

Development / Experimental

The core secure minting architecture has successfully produced and confirmed a real VELR mint on the Arkovia blockchain.

Development is now focused on transforming the validated protocol prototype into a secure, account-independent public minter suitable for ordinary users.

Name		Name	Last commit message	Last commit date
docs		docs
scripts		scripts
src		src
.gitignore		.gitignore
README.md		README.md
package.json		package.json

Latest commit

History

Folders and files

Repository files navigation

VELR Public Minter

What Is Velorium?

VELR Network Parameters

What Is Arkovia?

ARKOS Units

Important Distinction: Minting vs. Forging

Arkovia Forging

VELR Minting

Project Goals

Security Architecture

Secret Phrase Security

Local Account Resolution

VELR Minting Algorithm

Target Comparison

Minting Difficulty

Mint Counter

Local Hash Search

Unsigned Transaction Architecture

Why Unsigned Transactions Are Verified

Currency Mint Transaction

Transaction Signature

Signature Placement

Proven Live Mint

First Public-Minter Architecture Live Test

Minting Fees

Mint Amounts and Economics

Current Project Structure

Core Modules

src/arkovia-api.js

src/mint-hasher.js

src/arkovia-sign.js

src/transaction-verify.js

src/minter.js

Requirements

Installation

Running the Current Status Prototype

Development Test Scripts

Mint Hash Test

Mint Search Test

Signing Key Test

Local Signature Test

Unsigned Mint Test

Signed Mint Dry Run

Account Resolution Test

Live Mint Test

Development Status

Planned Public Minter Interface

Continuous Minting

Counter Race Protection

Node Trust Model

Public Node Support

Privacy

Memory Security

Important User Safety Rules

Git Security

Release Security

Third-Party Code and Licensing

Responsible Development

Roadmap

Phase 1 — Protocol Research

Phase 2 — Local Hashing

Phase 3 — Secure Transaction Architecture

Phase 4 — Live Network Validation

Phase 5 — Generic Public Minter

Phase 6 — Production CLI

Phase 7 — Desktop Application

Phase 8 — Public Release

Contributing

Reporting Security Issues

Disclaimer

ARKOS

Repository

Current Status

About

Resources

Security policy

`src/arkovia-api.js`

`src/mint-hasher.js`

`src/arkovia-sign.js`

`src/transaction-verify.js`

`src/minter.js`