[ANN][MYT] MYT — Privacy Settlement Layer for Machines | PoW | Fair Launch

[MYT-Core]

MYT is a privacy-preserving Proof-of-Work blockchain designed as a settlement
layer for autonomous systems, AI agents, and enterprises. Built on the
CryptoNote protocol stack with Bitcoin-style monetary policy.

Mainnet is live. Fair launch.

No ICO. No premine. No team allocation.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
NETWORK STATUS (at time of posting)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  Launch Date       2026-03-08 00:00:00 UTC
  Genesis Epoch     1772928000
  Current Block     ~9,629
  Network Hashrate  ~5.6 kH/s (early stage — growing)
  Coin Supply       48,150 MYT minted (0.23% of 21,000,000)
  Block Reward      5.000000 MYT (fixed until first halving)
  Chain Age         ~8 days

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CORE PARAMETERS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  Algorithm         CryptoNight (launch) → RandomX at HF12 (block 28,895)
  Block Time        60 seconds
  Max Supply        21,000,000 MYT
  Block Reward      5 MYT (halving every 2,102,400 blocks, ~4 years)
  Ring Size         Minimum 16 (consensus enforced at HF15)
  Privacy           Ring Signatures + Stealth Addresses + Confidential Txs
  Tail Emission     None — hard cap enforced
  P2P Port          39080
  RPC Port          39081


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
WHAT IS MYT?
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Modern digital infrastructure increasingly runs on autonomous software —
compute networks, automated service markets, programmatic APIs. These systems
need to transact across organizational boundaries without human oversight.
Existing blockchain infrastructure fails this use case:

  ✗  Transparent ledgers expose all payment flows publicly
  ✗  Smart contract platforms require identity and registration
  ✗  Privacy chains lack fixed monetary policy or machine-native design

MYT addresses all three. It combines:

  ✓  CryptoNote-derived privacy (ring signatures, stealth addresses, RingCT)
  ✓  Bitcoin-style fixed supply and halving schedule
  ✓  A roadmap for machine-native and programmatic settlement infrastructure

MYT is not a product. It is infrastructure — built to be reliable and still
useful decades from now.


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
HOW IT DIFFERS FROM MONERO
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

MYT inherits Monero's privacy stack but diverges in three fundamental ways:

  1. Fixed supply cap (21,000,000 MYT) — Monero has no supply cap
  2. No tail emission — MYT transitions entirely to fee-based security
  3. Machine settlement as primary design goal — not human-facing payments

If you want Monero's privacy with Bitcoin's monetary discipline, MYT is
built for exactly that.


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MINING
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

MYT uses a staged mining algorithm inherited from the CryptoNote hardfork plan:

  Blocks 1 – 28,894      CryptoNight (variant by block version)
  Block 28,895+           RandomX (activates at HF12)

Both algorithms are designed to favor commodity CPU hardware and resist ASIC
centralization. No specialized hardware is required or advantaged at launch.

Windows binaries are available on the GitHub releases page. Linux builds
can be compiled from source.

Seed Node (P2P):  87.106.240.3:39080
Seed Node (RPC):  87.106.240.3:39081


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MINING QUICKSTART
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  1. Download the Windows release from github.com/myt-core/MYT/releases
  2. Add the folder as an AV exclusion (see section below — read this first)
  3. Open the MYT Launcher

  4. Select: "Start Mining (local node + wallet)"
     Set your Mining Threads — this controls how much CPU power MYT uses.
     Click: "Start Mining Mode"

     This will automatically:
       — Start your local node
       — Connect to the MYT network
       — Open your wallet
       — Begin blockchain sync

  5. Wait until the wallet is fully synced before mining.  

  6. Inside the wallet console:
       Right-click → the command inserts automatically:

       start_mining (Number of Threads you want to use)

     Press ENTER to start mining.

  ⚠  If you skip step 6, your node runs but does NOT mine.

  Block reward: 5 MYT. ~60 second blocks.
  Network hashrate is low — solo mining is viable right now.


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠  ANTIVIRUS FALSE POSITIVES — PLEASE READ BEFORE DOWNLOADING
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The MYT daemon (myt-daemon) and wallet CLI (myt-wallet-cli) will almost
certainly be flagged by antivirus software — including Windows Defender,
Avast, Bitdefender, and others. This is a FALSE POSITIVE and affects every
CryptoNote/Monero-based project including Monero itself.

