A Seed signature can register an intent; it does not deliver NCK

const result = await wallet.provider.connect();
    const publicKey = publicKeyToString(result?.publicKey || wallet.provider.publicKey);
    if (!publicKey) throw new Error(text("status.actions.missingPublicKey"));
    const walletChanged = publicKey !== seedState.wallet;
    seedState = transitionSeedWallet(seedState, publicKey);
    seedState = {
      ...seedState,
      provider: wallet.provider,
      walletName: wallet.name,
      error: "",
    };
    bindSeedWalletEvents(wallet.provider, wallet.name);
    if (walletChanged) clearStoredSeedEntry();
    localStorage.setItem(seedWalletStorageKey, publicKey);
    await ensureSeedWalletNetwork(wallet.provider);
    persistConnectedWallet({ walletAddress: publicKey, walletName: wallet.name });
    await refreshEntryStatus(publicKey);

This current client excerpt begins after the player chose Connect. It accepts a public key, changes the local state, stores the Seed address, applies the shared wallet binding, and queries the central status endpoint. It does not sign a message or transaction here.

1. 1-3

   Ask the external provider to connect, convert the returned public key to text, and reject a missing address.

2. 4-11

   Detect an account change, clear prior registration trust through the state transition, attach the live provider, and listen for later account or disconnect events.

3. 12-17

   Clear a stale entry when needed, store the address, attempt the client network policy, update the shared binding, and query the central registration by public address.

now = int(time.time())
        nonce = secrets.token_urlsafe(24)
        issued_at = utc_now_iso()
        message = "\n".join([
            "NiceChunk Player Whitelist Registration",
            f"Registration ID: {CAMPAIGN_ID}",
            f"Wallet: {wallet}",
            f"Nonce: {nonce}",
            f"Issued At: {issued_at}",
            f"Origin: {origin}",
            "Purpose: Prove control of this wallet and submit a free player-whitelist registration.",
            "This signature does not authorize a transaction, transfer funds, purchase NCK, reserve a paid allocation, or make an investment.",
            "Registration requires no payment. The planned initial 100 NCK allocation for eligible whitelisted players is free.",
            "Current registration stores only a central record; it does not determine eligibility or transfer NCK.",
        ])
        with sqlite3.connect(DB_PATH) as db:
            db.execute(
                "INSERT INTO seed_challenges(nonce,wallet,message,issued_at,expires_at,ip,user_agent) VALUES(?,?,?,?,?,?,?)",
                (nonce, wallet, message, now, now + CHALLENGE_TTL_SECONDS, client_ip(self), self.headers.get("user-agent", "")[:300]),
            )

The server creates freshness data, constructs the complete readable message, and writes a central challenge row before a wallet signs. The origin variable was read from client JSON earlier; this excerpt does not authenticate it against the request host.

1. 1-3

   Capture integer server time, generate a random URL-safe nonce from 24 random bytes, and format a UTC issue time.

2. 4-13

   Join the title, registration ID, wallet, nonce, issue time, client-supplied origin, purpose, no-transaction and no-purchase terms, planned free-allocation policy, and central-record-only boundary into exact newline-separated text.

3. 14-18

   Store nonce, wallet, exact message, issue and expiry times, IP string, and User-Agent in SQLite before returning the challenge.

const encodedMessage = new TextEncoder().encode(challenge.message);
    const signResult = await seedState.provider.signMessage(encodedMessage, "utf8");
    const signature = signatureToBytes(signResult);
    if (!signature?.length) throw new Error(text("status.actions.missingSignature"));
    if (!nacl.sign.detached.verify(encodedMessage, signature, bs58.decode(seedState.wallet))) {
      throw new Error(text("status.actions.localVerificationFailed"));
    }
    setSeedMessage(
      text("status.actions.submittingState"),
      text("status.actions.submittingMessage"),
    );
    const result = await apiPost("/api/seed/join", {
      wallet: seedState.wallet,
      walletName: seedState.walletName || selectedWallet?.name || "Solana Wallet",
      nonce: challenge.nonce,
      message: challenge.message,
      signature: bs58.encode(signature),
    });

