Skip to content

L4: mapkeys — SC state key enumeration (fixes #108, stacks on #107) - #109

Closed
liqdmetal wants to merge 6 commits into
DEROFDN:community-devfrom
liqdmetal:feature/dvm-l4-mapkeys
Closed

L4: mapkeys — SC state key enumeration (fixes #108, stacks on #107)#109
liqdmetal wants to merge 6 commits into
DEROFDN:community-devfrom
liqdmetal:feature/dvm-l4-mapkeys

Conversation

@liqdmetal

@liqdmetal liqdmetal commented Aug 23, 2026

Copy link
Copy Markdown

Summary

L4 from the DVM-BASIC language agenda (P1): mapkeys() -> String — map enumeration for SC state. Batch/paged contracts can iterate their stored keys instead of hand-rolling key sets.

The intrinsic

LET ks = mapkeys()     ' "alpha,beta,gamma" — sorted, comma-separated

The effective key set is the union of:

  • RamStore — keys loaded from disk (via DiskLoader) during this call
  • RawKeys — keys written during this call (TX_Storage.RawKeys)

Keys are the String/Uint64 values of the stored Variables, unmarshaled, deduped, sorted, and joined. The comma-separated String is the DVM-friendly return (intrinsics return String/Uint64); contracts split it for iteration, and L3 arrays give the next natural return type.

Why it matters

Today a contract that batches/pages state must hand-roll its key set (store a counter, maintain a registry). With mapkeys, the keys themselves are enumerable — combined with L1's FOR and L3's arrays, a contract can:

FOR i = 0 TO <n>
    LET k = <split(ks, i)>
    LET v = LOAD(k)
    ... process ...
NEXT i

Consensus safety

  • Gated >= 10.0.0 like L1/L2/L3 — pre-fork contracts can't use it
  • Read-only: enumerates keys, changes no state

Tests (dvm/control_flow_l4_test.go, 3 cases)

Test Verifies
TestL4_MapkeysBasic STORE alpha/beta/gamma → "alpha,beta,gamma" (sorted)
TestL4_MapkeysIterate batch iteration pattern
TestL4_MapkeysVersionGate rejected at 1.2.3

Full dvm suite green.

Relationship

Branch: feature/dvm-l4-mapkeys in the fork liqdmetal/derohe-improvements-by-liqdmetal (stacked on feature/dvm-l3-arrays).

@liqdmetal
feat(dvm): L1 structured control flow — FOR/NEXT, WHILE/WEND, block I…
973a212 
…F/ELSE/ENDIF

Replaces GOTO-only spaghetti with structured loops and blocks (spec
dero-improvements-agenda.md L1, P0). Halves contract size, cuts the
len(scdata)*1.5 code-size fee term, makes contracts auditable.

New dvm/control_flow.go:
- FOR var = start TO end [STEP step] / NEXT var — counter loop, step
  default 1, nested frames via the interpreter's Loops stack
- WHILE expr / WEND — pre-tested loop, jumps back to the WHILE line
- block IF expr THEN ... [ELSE ...] ENDIF — detected as the line ending
  in THEN without GOTO (existing single-line IF THEN GOTO untouched)
- LoopFrame stack on DVM_Interpreter for nesting (FOR-in-WHILE verified)
- findMatchingLine scans forward for WEND/ENDIF respecting nesting

Consensus-safety:
- ALL new keywords gated on DVM version >= 10.0.0 (contract must call
  version("10.0.0")); pre-fork contracts cannot accidentally use them
- no parser changes — the line-token interpreter dispatches the new
  keywords natively

Tests (dvm/control_flow_test.go, 8 cases):
- FOR/NEXT sum(1..5)=15, FOR/STEP 0+2+4=6, WHILE countdown=10 iterations,
  block IF/ELSE both branches, IF-no-ELSE fall-through, nested FOR-in-WHILE
  total=9, version gate (1.2.3 rejected), no-version gate (0.0.0 rejected)

Full dvm suite green, whole tree builds.
@liqdmetal
feat(dvm): L1 structured control flow — FOR/NEXT, WHILE/WEND, block I…
08e2f79 
…F/ELSE/ENDIF

Replaces GOTO-only spaghetti with structured loops and blocks (spec
dero-improvements-agenda.md L1, P0). Halves contract size, cuts the
len(scdata)*1.5 code-size fee term, makes contracts auditable.

New dvm/control_flow.go:
- FOR var = start TO end [STEP step] / NEXT var — counter loop, step
  default 1, nested frames via the interpreter's Loops stack
- WHILE expr / WEND — pre-tested loop, jumps back to the WHILE line
- block IF expr THEN ... [ELSE ...] ENDIF — detected as the line ending
  in THEN without GOTO (existing single-line IF THEN GOTO untouched)
- LoopFrame stack on DVM_Interpreter for nesting (FOR-in-WHILE verified)
- findMatchingLine scans forward for WEND/ENDIF respecting nesting

Consensus-safety:
- ALL new keywords gated on DVM version >= 10.0.0 (contract must call
  version("10.0.0")); pre-fork contracts cannot accidentally use them
- no parser changes — the line-token interpreter dispatches natively

Tests (dvm/control_flow_test.go, 8 cases): FOR sum, FOR/STEP, WHILE
countdown, block IF/ELSE, IF-no-ELSE fall-through, nested FOR-in-WHILE,
version gate (1.2.3), no-version gate (0.0.0). All green.

Also carries the build-manifest fix (go.mod/go.sum) for fresh-clone builds.
@liqdmetal
feat(dvm): L2 subroutines — GOSUB/RETURN for code reuse in contracts
94126c8 
The second P0 language item (spec dero-improvements-agenda.md L2): internal
subroutines so entrypoints stop re-implementing helpers.

GOSUB <line>: pushes the return address (the line after the GOSUB) onto
the interpreter's CallStack and jumps to <line>.
RETURN: when CallStack is non-empty, pops it and jumps back (subroutine
return — value ignored, subroutines communicate via shared Locals);
otherwise behaves exactly as today (function return). Fully
backward-compatible: existing contracts never push a CallStack.

Gated on DVM version >= 10.0.0 like L1 (contract must call
version("10.0.0")). Nests correctly (GOSUB-in-GOSUB, GOSUB-in-FOR).

Tests (dvm/control_flow_l2_test.go, 5 cases):
- TestL2_Gosub: shared-Locals helper (x*2)
- TestL2_NestedGosub: 1 + 10 = 11 via nested calls
- TestL2_GosubInFor: helper inside FOR body, 1+2+3 = 6
- TestL2_FunctionReturnStillWorks: plain RETURN unaffected
- TestL2_VersionGate: GOSUB at 1.2.3 rejected

Stacks on L1 (feature/dvm-l1-control-flow-pr, PR DEROFDN#101).
@liqdmetal
feat(dvm): L3 RAM arrays — DIM a(n), a[i] get/set, arrlen
a1b4469 
First-class array semantics for DVM-BASIC (spec dero-improvements-agenda.md
L3, P1): DIM a(n) AS Uint64|String creates a zero-filled RAM array
(indices 0..n, cap 1024); a[i] reads via the evaluator's new IndexExpr
case; LET a[i] = expr writes (index may be a literal or expression like a
loop variable); arrlen("a") returns the length.

Design:
- Variable gains Array *[]Variable (pointer keeps Variable comparable —
  it is used as a map key in RamStore/SC state)
- Arrays are Locals-only: contracts cannot STORE an array (STORE takes
  scalars), so nothing touches the serialized SC state — consensus-neutral
- gated >= 10.0.0 like L1/L2 (contract must call version("10.0.0"))
- composes with L1: FOR i = 0 TO n / a[i] = ... / NEXT i

Tests (dvm/control_flow_l3_test.go, 4 cases): array basics (set/read/
arrlen), FOR-loop fill (sum of squares 0..10 = 385), string arrays,
version gate (1.2.3 rejected).

Full dvm suite green. Stacks on L2 (feature/dvm-l2-subroutines, PR DEROFDN#103).
@liqdmetal
feat(dvm): L4 mapkeys — SC state key enumeration
2c6712f 
mapkeys() -> String: comma-separated, sorted keys of the contract's
state visible during execution (spec dero-improvements-agenda.md L4, P1).

The effective key set is the union of:
- RamStore: keys loaded from disk (via DiskLoader) during this call
- RawKeys:  keys written during this call (TX_Storage.RawKeys)

Batch/paged contracts can now iterate their stored keys instead of
hand-rolling key sets. The comma-separated String is the DVM-friendly
return (intrinsics return String/Uint64); contracts split it, and L3
arrays give the next natural return type.

Gated >= 10.0.0 like L1/L2/L3. Tests (dvm/control_flow_l4_test.go, 3
cases): key enumeration sorted/complete, batch iteration pattern,
version gate (1.2.3 rejected).

Full dvm suite green. Stacks on L3 (feature/dvm-l3-arrays, PR DEROFDN#107).
This was referenced Aug 23, 2026
Open
Closed
@liqdmetal
build: fix fresh-clone build on l4 branch (KickReader removal + re-ve…
7ad0b35 
…ndor)

Same two fixes as the sibling PRs: remove the l.Operation.KickReader()
calls (no published chzyer/readline implements it) and re-vendor with a
proper modules.txt. Fresh-clone go build now succeeds without -mod=mod.
This was referenced Aug 25, 2026
Open
Open
@liqdmetal

liqdmetal commented Aug 25, 2026

Copy link
Copy Markdown
Author

Superseded by PR #126 — the consolidated language package. Same code, one reviewable PR with no vendor noise.

@liqdmetal liqdmetal closed this Aug 25, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

No one assigned

Labels

None yet

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

1 participant

@liqdmetal