WHY THIS HAPPENS:

  The MYT daemon contains the CryptoNight and RandomX hashing code. These
  algorithms are identical to the code used by actual cryptojacking malware.
  Antivirus vendors detect the hash functions themselves — not malicious
  behavior. The software is not doing anything covertly; it mines only when
  you explicitly start mining and only on hardware you control.

WHAT YOU WILL LIKELY SEE:

  Windows Defender     →  "Trojan:Win32/CoinMiner" or similar
  Avast / AVG          →  "CoinMiner" or "Coinminer.MNR"
  Bitdefender          →  "Gen:Variant.Application.Miner"
  Kaspersky            →  "not-a-virus:RiskTool.Win32.BitCoinMiner"

All of these are false positives. The binaries are open source — you can
verify the code yourself at github.com/myt-core/MYT and build from source
if you prefer not to trust pre-compiled releases.

HOW TO RUN (Windows — currently the only pre-compiled release):

  1. Download the release from github.com/myt-core/MYT/releases
  2. Before extracting: right-click the ZIP → Properties → Unblock
  3. Add the extracted folder as an exclusion in Windows Defender:
     Windows Security → Virus & threat protection → Exclusions → Add folder
  4. Do the same in any third-party AV software you run
  5. Verify the SHA256 hash of the binary matches the release page

HOW TO VERIFY (Windows PowerShell):
  Get-FileHash myt-daemon.exe -Algorithm SHA256

SHA256 hashes for all releases are published on the GitHub releases page.
Never run a binary whose hash does not match.

NOTE FOR MODS AND REVIEWERS:

  This is not an attempt to distribute malware. This is a known, documented
  issue affecting all CryptoNote-derived projects. Monero's own binaries
  trigger identical false positives. The source code is fully public and
  buildable from scratch. We include this warning proactively and
  transparently precisely because we are not trying to hide it.


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
LINKS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  Source Code       https://github.com/myt-core/MYT
  Whitepaper        https://github.com/MYT-Core/MYT-Whitepaper
  Website             https://myt-coin.com/
  Block Explorer Testnet    https://testnet-explorer.myt-coin.com/
  Block Explorer Mainnet   https://explorer.myt-coin.com/
  Seed Node P2P     87.106.240.3:39080
  Seed Node RPC     87.106.240.3:39081
  Discord:  https://discord.gg/nuWjx7kvqp
  Exchanges: https://klingex.io/de/trade/MYTC-USDT
                    https://cexius.com/trade/MYT-USDT

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ROADMAP
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✓  Phase 1  Local testnet — chain logic validated
  ✓  Phase 2  Public testnet — multi-node sync, block explorer, reproducible builds
  ✓  Phase 3  Mainnet — live, parameters finalized, public infrastructure stable
  ○  Phase 4  Machine Settlement Layer — selective disclosure, agent identity


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
EARLY NETWORK NOTICE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

MYT launched on 2026-03-08. The chain is 8 days old with ~9,600 blocks mined.
Like all new PoW networks:

  — Hashrate is ~5.6 kH/s — low, but this means solo mining is viable now
  — 0.23% of total supply mined — extremely early
  — Anonymity set grows as transaction history expands
  — Ecosystem tooling (explorers, wallets) continues to develop

We document these realities transparently in the whitepaper. They are
characteristic of every early-stage PoW chain, not specific to MYT.


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
DISCLAIMER
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

This is not an offer of securities or investment advice. MYT is open-source
software. Use it at your own risk.

[SwampSwagga]

No swimming pool?

[Laheeboo]

mining it solo before pools come and hashrate explodes

neat project and active developer

[MYT-Core]

No swimming pool?

RandomX will be activated soon at block 28895 and then pools are going to show up.
Greetings MYT

mining it solo before pools come and hashrate explodes

neat project and active developer

Thank you, my friend.
I try to do my best every day and create something special here. The community is growing every day.

No swimming pool?