TextEncoder produces the bytes the wallet signs. TweetNaCl verifies those same bytes with the current public key. Only then are the wallet, unsigned wallet label, nonce, full message, and Base58 signature sent to the central join endpoint.

1. 1-4

   Encode the API message as UTF-8, request signMessage, normalize the wallet result, and require nonempty signature bytes.

2. 5-7

   Verify message, detached signature, and decoded wallet public key locally; stop before join when they do not match.

3. 8-15

   Report local verification and submit the central registration inputs. No transaction object, instruction, fee payer, or RPC submission appears.

now = int(time.time())
        with sqlite3.connect(DB_PATH) as db:
            db.row_factory = sqlite3.Row
            challenge = db.execute("SELECT * FROM seed_challenges WHERE nonce=?", (nonce,)).fetchone()
            if not challenge:
                return json_response(self, 400, {"ok": False, "error": "challenge_not_found"})
            if challenge["used_at"]:
                return json_response(self, 409, {"ok": False, "error": "challenge_used"})
            if challenge["expires_at"] < now:
                return json_response(self, 400, {"ok": False, "error": "challenge_expired"})
            if challenge["wallet"] != wallet or challenge["message"] != message:
                return json_response(self, 400, {"ok": False, "error": "challenge_mismatch"})
            try:
                Ed25519PublicKey.from_public_bytes(public_key).verify(signature_bytes, message.encode("utf-8"))
            except InvalidSignature:
                return json_response(self, 401, {"ok": False, "error": "signature_invalid"})

The central service makes its own decision. It loads the nonce, checks normal replay and expiry conditions, requires wallet and full message equality, and verifies the detached signature. Passing this block is still only permission to continue into the central database write.

1. 1-4

   Read current server time and load the complete challenge row by its parameter-bound nonce.

2. 5-12

   Return separate missing, used, and expired errors; a wallet mismatch or message mismatch shares the same challenge_mismatch error.

3. 13-16

   Verify the 64-byte signature over the submitted UTF-8 message with the submitted wallet public key and reject an invalid signature.

CREATE TABLE IF NOT EXISTS seed_whitelist_entries (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                campaign_id TEXT NOT NULL,
                wallet TEXT NOT NULL UNIQUE,
                wallet_name TEXT,
                signature TEXT NOT NULL,
                message TEXT NOT NULL,
                nonce TEXT NOT NULL UNIQUE,
                status TEXT NOT NULL DEFAULT 'registered',
                planned_allocation_nck INTEGER NOT NULL DEFAULT 100,
                allocation_status TEXT NOT NULL DEFAULT 'planned_policy_not_entitlement',
                ip TEXT,
                user_agent TEXT,
                created_at TEXT NOT NULL,
                updated_at TEXT NOT NULL
            )

This table is the central registration authority for the whitelist flow. It stores a planned-policy quantity and an explicit non-entitlement allocation status. It has no mint, token account, base-unit amount, eligibility decision, payout transaction, slot, commitment, or token balance field.

1. 1-4

   Create a central table with an auto-increment ID, campaign label, and wallet that is globally unique across all campaigns.

2. 5-8

   Store the wallet label, detached signature, exact signed message, and a unique nonce.

3. 9-10

   Default the central status to registered and the central reward metadata integer to 100.

4. 11-15

   Store IP, User-Agent, creation time, and update time. No source retention or user-deletion rule appears in the schema.

existing = db.execute("SELECT id,created_at FROM seed_whitelist_entries WHERE wallet=?", (wallet,)).fetchone()
            if existing:
                db.execute(
                    "UPDATE seed_whitelist_entries SET wallet_name=?, signature=?, message=?, nonce=?, status='registered', ip=?, user_agent=?, updated_at=? WHERE wallet=?",
                    (wallet_name, signature, message, nonce, client_ip(self), self.headers.get("user-agent", "")[:300], created_at, wallet),
                )
                entry_id = existing["id"]
                first_created = existing["created_at"]
            else:
                cursor = db.execute(
                    "INSERT INTO seed_whitelist_entries(campaign_id,wallet,wallet_name,signature,message,nonce,ip,user_agent,created_at,updated_at) VALUES(?,?,?,?,?,?,?,?,?,?)",
                    (CAMPAIGN_ID, wallet, wallet_name, signature, message, nonce, client_ip(self), self.headers.get("user-agent", "")[:300], created_at, created_at),
                )
                entry_id = cursor.lastrowid
                first_created = created_at
            db.execute("UPDATE seed_challenges SET used_at=? WHERE nonce=?", (now, nonce))
            db.commit()

