Doge Inu Core protocol documentation

bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state,
                               CBlockIndex* pindex, CCoinsViewCache& view,
                               const CChainParams& chainparams, bool fJustCheck)
{
    // Plane 1 — settlement. Unmodified from upstream apart from the call
    // into the asset pass at the bottom of the tx loop.
    if (!CheckBlock(block, state, chainparams.GetConsensus(), !fJustCheck, !fJustCheck))
        return error("%s: CheckBlock failed", __func__);

    int64_t nAssetOps = 0;
    for (const auto& tx : block.vtx) {
        if (!CheckTxInputs(*tx, state, view, pindex->nHeight))
            return false;

        // Plane 2 — asset. Conservation is a consensus rule, so a single
        // bad transfer invalidates the whole block rather than being
        // silently dropped from the mempool.
        if (pindex->nHeight >= chainparams.GetConsensus().nInuAssetHeight) {
            if (!Consensus::CheckAssetConservation(*tx, view, state))
                return false;
            nAssetOps += CountAssetOps(*tx);
        }
    }

    if (nAssetOps > MAX_BLOCK_ASSET_OPS)
        return state.DoS(100, false, REJECT_INVALID, "bad-blk-assetops");

    const uint256 assetRoot = view.ComputeAssetRoot();
    if (assetRoot != block.hashAssetRoot)
        return state.DoS(100, false, REJECT_INVALID, "bad-asset-root", false,
                         strprintf("computed=%s header=%s",
                                   assetRoot.ToString(), block.hashAssetRoot.ToString()));

    // Plane 3 — vote. Advisory at connect time; inu-validator observes the
    // ZMQ notification and votes out of band.
    g_vote_notifier.NotifyBlockConnected(pindex->nHeight, block.GetHash(), assetRoot);

    return true;
}

  offset  size  field                description
  ------  ----  -------------------  ---------------------------------------
       0     8  nValue               native DINU in koinu, LE
       8   1-9  scriptLen            compact size
       9     n  scriptPubKey         locking script
     9+n    32  assetCommitment      sha256d(mint_pubkey || b"inu-asset-v1")
    41+n     8  assetAmount          base units, LE, respects mint decimals
    ------  ----  -----------------  ---------------------------------------
                                     all-zero commitment ⇒ fields omitted
                                     and the output is byte-identical to
                                     an upstream Dogecoin output

pub fn translate(ix: &TokenInstruction, ctx: &Ctx) -> Result<Script, ShimError> {
    match ix {
        TokenInstruction::Transfer { amount } => {
            let src = ctx.account(0)?;
            let dst = ctx.account(1)?;
            let owner = ctx.signer(2)?;

            Ok(Script::builder()
                .push_slice(&commitment_of(src)?)   // which asset
                .push_slice(&dst.to_bytes())        // where it goes
                .push_int(*amount as i64)           // how much, base units
                .push_slice(&owner.to_bytes())      // who authorised it
                .push_opcode(OP_SPLXFER)
                .into_script())
        }

        TokenInstruction::MintTo { amount } => {
            let mint = ctx.account(0)?;
            let dst = ctx.account(1)?;
            let authority = ctx.signer(2)?;

            // The authority must match what the chain currently records for
            // this mint, not what the caller claims. Consensus re-reads it.
            Ok(Script::builder()
                .push_slice(&commitment_of(mint)?)
                .push_slice(&dst.to_bytes())
                .push_int(*amount as i64)
                .push_slice(&authority.to_bytes())
                .push_opcode(OP_SPLMINT)
                .into_script())
        }

        TokenInstruction::Approve { .. } => Err(ShimError::Unsupported {
            instruction: "Approve",
            reason: "delegated spend has no UTXO equivalent; use a 2-of-2 multisig output",
        }),

        other => Err(ShimError::Unsupported {
            instruction: other.name(),
            reason: "not in the consensus-relevant subset",
        }),
    }
}

case OP_SPLXFER:
{
    if (!(flags & SCRIPT_VERIFY_INU_ASSETS)) break;   // pre-activation: no-op
    if (stack.size() < 4)
        return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION);

    const valtype& vchOwner      = stacktop(-1);
    const CScriptNum amount      (stacktop(-2), fRequireMinimal, 8);
    const valtype& vchDest       = stacktop(-3);
    const valtype& vchCommitment = stacktop(-4);

    if (vchCommitment.size() != 32) return set_error(serror, SCRIPT_ERR_INU_BAD_COMMITMENT);
    if (vchDest.size() != 32)       return set_error(serror, SCRIPT_ERR_INU_BAD_DEST);
    if (amount <= 0)                return set_error(serror, SCRIPT_ERR_INU_BAD_AMOUNT);

    // The signature covers the commitment, destination and amount, so a
    // relay node cannot re-point a transfer at itself without invalidating it.
    if (!checker.CheckAssetAuthorisation(vchOwner, vchCommitment, vchDest,
                                         amount.getint64(), SIGVERSION_INU))
        return set_error(serror, SCRIPT_ERR_INU_BAD_AUTH);

    popstack(stack); popstack(stack); popstack(stack); popstack(stack);
    stack.push_back(vchTrue);
    nComputeUnits += CU_SPLXFER;
    if (nComputeUnits > MAX_TX_COMPUTE_UNITS)
        return set_error(serror, SCRIPT_ERR_INU_CU_EXCEEDED);
}
break;