Hi now rrplant provided pool support. Check it out if you like:
https://pool.rplant.xyz/#myt


Also Cexius as an exchange listed us:
https://cexius.com/trade/MYT-USDT


Very good progress has been made!!

[MYT-Core]

Development Update — June 2026

A lot has happened since the original announcement.

Current Resources

Website:
https://myt-coin.com/

Mainnet Explorer:
https://explorer.myt-coin.com/

Testnet Explorer:
https://testnet-explorer.myt-coin.com/

Exchange:
https://klingex.io/de/trade/MYTC-USDT

Discord:
200+ community members

Network Status

The network continues to operate normally and development is ongoing.

RandomX activation has been completed successfully and the chain is running on the current protocol schedule. Public infrastructure, explorers, wallets, pools and exchange integrations remain operational.

While community activity and hashrate have naturally fluctuated over time, development has continued behind the scenes.

HF17 — Strict 21M Supply Cap

The next major protocol upgrade currently being tested is HF17.

The purpose of HF17 is to enforce a mathematically strict maximum supply of exactly 21,000,000 MYT at the consensus level.

Current emission calculations theoretically result in approximately:

21,023,999.9768736 MYT

To align the protocol implementation with the documented monetary policy, HF17 introduces a consensus-level emission cap.

Key Changes

* Exact 21,000,000 MYT maximum supply
* Reward capped to remaining supply
* Reward becomes zero once the cap is reached
* No chain reset
* No retroactive emission changes
* Existing chain history remains untouched
* Full backwards compatibility before HF17 activation

The upgrade is currently being validated on testnet before deployment to mainnet.

Future Direction

MYT continues to focus on its original vision:

A privacy-preserving settlement layer for machines, autonomous systems, AI agents and enterprises.

Current development priorities include:

* Network infrastructure improvements
* Consensus hardening
* Monetary policy consistency
* Foundation work for future Machine Settlement Layer components

More updates will follow as testing progresses.

Thank you to everyone who continues to support, mine and build with MYT.

[MYT-Core]

MYT Phase 4A Released — Machine Settlement SDK / CLI v0.1.0

We have released the first public version of the MYT Machine Settlement SDK / CLI.

Repository:
https://github.com/MYT-Core/MYT-Machine

Release v0.1.0:
https://github.com/MYT-Core/MYT-Machine/releases/tag/v0.1.0

What is Machine Settlement?

MYT already provides Wallet RPC functionality, but integrating directly with low-level RPC calls requires developers to understand request structures, authentication, atomic-unit conversion, error handling and individual wallet methods.

Phase 4A introduces a simpler standardized layer for software, services, bots and autonomous agents:

Code:

AI Agent / Application
        |
        v
    myt-machine
        |
        v
  myt-wallet-rpc
        |
        v
     MYT Network

Instead of every application implementing MYT Wallet RPC logic itself, developers can work with simple operations such as:

Code:

balance
address
pay
payment-status
prove-payment
verify-payment
sign-message
verify-message

In practical terms, software can now:

• Retrieve MYT addresses and balances
• Send exact MYT payments
• Track wallet-local transaction status
• Generate native OutProofV2 payment proofs
• Verify payment proofs and received amounts
• Sign messages with the wallet
• Verify native MYT signatures
• Receive predictable machine-readable JSON responses

A simple machine-to-machine flow can therefore look like this:

Code:

Agent A requests a service
        ↓
Service requests payment
        ↓
Agent A sends MYT
        ↓
Agent A generates payment proof
        ↓
Service verifies payment proof
        ↓
Service continues automatically

No consensus changes

Phase 4A is deliberately implemented as higher-layer infrastructure.

It does NOT change:

• MYT consensus
• HF17
• the 21,000,000 MYT emission cap
• block validation
• transaction rules
• Wallet RPC schemas
• Mainnet network parameters

Private keys and wallet seeds also remain inside the existing MYT wallet infrastructure. The Machine Settlement SDK communicates with an already running

Code:

myt-wallet-rpc

.

Safety

Payments are never automatically retried.

If connectivity is lost after a transaction may already have been submitted, the SDK reports the outcome as unknown instead of risking an accidental duplicate payment.