A known wallet is updated rather than inserted again. The current update replaces proof and request metadata, resets status to registered, preserves the original ID and created time, and does not update campaign_id. It then marks the challenge used and commits these central writes.

1. 1-8

   Look up by wallet alone; for an existing row overwrite wallet label, proof, nonce, status, IP, User-Agent, and update time while keeping the first ID and creation time.

2. 9-15

   For a new wallet insert the current campaign and proof fields, then save the new row ID and first creation time.

3. 16-17

   Mark the challenge used and commit. The read-check and used update are not one compare-and-set statement, so this is not proof of exactly-once behavior under concurrency.

export function confirmSeedEntry(state, entry, source) {
  const cleared = clearSeedEntryConfirmation(state);
  if (!confirmedEntrySources.has(source) || !entryMatchesSeedWallet(entry, state.wallet)) {
    return cleared;
  }
  return {
    ...cleared,
    entry,
    entryConfirmation: source,
    statusCheck: source === seedEntryConfirmation.status ? "confirmed" : state.statusCheck,
  };
}

export function applySeedStatusPayload(state, payload) {
  if (payload?.ok !== true) return clearSeedEntryConfirmation(state, "failed");
  if (!payload.entry) return clearSeedEntryConfirmation(state, "empty");
  const confirmed = confirmSeedEntry(state, payload.entry, seedEntryConfirmation.status);
  return isSeedRegistrationConfirmed(confirmed)
    ? confirmed
    : clearSeedEntryConfirmation(confirmed, "failed");
}

The earlier page could present any local entry as registered, including an entry for another wallet. The corrected pure state transition clears old trust first and accepts only status or join sources whose entry wallet exactly matches the current wallet. This improves the display but does not turn the central response into chain evidence.

1. 1-5

   Clear all previous registration confirmation and refuse an untrusted source or an entry whose wallet differs from the current wallet.

2. 6-11

   Retain the entry only with its trusted response source and record a confirmed status lookup when appropriate.

3. 14-20

   Treat failed and empty status payloads as no confirmation; route a nonempty response through exact-wallet matching and clear it again if that test fails.

fn transfer_nck<'a>(
    source_token: &AccountInfo<'a>,
    destination_token: &AccountInfo<'a>,
    nck_mint: &AccountInfo<'a>,
    owner: &AccountInfo<'a>,
    token_program: &AccountInfo<'a>,
    amount: u64,
) -> ProgramResult {
    let ix = spl_token::instruction::transfer_checked(
        token_program.key,
        source_token.key,
        nck_mint.key,
        destination_token.key,
        owner.key,
        &[],
        amount,
        NCK_DECIMALS,
    )
    .map_err(|_| NicechunkMarketError::InvalidInstruction)?;
    invoke(
        &ix,
        &[
            source_token.clone(),
            nck_mint.clone(),
            destination_token.clone(),
            owner.clone(),
            token_program.clone(),
        ],
    )
}

This Marketplace helper is a comparison, not part of Seed. Its caller first validates the exact NCK mint, Token Program, and token-account owners. The helper then builds a checked transfer with source, destination, mint, authority, amount, and decimals and invokes the Token Program. Seed contains no corresponding call.

1. 1-8

   Require explicit source token account, destination token account, mint, signing owner, Token Program, and integer base-unit amount.

2. 9-18

   Build transfer_checked with those accounts, the amount, and NCK_DECIMALS so the instruction is bound to the mint's unit scale.

3. 19-29

   Invoke the Token Program with all required accounts. A transaction must still execute successfully before any later balance claim.