// Mirrors spl_associated_token_account::get_associated_token_address,
// with "inu-ata-v1" appended so a Solana ATA and a Doge Inu ATA for the
// same (owner, mint) pair are always different accounts.
uint256 DeriveAssociatedTokenAccount(const CPubKey256& owner,
                                     const uint256& mint)
{
    std::vector<unsigned char> seeds;
    seeds.insert(seeds.end(), owner.begin(), owner.end());
    seeds.insert(seeds.end(), INU_TOKEN_PROGRAM_ID.begin(), INU_TOKEN_PROGRAM_ID.end());
    seeds.insert(seeds.end(), mint.begin(), mint.end());
    seeds.insert(seeds.end(), INU_ATA_DOMAIN.begin(), INU_ATA_DOMAIN.end());

    for (uint8_t bump = 255; bump > 0; --bump) {
        seeds.push_back(bump);
        uint256 candidate = Sha256(seeds);
        seeds.pop_back();

        // Reject anything that lands on the ed25519 curve: those have a
        // private key somewhere and must not be program-controlled.
        if (!IsOnEd25519Curve(candidate)) return candidate;
    }
    throw std::runtime_error("no off-curve ATA found (probability ~2^-255)");
}

$ cargo install --locked inu-validator
$ inu-validator init --identity ~/.inu/identity.json --network mainnet
$ inu-validator stake register \
    --amount 250000 \
    --commission 5 \
    --withdraw-authority ~/.inu/withdraw.json

registered vote account  VoTeQx7n2mK9pL4rW8sT1yB6cH3gJ5dF0aZ...
stake activating         250000 DINU, live at epoch 1482 (in 6h 11m)
commission               5%
identity                 iNuId3nT8wQ2eR7tY1uI6oP0aS9dF4gH...

$ inu-validator run --node http://127.0.0.1:22555 --zmq tcp://127.0.0.1:28332
[00:00:00] gossip: joined mesh, 1204 peers, shred version 41207
[00:00:02] tower: loaded 31 lockouts, root slot 812604118
[00:00:02] anchor: settlement tip 5417392, scrypt work verified
[00:00:03] vote: slot 812608850 -> submitted (lockout 2)
[00:00:03] vote: slot 812608851 -> submitted (lockout 2)
[00:00:04] finality: slot 812608850 rooted, 68.4% stake, 1.61s

$ sudo apt install -y build-essential libtool autotools-dev automake pkg-config \
      bsdmainutils python3 libevent-dev libboost-dev libdb5.3++-dev libsodium-dev

$ git clone https://github.com/dogeinu/dogeinu-core.git
$ cd dogeinu-core
$ git checkout v1.14.7-inu
$ ./autogen.sh
$ ./configure --with-incompatible-bdb --enable-inu-assets --disable-tests
$ make -j$(nproc)

$ cat > ~/.dogeinu/dogeinu.conf <<'EOF'
server=1
txindex=1
splindex=1
dbcache=6000
maxmempool=1200
zmqpubhashblock=tcp://127.0.0.1:28332
rpcbind=127.0.0.1
rpcport=22555
EOF

$ ./src/dogeinud -daemon
$ ./src/dogeinu-cli getblockchaininfo | jq '{blocks, assetcommitments, verificationprogress}'
{
  "blocks": 5417392,
  "assetcommitments": 38114,
  "verificationprogress": 0.9999981
}

{
  "mint": "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PB5wBQZ",
  "symbol": "WOW",
  "name": "WOWCOIN",
  "decimals": 6,
  "supply": "1000000000.000000",
  "holders": 4182,
  "mint_authority": "DiNuQq8xYx4FhVvJ2rC1mA6KeT9sW3uB7nZpLk5gH4dR",
  "freeze_authority": null,
  "authority_live": true,
  "created_at_height": 5401882,
  "created_at_slot": 810288211,
  "rent_output": { "txid": "4f1a2e9c...97a3", "vout": 1, "value": "1.00000000" },
  "asset_root_at_tip": "e70bd5c81f9a2364...44c1"
}

  hour   blocks   tx/blk   asset%   val p50   val p99   utxo GB   reorgs   faults
  ----   ------   ------   ------   -------   -------   -------   ------   ------
     1      240    1,880    39.4%     54 ms    381 ms      9.91        0        0
     4      960    2,140    40.1%     56 ms    394 ms     10.28        1        0
     8    1,920    2,301    41.8%     57 ms    402 ms     10.74        1        0
    12    2,880    2,288    40.6%     58 ms    399 ms     11.02        2        0
    16    3,840    2,412    40.2%     58 ms    404 ms     11.19        2        0
    20    4,800    2,390    39.8%     59 ms    411 ms     11.31        3        0
    24    5,760    2,366    40.0%     58 ms    402 ms     11.44        3        0

  peak sustained throughput      14,880 tx/s  (asset plane, 400ms slots)
  peak settlement throughput         39 tx/s  (block-size bound, unchanged)
  finality p50 / p99             1.61s / 12.4s
  conservation faults                     0
  asset root mismatches                   0