RPC authentication and protected password files are supported, and sensitive wallet material is never exposed by the SDK.

Validation

v0.1.0 has passed:

• 66 automated unit and CLI tests
• Linux testing on Python 3.10, 3.12 and 3.13
• Windows testing
• Clean package installation testing
• Real MYT Testnet payment
• Pending → confirmed payment tracking
• Payment-proof generation and verification
• Message signing and verification
• Manipulated proof/signature tests
• Authentication and connection-failure tests

How to try it

Python 3.10+ is required.

Download the wheel from the release page and install it inside a virtual environment:

Code:

python3 -m venv .venv
source .venv/bin/activate

pip install ./myt_machine_settlement-0.1.0-py3-none-any.whl

myt-machine --help

We currently recommend beginning with MYT Testnet and reporting issues or feedback through GitHub before using significant Mainnet funds.

What comes next?

Machine Settlement is only the first building block of Phase 4.

The higher-layer roadmap can now build toward areas such as:

Code:

Phase 4A
Machine Settlement
        ↓
Machine Identity
        ↓
Signed Address Binding
        ↓
API Billing
        ↓
Agent Reputation

The goal is not to put “AI logic” into consensus.

The goal is to keep MYT as a private, decentralized settlement layer while building standardized infrastructure above it that autonomous software can actually use.

Phase 4 has begun.

[parrotbr]

Another important piece of news is that MYT is now listed at  miningpoolstats
 
https://miningpoolstats.stream/mytcoin

[MYT-Core]

🚀 MYT Phase 4B Released — Agent Identity / MYT Machine v0.2.0

We have released MYT Machine v0.2.0, introducing Phase 4B: Agent Identity.

Phase 4A established the machine-facing settlement interface.

Phase 4B now adds a separate cryptographic identity layer for software, autonomous agents and machine-to-machine systems.

Phase 4A: How can machines pay?
Phase 4B: How can a machine prove which identity it controls?

What is Agent Identity?

Each machine can now create its own pseudonymous cryptographic identity based on Ed25519.

An identity consists of:

Code:

Encrypted Private Identity Key
        ↓
Public Identity Key
        ↓
Deterministic Machine ID

myt-machine-v1:...

The Machine ID is deterministically derived from the public key.

An agent can use its private identity key to sign messages or authentication challenges.

Another machine or service can then verify the signature and confirm control of the expected Machine ID.

This allows persistent machine identities without requiring real-world identity, KYC or a blockchain registry.

Wallet-independent by design

Phase 4B is intentionally separate from the MYT wallet layer.

Code:

Phase 4B
Machine Identity
      │
      │  no wallet binding yet
      │
Phase 4A
Machine Settlement
      │
      ▼
MYT Wallet RPC
      │
      ▼
MYT Network

Identity commands therefore require:

- no MYT wallet
- no wallet RPC
- no daemon
- no blockchain access
- no Testnet or Mainnet connection
- no Internet connection

The identity layer can operate completely offline.

The connection between a Machine Identity and an MYT settlement address is intentionally deferred to Phase 4C.

Available in v0.2.0

The CLI now supports:

Code:

myt-machine identity create
myt-machine identity show
myt-machine identity sign
myt-machine identity verify

Features include:

- Ed25519 Machine Identities
- deterministic versioned Machine IDs
- encrypted PKCS8 private-key storage
- message signing and verification
- binary-data signing
- challenge-response authentication
- strict canonical Base64url / Base32 formats
- machine-readable JSON output
- verification against an independently expected Machine ID

Authentication

A typical authentication flow looks like this:

Code:

Service
   │
   │ random 32-byte challenge
   ▼
Agent
   │
   │ signs challenge with identity key
   ▼
Service
   │
   │ verifies signature
   │ verifies expected Machine ID
   ▼
Authenticated

The challenge itself is only transport data.

Replay protection, expiration and one-time nonce consumption remain application responsibilities.

No consensus changes

Phase 4B does not modify:

- MYT consensus
- emission
- HF17
- transaction formats
- wallet RPC schemas
- network parameters
- MYT transaction privacy

No hardfork is required.

The Machine Identity layer sits above the blockchain.

Privacy

