# VinDAX listing integration (local copy)

**Canonical published URLs (use these in email - no attachment required):**

| Artifact | URL |
|---|---|
| Integration pack | https://dcscan.io/apis/exchange-integration/DATACHAIN_ROPE_INTEGRATION.md |
| Hub page | https://dcscan.io/apis/exchange-integration |
| verify-mainnet.mjs | https://dcscan.io/apis/exchange-integration/verify-mainnet.mjs |
| eip3085 JSON | https://dcscan.io/apis/exchange-integration/eip3085-datachain-rope.json |
| genesis block-0 | https://dcscan.io/apis/exchange-integration/genesis-block-0x0.json |
| Live config API | https://dcscan.io/api/v1/network/config |
| Console | https://console.datachain.network/console/ |
| Docs | https://datachain.network/docs#third-party-integration |

Local files in this folder mirror the published pack for git review. **Deploy:** rsync the pack to lon1 `new-blue` (`159.65.208.206`, public `dcscan.io`), then rebuild dc-explorer from `/opt/datachain-rope/code-full` for `POST /api/v1/integration-requests`. Do **not** treat Gandi `rope-vps` as the acceptance surface.

---

# Datachain Rope - VinDAX listing integration pack

**For:** VinDAX engineering / Customer Success
**From:** Datachain Foundation (`contact@datachain.one`)
**Date:** 2026-09-04
**Asset:** native **FAT** (DC FAT) on **Datachain Rope mainnet**
**Invariant:** every deposit, withdrawal, and hot-wallet move that VinDAX processes MUST be a transaction on Datachain Rope **mainnet** (chainId **271828**) and MUST be visible on **https://dcscan.io**. A disconnected private chain is not mainnet and is not accepted.

This pack answers the request for Geth binary, config, peers, and `genesis.json`. It is written so VinDAX can finish listing integration without standing up a forked chain.

**Canonical onboarding (exchange partners):**

| Surface | URL | Role |
|---|---|---|
| Ecosystem Deployment Console | https://console.datachain.network/console/ | Create a VinDAX project, **Deploy a Node**, receive node-identity public key, manage servers |
| Documentation | https://datachain.network/docs | Network params, RPC, deposits/withdrawals, API keys, console walkthrough |

The console is the **default** path when an exchange asks for a "private node." Manual IP allow-list emails are not the onboarding flow.

---

## 0. The one rule that must not be broken

VinDAX asked to "set up and connect a private node." In this network that means:

**A VinDAX-controlled RPC endpoint that still talks to Datachain Rope mainnet** - provisioned through the [Ecosystem Deployment Console](https://console.datachain.network/console/) or, in advanced cases, self-hosted relay software on VinDAX servers. Both attach a **node-identity public key** to the VinDAX project so the network knows which environment is calling.

It does **not** mean:

- a new Geth/Reth `--dev` / Clique / IBFT chain with its own genesis
- a side ledger whose receipts never appear on dcscan.io
- a write path that accepts `eth_sendRawTransaction` only on VinDAX hardware without ever reaching the mainnet writer

dcscan.io indexes **mainnet only** (the writer that public `https://erpc.datachain.network` pins). If a hash is missing from:

```
https://dcscan.io/tx/<hash>
```

and `eth_getTransactionReceipt` on `https://erpc.datachain.network` is null, that transfer **did not happen on Datachain Rope**. Do not credit or debit FAT for it.

Acceptance test for every VinDAX-signed withdrawal and every user deposit:

| Check | Must be true |
|---|---|
| `eth_chainId` on the endpoint you used | `0x425d4` (271828) |
| Genesis `eth_getBlockByNumber("0x0").hash` | `0x6a425482c849cfa07ec253c272a661375469b71c47f499048218a377a24d7203` |
| Receipt | `status = 0x1`, `blockNumber` set |
| Explorer | `https://dcscan.io/tx/<hash>` shows the same from / to / value |

---

## 1. Why there is no Geth binary

Datachain Rope is an EVM-compatible smartchain. The public JSON-RPC surface is `eth_*` + `rope_*`. The execution client in production is **Reth**, not Geth. Consensus is **Testimony** (`rope-node`), not Geth Clique / ethash / PoS.

Shipping a Geth binary plus a homemade `genesis.json` would create a **different chain**. Those blocks would never be the mainnet head, and dcscan.io would never list those hashes.

| VinDAX asked for | What to use instead |
|---|---|
| Geth file/binary | Do not run Geth against this chain. Use public HTTPS RPC, or provision an RPC/relay node via the [console](https://console.datachain.network/console/) (same mainnet, node auth key registered to your project). |
| `genesis.json` to `geth init` | Live genesis **header** is in `genesis-block-0x0.json` (this folder). Use it to **verify identity**, not to start a new network. |
| Peer / enode list | For exchanges, peers are the HTTPS/WSS endpoints in §2 plus any console-provisioned RPC URL. There is no Geth discv4 bootnode that makes you a second sealer. |
| Config files | EIP-3085 in `eip3085-datachain-rope.json`, live copy at `https://dcscan.io/api/v1/network/config`, console project settings |

Official references:

- Console: https://console.datachain.network/console/
- Docs: https://datachain.network/docs
- Protocol source (contributors only): https://github.com/KazeONGUENE/rope
- Explorer APIs: https://dcscan.io/apis

---

## 2. Endpoints VinDAX should wire (live, verified 2026-09-04)

### Writes (deposits you broadcast, withdrawals you sign)

Use **only** the writer URL. Attester-read URLs return HTTP 405 on `eth_sendRawTransaction` on purpose, so a leaked write cannot create a ghost hash that never mines.

```
https://erpc.datachain.network
https://erpc.rope.network          (same public edge family)
```

WSS (subscriptions / new heads):

```
wss://ws.datachain.network
wss://ws.rope.network
```

### Reads (balances, receipts, logs, deposit scan)

Prefer the attester-only read pool so listing scanners stay up while the writer restarts:

```
https://erpc.datachain.network/v1/read
https://erpc.rope.network/v1/read
```

Verified: `eth_blockNumber` on `/v1/read` returns the mainnet tip. `eth_sendRawTransaction` on `/v1/read` returns HTTP 405 / JSON-RPC `-32601`.

### Identity and health

| URL | Use |
|---|---|
| https://dcscan.io/api/v1/network/config | Canonical EIP-3085 + token list |
| https://dcscan.io/api?module=account&action=txlist&address=… | Etherscan-compatible normal tx list per address (same params as Etherscan `txlist`) |
| https://dcscan.io/api?module=account&action=balance&address=… | Etherscan-compatible native FAT balance (wei string) |
| https://dcscan.io/api/v1/accounts/{address}/transactions | dcscan REST tx history (same data, JSON shape) |
| https://erpc.datachain.network/v1/fleet-status | Writer / edge health |
| https://erpc.datachain.network/healthz | Writer liveness |
| https://chainlist.org/chain/271828 | Public chain registry |
| https://dcscan.io | Explorer (user-facing proof) |

Chain parameters:

| Field | Value |
|---|---|
| Network name | Datachain Rope Mainnet |
| Chain ID | 271828 (`0x425d4`) |
| Native symbol | FAT |
| Decimals | 18 |
| Genesis block hash | `0x6a425482c849cfa07ec253c272a661375469b71c47f499048218a377a24d7203` |
| Block time (typical) | ~3 s |
| Suggested deposit confirmations | 20 blocks (~60 s) after `status=0x1` |
| Suggested withdrawal confirmations | same, then show the dcscan link to the user |

---

## 3. What FAT is on this chain (do not treat it as an ERC-20)

**FAT is the native gas coin.** It has **no token contract**. A deposit is a plain value transfer (`tx.value > 0`, `tx.to = depositAddress`), the same shape as ETH on Ethereum.

Do **not** watch `Transfer` logs for native FAT. Those logs are only for DCR-20 tokens.

Canonical 1:1 wrap (only if VinDAX later lists a token-contract form):

| Token | Address | Decimals | Standard |
|---|---|---|---|
| WFAT (Wrapped DC FAT) | `0x285eecf51d5f0a6ab8d8151139b4d19b05c6b3e4` | 18 | DCR-20 (ERC-20 wire) |
| USDC | `0xb93bd8db94f1baff474aa9cba0739daaad01641f` | 6 | DCR-20 |
| USDT | `0x79a26132f48394421382c13b54ae77fa3af73289` | 6 | DCR-20 |
| EUROD | `0x24d6137807fa8a592888726d87ac748d018c6d4a` | 6 | DCR-20 |

Explorer examples:

- Native coin page / supply: https://dcscan.io/supply
- WFAT: https://dcscan.io/token/0x285eecf51d5f0a6ab8d8151139b4d19b05c6b3e4
- Any address: https://dcscan.io/address/<addr>
- Any tx: https://dcscan.io/tx/<hash>

**Deposit reconciliation (Etherscan-style):**

```
GET https://dcscan.io/api?module=account&action=txlist&address=<depositAddress>&startblock=0&endblock=99999999&page=1&offset=100&sort=desc
```

Reference: https://docs.etherscan.io/api-reference/endpoint/txlist

Example (15,000 FAT test deposit, 2026-09-04):

```
GET https://dcscan.io/api?module=account&action=txlist&address=0x029d65c2759099c6237ed3233736b5c25be31ed0&page=1&offset=5&sort=desc
```

Address collisions are **chain-scoped**. The same hex on Ethereum or BSC is a different wallet. Always key records as `(271828, address)`.

---

## 4. Recommended VinDAX architecture (private node + mainnet record)

```
  VinDAX engineers
        |
        v
  console.datachain.network/console/
  (project + Deploy a Node + node public key)
        |
        +--> VinDAX RPC URL (reads: balances, receipts, deposit scan)
        |
  users / VinDAX hot wallet
        |
        |  signed raw tx (EIP-155 chainId 271828)
        v
  https://erpc.datachain.network   <-- writes ALWAYS here
        |
        v
  Datachain Rope writer (mainnet)
        |
        +--> https://dcscan.io/tx/<hash>
```

### What "private node" means (plain language)

VinDAX asked for a **private node**. That phrase confuses people because it sounds like a separate blockchain. It is not.

| Phrase | Meaning |
|---|---|
| **Private node (what we want)** | VinDAX gets its **own RPC URL** and **node-identity key** tied to a VinDAX project in the console. Reads can go through that URL. **Writes still go to public mainnet** so dcscan.io shows every deposit and withdrawal. |
| **Private chain (what we reject)** | VinDAX runs Geth/Reth with a fresh `genesis.json` and mines its own blocks. Those txs never appear on dcscan.io. **Not acceptable.** |
| **Own servers (optional detail)** | Some exchanges want the node **software running on VinDAX-owned machines** (their cloud account or data centre) instead of Foundation-managed infrastructure. That is fine **only** if it still uses mainnet chainId 271828 and the same genesis hash - see Path C below. |

### Path A - public RPC only (fastest way to list)

Point the listing integration at the URLs in §2. No console required. This is enough to go live if VinDAX is comfortable calling public erpc directly. Every transaction is mainnet by construction.

### Path B - Ecosystem Deployment Console (**default when they ask for a private node**)

This is the standard exchange-partner path documented at https://datachain.network/docs (see **Running a Validator Node** and **CLI Interface / Installation** - console is listed first).

1. Open https://console.datachain.network/console/
2. Sign in (wallet signature or Datachain identity).
3. **+ New Project** - name it e.g. `VinDAX FAT listing`.
4. **Deploy a Node** - role **RPC / relay** (read-heavy; does not produce blocks).
5. Pick region / size per the form. The console provisions the machine, generates a **node-identity keypair** on first boot, and shows the **public key** registered to that project.
6. Use the RPC URL the console returns for `eth_getBalance`, `eth_getTransactionReceipt`, deposit scanning, and health checks.
7. Route **all** `eth_sendRawTransaction` (withdrawals) to `https://erpc.datachain.network` - never only to the private RPC listener.
8. Run `node verify-mainnet.mjs --rpc <your-console-rpc-url>` before crediting any FAT.

Why the node key matters: Datachain Rope uses the public half of that keypair to **authenticate the node** and to **gate its RPC role** (relay vs validator vs agent). The console binds the key to the VinDAX project so ops can see which environment belongs to which listing partner. VinDAX manages rotation and teardown from the same console - no ad-hoc IP allow-list thread.

### Path C - self-hosted on VinDAX servers (advanced)

Only if VinDAX policy requires the node process to run on **hardware VinDAX owns** (their AWS/GCP account or on-premise racks):

1. Follow https://datachain.network/docs - local operator path (`rope node --network mainnet --mode relay`).
2. Still register the deployment in the **console project** so the node-identity public key is attributed to VinDAX (same gating as Path B).
3. Point the relay's EVM backend at `https://erpc.datachain.network` (writes) and `/v1/read` (reads).
4. Run `verify-mainnet.mjs` against the internal URL before production.

Forbidden on every path:

- `--dev` / sealer / local block production
- a `genesis.json` that does not yield hash `0x6a425482…24d7203`
- crediting FAT when `https://dcscan.io/tx/<hash>` does not show the transfer

---

## 5. Deposit / withdrawal recipe (native FAT)

### Credit a deposit

1. Assign the user a unique deposit address on chain 271828 (or a memo + shared address if that is VinDAX policy; native FAT has no memo field on-chain, so unique addresses are safer).
2. Watch new heads on `wss://ws.datachain.network` or poll `eth_blockNumber` on `/v1/read`.
3. For each new block, list txs where `to == depositAddress` and `value > 0`.
4. Wait until `eth_getTransactionReceipt(hash)` on **public erpc or /v1/read** returns `status=0x1` and `blockNumber + 20 <= latest`.
5. Confirm `https://dcscan.io/tx/<hash>` loads the same transfer.
6. Credit `value / 1e18` FAT.

`eth_getBalance(depositAddress, "latest")` is a sanity check, not a substitute for a receipt + explorer link.

### Process a withdrawal

1. Sign an EIP-155 transaction with `chainId = 271828`, `value` in wei, `to` = user address.
2. Broadcast **only** to `https://erpc.datachain.network` (`eth_sendRawTransaction`).
3. Persist the hash immediately.
4. Poll receipt on `/v1/read` and on public erpc. Do not re-sign a second tx while a hash is pending (mempool dedupes by hash; a second nonce burns funds).
5. Mark complete only when receipt `status=0x1` **and** `https://dcscan.io/tx/<hash>` shows it.
6. If the edge returns 502/504 after the send, re-broadcast the **same raw hex**. Do not build a new signature.

### Gas

Native FAT pays gas. Price the hot wallet so it always holds a FAT gas float in addition to the withdrawal inventory. Typical `baseFee` is ~1 gwei (`0x3b9aca00` at genesis; live `eth_gasPrice` on erpc).

---

## 6. Smoke commands (copy-paste)

```bash
# Identity - must print 0x425d4
curl -sS https://erpc.datachain.network \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'

# Genesis hash - must print 0x6a425482c849cfa07ec253c272a661375469b71c47f499048218a377a24d7203
curl -sS https://erpc.datachain.network \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"eth_getBlockByNumber","params":["0x0",false]}'

# Tip (writer)
curl -sS https://erpc.datachain.network \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":3,"method":"eth_blockNumber","params":[]}'

# Tip (read pool) - should be within a few blocks of writer
curl -sS https://erpc.datachain.network/v1/read \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":4,"method":"eth_blockNumber","params":[]}'

# Writes must fail on the read pool
curl -sS -D - https://erpc.datachain.network/v1/read \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":5,"method":"eth_sendRawTransaction","params":["0x00"]}'

# After any real deposit/withdrawal:
# open https://dcscan.io/tx/0x<64 hex>
```

Or: `node listing/vindax/verify-mainnet.mjs` (defaults to public erpc). Point `--rpc` at a VinDAX private URL; the script fails if chainId or genesis hash differ from mainnet.

---

## 7. Files in this pack

| File | What it is |
|---|---|
| `VINDAX_DATACHAIN_ROPE_INTEGRATION.md` | This document |
| `eip3085-datachain-rope.json` | Wallet / node network object |
| `genesis-block-0x0.json` | Live mainnet genesis **header** (identity, not `geth init`) |
| `verify-mainnet.mjs` | Fail-closed identity check |

We do not attach sealer keys, SSH access, writer loopback ports, or a Reth `--chain` file that could be used to start a second network.

---

## 8. Contacts and canonical links

| Need | Where |
|---|---|
| Provision VinDAX node + auth key | https://console.datachain.network/console/ |
| Integration docs | https://datachain.network/docs |
| Explorer (proof for every tx) | https://dcscan.io |
| Listing questions | `contact@datachain.one` |
| Protocol source (contributors) | https://github.com/KazeONGUENE/rope |

We do not issue sealer keys. All VinDAX environments should be registered and managed through the console so node authentication stays attributable to the VinDAX project.