A Machine Identity is pseudonymous and contains no MYT wallet address.

Phase 4B therefore does not create an identity-to-wallet link.

The public identity document contains only the identity type, version, algorithm, Machine ID and public key.

The private identity key remains encrypted and local.

Security

MYT Machine v0.2.0 uses Ed25519 through the established Python cryptography library.

Runtime requirement:

Code:

cryptography>=50.0.0

Private identity keys are stored as encrypted PKCS8 PEM files.

The CLI does not expose private keys or passphrases in normal JSON output.

For authentication against a known peer, the expected Machine ID must be obtained or pinned independently.

A public identity document supplied by the remote party alone is not a trust anchor.

Validation

Phase 4B was validated with:

- 128 / 128 automated tests
- 66 / 66 existing Phase 4A regression tests
- Linux and Windows
- Python 3.10 / 3.12 / 3.13
- cryptography 50.0.0
- pip-audit: no known vulnerabilities
- Bandit
- Ruff
- compileall
- Wheel and Source Distribution validation
- Clean-Wheel offline E2E
- manual offline end-to-end testing

The manual E2E included:

- identity creation
- message signing
- generic verification
- authentication against an expected Machine ID
- rejection of a modified message
- rejection of a wrong Machine ID
- challenge-response authentication
- malformed nonce rejection
- binary-data signing
- wrong-passphrase rejection
- no-overwrite protection
- secret-leak checks

How to try it

Repository:

https://github.com/MYT-Core/MYT-Machine

Release:

https://github.com/MYT-Core/MYT-Machine/releases/tag/v0.2.0

Example:

Code:

myt-machine identity create \
  --private-key-file machine-key.pem \
  --identity-file identity.json \
  --passphrase-file passphrase.txt

Then sign a message:

Code:

myt-machine identity sign \
  --private-key-file machine-key.pem \
  --identity-file identity.json \
  --passphrase-file passphrase.txt \
  --context myt-machine/message \
  --message "Hello from my agent"

And verify it:

Code:

myt-machine identity verify \
  --identity-file identity.json \
  --context myt-machine/message \
  --message "Hello from my agent" \
  --signature <SIGNATURE>

What comes next?

Code:

Phase 4A — Machine Settlement     ✅
Phase 4B — Agent Identity         ✅
Phase 4C — Wallet Binding         🔜

Phase 4C will connect the two layers.

The goal is to let a machine prove that a specific MYT settlement address is authorized by its Machine Identity, while keeping identity logic outside consensus and preserving MYT's privacy-focused base layer.

Phase 4 continues.

[MYT-Core]

🚀 MYT Phase 4C Released — Address Binding / MYT Machine v0.3.0

MYT Machine v0.3.0 has now been released, completing the first full Phase-4 machine settlement stack.

Phase 4A introduced machine-facing settlement.

Phase 4B introduced cryptographic Machine Identities.

Phase 4C now connects both layers through cryptographic MYT settlement-address bindings.

Phase 4A: How can machines pay?
Phase 4B: How can a machine prove which identity it controls?
Phase 4C: How can that Machine Identity prove which MYT settlement address it authorizes?

Two-sided address binding

Phase 4C uses a two-sided authorization model:

Code:

Machine Identity
      │
      │ Ed25519 signature
      ▼
Canonical Binding Statement
      ▲
      │ MYT SigV2 Spend signature
      │
MYT Settlement Address

Both key controllers authorize the same canonical binding statement.

This means the binding does not rely on a simple self-assertion such as:

Code:

"Machine ABC claims Address XYZ belongs to it"

Instead, both sides participate cryptographically:

- the Phase-4B Machine Identity authorizes the MYT address
- the MYT spend key authorizes the Machine Identity

Binding Artifact

The versioned binding artifact contains:

Code:

{
  "address": "MYT_ADDRESS",
  "identity": {
    "algorithm": "ed25519",
    "machine_id": "myt-machine-v1:...",
    "public_key": "...",
    "type": "myt-machine-identity",
    "version": 1
  },
  "identity_signature": "...",
  "network": "mainnet|testnet|stagenet",
  "type": "myt-machine-address-binding",
  "version": 1,
  "wallet_signature": "SigV2..."
}

The artifact is self-contained and machine-readable.

Privacy by design

Phase 4C remains completely off-chain.

No Machine ID, public identity document or binding is written to the MYT blockchain.

Bindings are only disclosed to parties that the owner chooses to share them with.

Code:

Machine ID
    ↕
Binding
    ↕
MYT Address

This relationship exists outside consensus.

MYT transaction privacy remains unchanged.

There is:

- no global identity registry
- no on-chain identity
- no public address database
- no consensus-level identity
- no hardfork
- no transaction-format change

Subaddresses as the default

For privacy, Phase 4C uses MYT subaddresses as the recommended default.

A separate subaddress and binding can be used for each service or counterparty.

The primary standard address can still be bound, but requires explicit opt-in:

Code:

--allow-standard-address

Integrated addresses are intentionally not supported in Binding v1.

CLI

Phase 4C adds:

Code:

myt-machine binding create
myt-machine binding show
myt-machine binding verify

Example:

Code:

myt-machine binding create \
  --private-key-file machine-key.pem \
  --identity-file identity.json \
  --binding-file binding.json

Verification:

Code:

myt-machine binding verify \
  --binding-file binding.json \
  --expected-machine-id myt-machine-v1:... \
  --expected-network testnet

Independent verification

Binding verification does not require possession of the bound address private keys.

This was tested using a completely independent MYT Testnet wallet.

The verifier checks:

- the embedded Machine Identity
- the Ed25519 identity signature
- the MYT address and network
- the native MYT SigV2 spend signature
- the expected Machine ID
- the expected network

Important security property

A valid binding proves that the controllers of the Machine Identity key and the MYT settlement-address spend key both authorized the same canonical binding statement.

It does NOT prove:

- when the authorization occurred
- current liveness
- continued control of the keys
- exclusive control
- real-world identity
- reputation
- balance
- transaction history

Current Machine Identity liveness should be checked using a fresh Phase-4B challenge-response.

Full Phase-4 stack tested

The complete system was tested end-to-end on the real MYT Testnet:

Code:

Machine Identity B
        ↓
Phase-4B Challenge Authentication
        ↓
Phase-4C Address Binding
        ↓
Agent A verifies Binding
        ↓
Agent A sends 0.1 MYT
        ↓
MYT Testnet
        ↓
OutProofV2
        ↓
Service B verifies Payment Proof
        ↓
VALID

The real Testnet payment used:

Code:

Amount: 0.100000000 MYT
Fee:    0.000258910 MYT
TXID:   af51c39734ce8bb1c86cce06d38aac78be902304f07d7c9029689e4185602672

The received amount was verified as exactly:

Code:

100000000 atomic units

Manipulated challenges, bindings, transaction IDs and payment proofs were rejected.

Validation

MYT Machine v0.3.0 passed:

- 175 / 175 automated tests
- 66 / 66 Phase-4A regression tests
- 62 / 62 Phase-4B regression tests
- 47 / 47 Phase-4C tests
- Linux and Windows
- Python 3.10 / 3.12 / 3.13
- cryptography >= 50.0.0
- pip-audit
- Bandit
- Ruff
- compileall
- Wheel / Source Distribution validation
- Clean-Wheel E2E
- real offline Wallet-RPC E2E
- complete MYT Testnet E2E

No protocol changes

Phase 4C does not modify:

- MYT Core
- consensus
- HF17
- emission
- blockchain format
- transaction format
- RingCT
- CLSAG
- stealth addresses
- Wallet-RPC schemas
- network parameters

It is entirely additive infrastructure above the existing privacy-preserving base chain.

Phase 4 status

Code:

Phase 4A — Machine Settlement     ✅
Phase 4B — Agent Identity         ✅
Phase 4C — Address Binding        ✅

This now forms the first complete MYT Machine stack:

Code:

Machine Identity
       ↓
Authentication
       ↓
Verified MYT Address
       ↓
Private MYT Settlement
       ↓
Payment Proof
       ↓
Verification

Repository

https://github.com/MYT-Core/MYT-Machine

Release

https://github.com/MYT-Core/MYT-Machine/releases/tag/v0.3.0

Phase 4 continues.