reduce tx naming overload (#2952)

* if it's a db function, use `txFrame...`
* if it's not a db function, don't use `txFrame...`

hive_integration/nodocker/engine/node.nim

@@ -42,7 +42,7 @@ proc processBlock(
   ## implementations (but can be savely removed, as well.)
   ## variant of `processBlock()` where the `header` argument is explicitely set.
   template header: Header = blk.header
-  var dbTx = vmState.com.db.ctx.newTransaction()
+  var dbTx = vmState.com.db.ctx.txFrameBegin()
   defer: dbTx.dispose()
 
   let com = vmState.com
@@ -89,7 +89,7 @@ proc getVmState(c: ChainRef, header: Header):
 # intended to accepts invalid block
 proc setBlock*(c: ChainRef; blk: Block): Result[void, string] =
   template header: Header = blk.header
-  let dbTx = c.db.ctx.newTransaction()
+  let dbTx = c.db.ctx.txFrameBegin()
   defer: dbTx.dispose()
 
   # Needed for figuring out whether KVT cleanup is due (see at the end)

nimbus/core/chain/forked_chain.nim

@@ -140,7 +140,7 @@ proc validateBlock(c: ForkedChainRef,
           parent: Header,
           blk: Block,
           updateCursor: bool = true): Result[void, string] =
-  let dbTx = c.db.ctx.newTransaction()
+  let dbTx = c.db.ctx.txFrameBegin()
   defer:
     dbTx.dispose()
 
@@ -170,7 +170,7 @@ proc replaySegment*(c: ForkedChainRef, target: Hash32) =
       prevHash = chain[^1].header.parentHash
 
   c.stagingTx.rollback()
-  c.stagingTx = c.db.ctx.newTransaction()
+  c.stagingTx = c.db.ctx.txFrameBegin()
   c.cursorHeader = c.baseHeader
   for i in countdown(chain.high, chain.low):
     c.validateBlock(c.cursorHeader, chain[i],
@@ -432,7 +432,7 @@ proc updateHeadIfNecessary(c: ForkedChainRef, pvarc: PivotArc) =
   if c.cursorHash != pvarc.cursor.hash:
     if not c.stagingTx.isNil:
       c.stagingTx.rollback()
-    c.stagingTx = c.db.ctx.newTransaction()
+    c.stagingTx = c.db.ctx.txFrameBegin()
     c.replaySegment(pvarc.pvHash)
 
   c.trimCursorArc(pvarc)
@@ -442,7 +442,7 @@ proc updateHeadIfNecessary(c: ForkedChainRef, pvarc: PivotArc) =
 
   if c.stagingTx.isNil:
     # setHead below don't go straight to db
-    c.stagingTx = c.db.ctx.newTransaction()
+    c.stagingTx = c.db.ctx.txFrameBegin()
 
   c.setHead(pvarc)
 
@@ -511,7 +511,7 @@ proc importBlock*(c: ForkedChainRef, blk: Block): Result[void, string] =
   # Try to import block to canonical or side chain.
   # return error if the block is invalid
   if c.stagingTx.isNil:
-    c.stagingTx = c.db.ctx.newTransaction()
+    c.stagingTx = c.db.ctx.txFrameBegin()
 
   template header(): Header =
     blk.header
@@ -521,7 +521,7 @@ proc importBlock*(c: ForkedChainRef, blk: Block): Result[void, string] =
 
   if header.parentHash == c.baseHash:
     c.stagingTx.rollback()
-    c.stagingTx = c.db.ctx.newTransaction()
+    c.stagingTx = c.db.ctx.txFrameBegin()
     return c.validateBlock(c.baseHeader, blk)
 
   if header.parentHash notin c.blocks:
@@ -601,7 +601,7 @@ proc forkChoice*(c: ForkedChainRef,
 
   # Write segment from base+1 to newBase into database
   c.stagingTx.rollback()
-  c.stagingTx = c.db.ctx.newTransaction()
+  c.stagingTx = c.db.ctx.txFrameBegin()
 
   if newBase.pvNumber > c.baseHeader.number:
     c.replaySegment(newBase.pvHash)
@@ -616,7 +616,7 @@ proc forkChoice*(c: ForkedChainRef,
   if c.stagingTx.isNil:
     # replaySegment or setHead below don't
     # go straight to db
-    c.stagingTx = c.db.ctx.newTransaction()
+    c.stagingTx = c.db.ctx.txFrameBegin()
 
   # Move chain state forward to current head
   if newBase.pvNumber < pvarc.pvNumber:

nimbus/core/chain/persist_blocks.nim

@@ -117,6 +117,9 @@ proc persistBlock*(p: var Persister, blk: Block): Result[void, string] =
 
   let c = p.c
 
+  if p.dbTx == nil:
+    p.dbTx = p.c.db.ctx.txFrameBegin()
+
   # Full validation means validating the state root at every block and
   # performing the more expensive hash computations on the block itself, ie
   # verifying that the transaction and receipts roots are valid - when not

nimbus/core/tx_pool/tx_packer.nim

@@ -292,7 +292,7 @@ proc packerVmExec*(xp: TxPoolRef): Result[TxPacker, string]
   ## Rebuild `packed` bucket by selection items from the `staged` bucket
   ## after executing them in the VM.
   let db = xp.vmState.com.db
-  let dbTx = db.ctx.newTransaction()
+  let dbTx = db.ctx.txFrameBegin()
   defer: dbTx.dispose()
 
   var pst = xp.vmExecInit.valueOr:

nimbus/db/aristo/aristo_api.nim

@@ -178,7 +178,7 @@ type
       ## Getter, returns `true` if the argument `tx` referes to the current
       ## top level transaction.
 
-  AristoApiLevelFn* =
+  AristoApiTxFrameLevelFn* =
     proc(db: AristoDbRef;
         ): int
         {.noRaise.}
@@ -310,7 +310,7 @@ type
       ## operations performed for this transactio. The previous transaction
       ## is returned if there was any.
 
-  AristoApiTxBeginFn* =
+  AristoApiTxFrameBeginFn* =
     proc(db: AristoDbRef;
         ): Result[AristoTxRef,AristoError]
         {.noRaise.}
@@ -324,13 +324,7 @@ type
       ##     ... continue using db ...
       ##     tx.commit()
 
-  AristoApiTxLevelFn* =
+  AristoApiTxFrameTopFn* =
-    proc(tx: AristoTxRef;
-        ): int
-        {.noRaise.}
-      ## Getter, positive nesting level of transaction argument `tx`
-
-  AristoApiTxTopFn* =
     proc(db: AristoDbRef;
         ): Result[AristoTxRef,AristoError]
         {.noRaise.}
@@ -358,7 +352,7 @@ type
     hasStorageData*: AristoApiHasStorageDataFn
 
     isTop*: AristoApiIsTopFn
-    level*: AristoApiLevelFn
+    txFrameLevel*: AristoApiTxFrameLevelFn
 
     mergeAccountRecord*: AristoApiMergeAccountRecordFn
     mergeStorageData*: AristoApiMergeStorageDataFn
@@ -373,9 +367,8 @@ type
     pathAsBlob*: AristoApiPathAsBlobFn
     persist*: AristoApiPersistFn
     rollback*: AristoApiRollbackFn
-    txBegin*: AristoApiTxBeginFn
+    txFrameBegin*: AristoApiTxFrameBeginFn
-    txLevel*: AristoApiTxLevelFn
+    txFrameTop*: AristoApiTxFrameTopFn
-    txTop*: AristoApiTxTopFn
 
 
   AristoApiProfNames* = enum
@@ -414,9 +407,8 @@ type
     AristoApiProfPathAsBlobFn           = "pathAsBlob"
     AristoApiProfPersistFn              = "persist"
     AristoApiProfRollbackFn             = "rollback"
-    AristoApiProfTxBeginFn              = "txBegin"
+    AristoApiProfTxFrameBeginFn              = "txFrameBegin"
-    AristoApiProfTxLevelFn              = "txLevel"
+    AristoApiProfTxFrameTopFn                = "txFrameTop"
-    AristoApiProfTxTopFn                = "txTop"
 
     AristoApiProfBeGetVtxFn             = "be/getVtx"
     AristoApiProfBeGetKeyFn             = "be/getKey"
@@ -471,9 +463,8 @@ when AutoValidateApiHooks:
     doAssert not api.pathAsBlob.isNil
     doAssert not api.persist.isNil
     doAssert not api.rollback.isNil
-    doAssert not api.txBegin.isNil
+    doAssert not api.txFrameBegin.isNil
-    doAssert not api.txLevel.isNil
+    doAssert not api.txFrameTop.isNil
-    doAssert not api.txTop.isNil
 
   proc validate(prf: AristoApiProfRef) =
     prf.AristoApiRef.validate
@@ -520,7 +511,7 @@ func init*(api: var AristoApiObj) =
   api.hasStorageData = hasStorageData
 
   api.isTop = isTop
-  api.level = level
+  api.txFrameLevel = txFrameLevel
 
   api.mergeAccountRecord = mergeAccountRecord
   api.mergeStorageData = mergeStorageData
@@ -533,9 +524,8 @@ func init*(api: var AristoApiObj) =
   api.pathAsBlob = pathAsBlob
   api.persist = persist
   api.rollback = rollback
-  api.txBegin = txBegin
+  api.txFrameBegin = txFrameBegin
-  api.txLevel = txLevel
+  api.txFrameTop = txFrameTop
-  api.txTop = txTop
   when AutoValidateApiHooks:
     api.validate
 
@@ -564,7 +554,7 @@ func dup*(api: AristoApiRef): AristoApiRef =
     hasStorageData:       api.hasStorageData,
 
     isTop:                api.isTop,
-    level:                api.level,
+    txFrameLevel:              api.txFrameLevel,
 
     mergeAccountRecord:   api.mergeAccountRecord,
     mergeStorageData:     api.mergeStorageData,
@@ -577,9 +567,8 @@ func dup*(api: AristoApiRef): AristoApiRef =
     pathAsBlob:           api.pathAsBlob,
     persist:              api.persist,
     rollback:             api.rollback,
-    txBegin:              api.txBegin,
+    txFrameBegin:              api.txFrameBegin,
-    txLevel:              api.txLevel,
+    txFrameTop:                api.txFrameTop)
-    txTop:                api.txTop)
   when AutoValidateApiHooks:
     result.validate
 
@@ -730,20 +719,15 @@ func init*(
       AristoApiProfRollbackFn.profileRunner:
         result = api.rollback(a)
 
-  profApi.txBegin =
+  profApi.txFrameBegin =
     proc(a: AristoDbRef): auto =
-       AristoApiProfTxBeginFn.profileRunner:
+       AristoApiProfTxFrameBeginFn.profileRunner:
-        result = api.txBegin(a)
+        result = api.txFrameBegin(a)
 
-  profApi.txLevel =
+  profApi.txFrameTop =
-    proc(a: AristoTxRef): auto =
-       AristoApiProfTxLevelFn.profileRunner:
-        result = api.txLevel(a)
-
-  profApi.txTop =
     proc(a: AristoDbRef): auto =
-      AristoApiProfTxTopFn.profileRunner:
+      AristoApiProfTxFrameTopFn.profileRunner:
-        result = api.txTop(a)
+        result = api.txFrameTop(a)
 
   let beDup = be.dup()
   if beDup.isNil:

nimbus/db/aristo/aristo_desc/desc_error.nim

@@ -232,8 +232,8 @@ type
     TxArgStaleTx
     TxArgsUseless
     TxBackendNotWritable
-    TxLevelTooDeep
+    TxFrameLevelTooDeep
-    TxLevelUseless
+    TxFrameLevelUseless
     TxNoPendingTx
     TxNotFound
     TxNotTopTx

nimbus/db/aristo/aristo_tx.nim

@@ -18,26 +18,7 @@ import
   ./aristo_tx/[tx_frame, tx_stow],
   ./aristo_desc
 
-# ------------------------------------------------------------------------------
+export tx_frame
-# Public functions, getters
-# ------------------------------------------------------------------------------
-
-func txTop*(db: AristoDbRef): Result[AristoTxRef,AristoError] =
-  ## Getter, returns top level transaction if there is any.
-  db.txFrameTop()
-
-func isTop*(tx: AristoTxRef): bool =
-  ## Getter, returns `true` if the argument `tx` referes to the current top
-  ## level transaction.
-  tx.txFrameIsTop()
-
-func txLevel*(tx: AristoTxRef): int =
-  ## Getter, positive nesting level of transaction argument `tx`
-  tx.txFrameLevel()
-
-func level*(db: AristoDbRef): int =
-  ## Getter, non-negative nesting level (i.e. number of pending transactions)
-  db.txFrameLevel()
 
 # ------------------------------------------------------------------------------
 # Public functions
@@ -51,51 +32,6 @@ func to*(tx: AristoTxRef; T: type[AristoDbRef]): T =
 # Public functions: Transaction frame
 # ------------------------------------------------------------------------------
 
-proc txBegin*(db: AristoDbRef): Result[AristoTxRef,AristoError] =
-  ## Starts a new transaction.
-  ##
-  ## Example:
-  ## ::
-  ##   proc doSomething(db: AristoDbRef) =
-  ##     let tx = db.begin
-  ##     defer: tx.rollback()
-  ##     ... continue using db ...
-  ##     tx.commit()
-  ##
-  db.txFrameBegin()
-
-proc rollback*(
-    tx: AristoTxRef;                  # Top transaction on database
-      ): Result[void,AristoError] =
-  ## Given a *top level* handle, this function discards all database operations
-  ## performed for this transactio. The previous transaction is returned if
-  ## there was any.
-  ##
-  tx.txFrameRollback()
-
-proc commit*(
-    tx: AristoTxRef;                  # Top transaction on database
-      ): Result[void,AristoError] =
-  ## Given a *top level* handle, this function accepts all database operations
-  ## performed through this handle and merges it to the previous layer. The
-  ## previous transaction is returned if there was any.
-  ##
-  tx.txFrameCommit()
-
-proc collapse*(
-    tx: AristoTxRef;                  # Top transaction on database
-    commit: bool;                     # Commit if `true`, otherwise roll back
-      ): Result[void,AristoError] =
-  ## Iterated application of `commit()` or `rollback()` performing the
-  ## something similar to
-  ## ::
-  ##   while true:
-  ##     discard tx.commit() # ditto for rollback()
-  ##     if db.txTop.isErr: break
-  ##     tx = db.txTop.value
-  ##
-  tx.txFrameCollapse commit
-
 # ------------------------------------------------------------------------------
 # Public functions: save to database
 # ------------------------------------------------------------------------------
@@ -119,20 +55,7 @@ proc persist*(
   ## next recovery journal record. If non-zero, this ID must be greater than
   ## all previous IDs (e.g. block number when stowing after block execution.)
   ##
-  db.txStow(nxtSid, persistent=true)
+  db.txPersist(nxtSid)
-
-proc stow*(
-    db: AristoDbRef;                  # Database
-      ): Result[void,AristoError] =
-  ## This function is similar to `persist()` stopping short of performing the
-  ## final step storing on the persistent database. It fails if there is a
-  ## pending transaction.
-  ##
-  ## The function merges all staged data from the top layer cache onto the
-  ## backend stage area and leaves it there. This function can be seen as
-  ## a sort of a bottom level transaction `commit()`.
-  ##
-  db.txStow(nxtSid=0u64, persistent=false)
 
 # ------------------------------------------------------------------------------
 # End

nimbus/db/aristo/aristo_tx/tx_frame.nim

@@ -17,14 +17,14 @@ import
   results,
   ".."/[aristo_desc, aristo_layers]
 
-func txFrameIsTop*(tx: AristoTxRef): bool
+func isTop*(tx: AristoTxRef): bool
 
 # ------------------------------------------------------------------------------
 # Private helpers
 # ------------------------------------------------------------------------------
 
 func getDbDescFromTopTx(tx: AristoTxRef): Result[AristoDbRef,AristoError] =
-  if not tx.txFrameIsTop():
+  if not tx.isTop():
     return err(TxNotTopTx)
   let db = tx.db
   if tx.level != db.stack.len:
@@ -48,15 +48,11 @@ func txFrameTop*(db: AristoDbRef): Result[AristoTxRef,AristoError] =
   else:
     ok(db.txRef)
 
-func txFrameIsTop*(tx: AristoTxRef): bool =
+func isTop*(tx: AristoTxRef): bool =
   ## Getter, returns `true` if the argument `tx` referes to the current top
   ## level transaction.
   tx.db.txRef == tx and tx.db.top.txUid == tx.txUid
 
-func txFrameLevel*(tx: AristoTxRef): int =
-  ## Getter, positive nesting level of transaction argument `tx`
-  tx.level
-
 func txFrameLevel*(db: AristoDbRef): int =
   ## Getter, non-negative nesting level (i.e. number of pending transactions)
   if not db.txRef.isNil:
@@ -95,7 +91,7 @@ proc txFrameBegin*(db: AristoDbRef): Result[AristoTxRef,AristoError] =
   ok db.txRef
 
 
-proc txFrameRollback*(
+proc rollback*(
     tx: AristoTxRef;                  # Top transaction on database
       ): Result[void,AristoError] =
   ## Given a *top level* handle, this function discards all database operations
@@ -112,7 +108,7 @@ proc txFrameRollback*(
   ok()
 
 
-proc txFrameCommit*(
+proc commit*(
     tx: AristoTxRef;                  # Top transaction on database
       ): Result[void,AristoError] =
   ## Given a *top level* handle, this function accepts all database operations
@@ -139,7 +135,7 @@ proc txFrameCommit*(
   ok()
 
 
-proc txFrameCollapse*(
+proc collapse*(
     tx: AristoTxRef;                  # Top transaction on database
     commit: bool;                     # Commit if `true`, otherwise roll back
       ): Result[void,AristoError] =
@@ -148,8 +144,8 @@ proc txFrameCollapse*(
   ## ::
   ##   while true:
   ##     discard tx.commit() # ditto for rollback()
-  ##     if db.txTop.isErr: break
+  ##     if db.txFrameTop.isErr: break
-  ##     tx = db.txTop.value
+  ##     tx = db.txFrameTop.value
   ##
   let db = ? tx.getDbDescFromTopTx()
 
@@ -162,7 +158,7 @@ proc txFrameCollapse*(
 # Public iterators
 # ------------------------------------------------------------------------------
 
-iterator txFrameWalk*(tx: AristoTxRef): (int,AristoTxRef,LayerRef,AristoError) =
+iterator walk*(tx: AristoTxRef): (int,AristoTxRef,LayerRef,AristoError) =
   ## Walk down the transaction stack chain.
   let db = tx.db
   var tx = tx

nimbus/db/aristo/aristo_tx/tx_stow.nim

@@ -8,7 +8,7 @@
 # at your option. This file may not be copied, modified, or distributed
 # except according to those terms.
 
-## Aristo DB -- Transaction stow/save helper
+## Aristo DB -- Transaction save helper
 ## =========================================
 ##
 {.push raises: [].}
@@ -22,15 +22,14 @@ import
 # Private functions
 # ------------------------------------------------------------------------------
 
-proc txStowOk*(
+proc txPersistOk*(
     db: AristoDbRef;                  # Database
-    persistent: bool;                 # Stage only unless `true`
       ): Result[void,AristoError] =
   if not db.txRef.isNil:
     return err(TxPendingTx)
   if 0 < db.stack.len:
     return err(TxStackGarbled)
-  if persistent and not db.deltaPersistentOk():
+  if not db.deltaPersistentOk():
     return err(TxBackendNotWritable)
   ok()
 
@@ -38,14 +37,13 @@ proc txStowOk*(
 # Public functions
 # ------------------------------------------------------------------------------
 
-proc txStow*(
+proc txPersist*(
     db: AristoDbRef;                  # Database
     nxtSid: uint64;                   # Next state ID (aka block number)
-    persistent: bool;                 # Stage only unless `true`
       ): Result[void,AristoError] =
-  ## Worker for `stow()` and `persist()` variants.
+  ## Worker for `persist()` variants.
   ##
-  ? db.txStowOk persistent
+  ? db.txPersistOk()
 
   if not db.top.isEmpty():
     # Note that `deltaMerge()` will return the `db.top` argument if the
@@ -57,7 +55,6 @@ proc txStow*(
     # New empty top layer
     db.top = LayerRef(vTop: db.balancer.vTop)
 
-  if persistent:
   # Merge/move `balancer` into persistent tables (unless missing)
   ? db.deltaPersistent nxtSid
 

nimbus/db/core_db/base.nim

@@ -107,7 +107,7 @@ proc persistent*(
       if rc.isOk or rc.error == TxPersistDelayed:
         # The latter clause is OK: Piggybacking on `Aristo` backend
         discard
-      elif CoreDbKvtRef(db.ctx).call(level, db.ctx.kvt) != 0:
+      elif CoreDbKvtRef(db.ctx).call(txFrameLevel, db.ctx.kvt) != 0:
         result = err(rc.error.toError($api, TxPending))
         break body
       else:
@@ -651,37 +651,30 @@ proc recast*(
 # Public transaction related methods
 # ------------------------------------------------------------------------------
 
-proc level*(db: CoreDbRef): int =
+proc txFrameLevel*(db: CoreDbRef): int =
   ## Retrieve transaction level (zero if there is no pending transaction).
   ##
   db.setTrackNewApi BaseLevelFn
-  result = CoreDbAccRef(db.ctx).call(level, db.ctx.mpt)
+  result = CoreDbAccRef(db.ctx).call(txFrameLevel, db.ctx.mpt)
   db.ifTrackNewApi: debug logTxt, api, elapsed, result
 
-proc newTransaction*(ctx: CoreDbCtxRef): CoreDbTxRef =
+proc txFrameBegin*(ctx: CoreDbCtxRef): CoreDbTxRef =
   ## Constructor
   ##
   ctx.setTrackNewApi BaseNewTxFn
   let
-    kTx = CoreDbKvtRef(ctx).call(txBegin, ctx.kvt).valueOr:
+    kTx = CoreDbKvtRef(ctx).call(txFrameBegin, ctx.kvt).valueOr:
       raiseAssert $api & ": " & $error
-    aTx = CoreDbAccRef(ctx).call(txBegin, ctx.mpt).valueOr:
+    aTx = CoreDbAccRef(ctx).call(txFrameBegin, ctx.mpt).valueOr:
       raiseAssert $api & ": " & $error
   result = ctx.bless CoreDbTxRef(kTx: kTx, aTx: aTx)
   ctx.ifTrackNewApi:
     let newLevel = CoreDbAccRef(ctx).call(level, ctx.mpt)
     debug logTxt, api, elapsed, newLevel
 
-proc level*(tx: CoreDbTxRef): int =
-  ## Print positive transaction level for argument `tx`
-  ##
-  tx.setTrackNewApi TxLevelFn
-  result = CoreDbAccRef(tx.ctx).call(txLevel, tx.aTx)
-  tx.ifTrackNewApi: debug logTxt, api, elapsed, result
-
 proc commit*(tx: CoreDbTxRef) =
   tx.setTrackNewApi TxCommitFn:
-    let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(txLevel, tx.aTx)
+    let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(level, tx.aTx)
   CoreDbAccRef(tx.ctx).call(commit, tx.aTx).isOkOr:
     raiseAssert $api & ": " & $error
   CoreDbKvtRef(tx.ctx).call(commit, tx.kTx).isOkOr:
@@ -690,7 +683,7 @@ proc commit*(tx: CoreDbTxRef) =
 
 proc rollback*(tx: CoreDbTxRef) =
   tx.setTrackNewApi TxRollbackFn:
-    let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(txLevel, tx.aTx)
+    let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(level, tx.aTx)
   CoreDbAccRef(tx.ctx).call(rollback, tx.aTx).isOkOr:
     raiseAssert $api & ": " & $error
   CoreDbKvtRef(tx.ctx).call(rollback, tx.kTx).isOkOr:
@@ -699,7 +692,7 @@ proc rollback*(tx: CoreDbTxRef) =
 
 proc dispose*(tx: CoreDbTxRef) =
   tx.setTrackNewApi TxDisposeFn:
-    let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(txLevel, tx.aTx)
+    let prvLevel {.used.} = CoreDbAccRef(tx.ctx).call(level, tx.aTx)
   if CoreDbAccRef(tx.ctx).call(isTop, tx.aTx):
     CoreDbAccRef(tx.ctx).call(rollback, tx.aTx).isOkOr:
       raiseAssert $api & ": " & $error

nimbus/db/core_db/base/api_tracking.nim

@@ -52,7 +52,7 @@ type
     BaseFinishFn        = "finish"
     BaseLevelFn         = "level"
     BasePushCaptureFn   = "pushCapture"
-    BaseNewTxFn         = "newTransaction"
+    BaseNewTxFn         = "txFrameBegin"
     BasePersistentFn    = "persistent"
     BaseStateBlockNumberFn = "stateBlockNumber"
     BaseVerifyFn        = "verify"
@@ -77,7 +77,7 @@ type
 
     TxCommitFn          = "commit"
     TxDisposeFn         = "dispose"
-    TxLevelFn           = "level"
+    TxFrameLevelFn           = "level"
     TxRollbackFn        = "rollback"
     TxSaveDisposeFn     = "safeDispose"
 

nimbus/db/kvt/kvt_api.nim

@@ -52,14 +52,14 @@ type
   KvtApiHasKeyRcFn* = proc(db: KvtDbRef,
     key: openArray[byte]): Result[bool,KvtError] {.noRaise.}
   KvtApiIsTopFn* = proc(tx: KvtTxRef): bool {.noRaise.}
-  KvtApiLevelFn* = proc(db: KvtDbRef): int {.noRaise.}
+  KvtApiTxFrameLevelFn* = proc(db: KvtDbRef): int {.noRaise.}
   KvtApiPutFn* = proc(db: KvtDbRef,
     key, data: openArray[byte]): Result[void,KvtError] {.noRaise.}
   KvtApiRollbackFn* = proc(tx: KvtTxRef): Result[void,KvtError] {.noRaise.}
   KvtApiPersistFn* = proc(db: KvtDbRef): Result[void,KvtError] {.noRaise.}
   KvtApiToKvtDbRefFn* = proc(tx: KvtTxRef): KvtDbRef {.noRaise.}
-  KvtApiTxBeginFn* = proc(db: KvtDbRef): Result[KvtTxRef,KvtError] {.noRaise.}
+  KvtApiTxFrameBeginFn* = proc(db: KvtDbRef): Result[KvtTxRef,KvtError] {.noRaise.}
-  KvtApiTxTopFn* =
+  KvtApiTxFrameTopFn* =
     proc(db: KvtDbRef): Result[KvtTxRef,KvtError] {.noRaise.}
 
   KvtApiRef* = ref KvtApiObj
@@ -73,13 +73,13 @@ type
     len*: KvtApiLenFn
     hasKeyRc*: KvtApiHasKeyRcFn
     isTop*: KvtApiIsTopFn
-    level*: KvtApiLevelFn
+    txFrameLevel*: KvtApiTxFrameLevelFn
     put*: KvtApiPutFn
     rollback*: KvtApiRollbackFn
     persist*: KvtApiPersistFn
     toKvtDbRef*: KvtApiToKvtDbRefFn
-    txBegin*: KvtApiTxBeginFn
+    txFrameBegin*: KvtApiTxFrameBeginFn
-    txTop*: KvtApiTxTopFn
+    txFrameTop*: KvtApiTxFrameTopFn
 
 
   KvtApiProfNames* = enum
@@ -98,8 +98,8 @@ type
     KvtApiProfRollbackFn     = "rollback"
     KvtApiProfPersistFn      = "persist"
     KvtApiProfToKvtDbRefFn   = "toKvtDbRef"
-    KvtApiProfTxBeginFn      = "txBegin"
+    KvtApiProfTxFrameBeginFn      = "txFrameBegin"
-    KvtApiProfTxTopFn        = "txTop"
+    KvtApiProfTxFrameTopFn        = "txFrameTop"
 
     KvtApiProfBeGetKvpFn     = "be/getKvp"
     KvtApiProfBeLenKvpFn     = "be/lenKvp"
@@ -123,13 +123,13 @@ when AutoValidateApiHooks:
     doAssert not api.get.isNil
     doAssert not api.hasKeyRc.isNil
     doAssert not api.isTop.isNil
-    doAssert not api.level.isNil
+    doAssert not api.txFrameLevel.isNil
     doAssert not api.put.isNil
     doAssert not api.rollback.isNil
     doAssert not api.persist.isNil
     doAssert not api.toKvtDbRef.isNil
-    doAssert not api.txBegin.isNil
+    doAssert not api.txFrameBegin.isNil
-    doAssert not api.txTop.isNil
+    doAssert not api.txFrameTop.isNil
 
   proc validate(prf: KvtApiProfRef) =
     prf.KvtApiRef.validate
@@ -161,13 +161,13 @@ func init*(api: var KvtApiObj) =
   api.len = len
   api.hasKeyRc = hasKeyRc
   api.isTop = isTop
-  api.level = level
+  api.txFrameLevel = txFrameLevel
   api.put = put
   api.rollback = rollback
   api.persist = persist
   api.toKvtDbRef = toKvtDbRef
-  api.txBegin = txBegin
+  api.txFrameBegin = txFrameBegin
-  api.txTop = txTop
+  api.txFrameTop = txFrameTop
   when AutoValidateApiHooks:
     api.validate
 
@@ -184,16 +184,15 @@ func dup*(api: KvtApiRef): KvtApiRef =
     len:        api.len,
     hasKeyRc:   api.hasKeyRc,
     isTop:      api.isTop,
-    level:      api.level,
+    txFrameLevel:      api.txFrameLevel,
     put:        api.put,
     rollback:   api.rollback,
     persist:    api.persist,
     toKvtDbRef: api.toKvtDbRef,
-    txBegin:    api.txBegin,
+    txFrameBegin:    api.txFrameBegin,
-    txTop:      api.txTop)
+    txFrameTop:      api.txFrameTop)
   when AutoValidateApiHooks:
     result.validate
-
 # ------------------------------------------------------------------------------
 # Public profile API constuctor
 # ------------------------------------------------------------------------------
@@ -281,15 +280,15 @@ func init*(
        KvtApiProfToKvtDbRefFn.profileRunner:
          result = api.toKvtDbRef(a)
 
-  profApi.txBegin =
+  profApi.txFrameBegin =
     proc(a: KvtDbRef): auto =
-      KvtApiProfTxBeginFn.profileRunner:
+      KvtApiProfTxFrameBeginFn.profileRunner:
-        result = api.txBegin(a)
+        result = api.txFrameBegin(a)
 
-  profApi.txTop =
+  profApi.txFrameTop =
     proc(a: KvtDbRef): auto =
-      KvtApiProfTxTopFn.profileRunner:
+      KvtApiProfTxFrameTopFn.profileRunner:
-        result = api.txTop(a)
+        result = api.txFrameTop(a)
 
   let beDup = be.dup()
   if beDup.isNil:

nimbus/db/kvt/kvt_desc/desc_error.nim

@@ -33,8 +33,8 @@ type
     # Transaction wrappers
     TxArgStaleTx
     TxBackendNotWritable
-    TxLevelTooDeep
+    TxFrameLevelTooDeep
-    TxLevelUseless
+    TxFrameLevelUseless
     TxNoPendingTx
     TxNotTopTx
     TxPendingTx

nimbus/db/kvt/kvt_init/rocks_db.nim

@@ -185,11 +185,11 @@ proc putEndTriggeredFn(db: RdbBackendRef): PutEndFn =
         when extraTraceMessages:
           debug logTxt "putEndTriggeredFn: failed",
             error=hdl.error, info=hdl.info
-        # The error return code will signal a problem to the `txStow()`
+        # The error return code will signal a problem to the `txPersist()`
         # function which was called by `writeEvCb()` below.
         return err(hdl.error)
 
-      # Commit the session. This will be acknowledged by the `txStow()`
+      # Commit the session. This will be acknowledged by the `txPersist()`
       # function which was called by `writeEvCb()` below.
       ok()
 
@@ -229,22 +229,22 @@ proc writeEvCb(db: RdbBackendRef): RdbWriteEventCb =
         # Publish session argument
         db.rdb.session = ws
 
-        # Execute delayed session. Note the the `txStow()` function is located
+        # Execute delayed session. Note the the `txPersist()` function is located
         # in `tx_stow.nim`. This module `tx_stow.nim` is also imported by
         # `kvt_tx.nim` which contains `persist() `. So the logic goes:
         # ::
         #   kvt_tx.persist()     --> registers a delayed write request rather
-        #                            than excuting tx_stow.txStow()
+        #                            than excuting tx_stow.txPersist()
         #
         #   // the backend owner (i.e. Aristo) will start a write cycle and
         #   // invoke the envent handler rocks_db.writeEvCb()
-        #   rocks_db.writeEvCb() --> calls tx_stow.txStow()
+        #   rocks_db.writeEvCb() --> calls tx_stow.txPersist()
         #
-        #   tx_stow.txStow()     --> calls rocks_db.putBegTriggeredFn()
+        #   tx_stow.txPersist()     --> calls rocks_db.putBegTriggeredFn()
         #                            calls rocks_db.putKvpFn()
         #                            calls rocks_db.putEndTriggeredFn()
         #
-        let rc = db.rdb.delayedPersist.txStow(persistent=true)
+        let rc = db.rdb.delayedPersist.txPersist()
         if rc.isErr:
           error "writeEventCb(): persist() failed", error=rc.error
           return false

nimbus/db/kvt/kvt_tx.nim

@@ -19,26 +19,8 @@ import
   ./kvt_init/memory_only,
   ./kvt_desc
 
-# ------------------------------------------------------------------------------
+export tx_frame
-# Public functions, getters
-# ------------------------------------------------------------------------------
 
-func txTop*(db: KvtDbRef): Result[KvtTxRef,KvtError] =
-  ## Getter, returns top level transaction if there is any.
-  db.txFrameTop()
-
-func isTop*(tx: KvtTxRef): bool =
-  ## Getter, returns `true` if the argument `tx` referes to the current top
-  ## level transaction.
-  tx.txFrameIsTop()
-
-func txLevel*(tx: KvtTxRef): int =
-  ## Getter, positive nesting level of transaction argument `tx`
-  tx.txFrameLevel()
-
-func level*(db: KvtDbRef): int =
-  ## Getter, non-negative nesting level (i.e. number of pending transactions)
-  db.txFrameLevel()
 
 # ------------------------------------------------------------------------------
 # Public functions
@@ -52,55 +34,6 @@ func toKvtDbRef*(tx: KvtTxRef): KvtDbRef =
   ## Same as `.to(KvtDbRef)`
   tx.db
 
-# ------------------------------------------------------------------------------
-# Public functions: Transaction frame
-# ------------------------------------------------------------------------------
-
-proc txBegin*(db: KvtDbRef): Result[KvtTxRef,KvtError] =
-  ## Starts a new transaction.
-  ##
-  ## Example:
-  ## ::
-  ##   proc doSomething(db: KvtDbRef) =
-  ##     let tx = db.txBegin
-  ##     defer: tx.rollback()
-  ##     ... continue using db ...
-  ##     tx.commit()
-  ##
-  db.txFrameBegin()
-
-proc rollback*(
-    tx: KvtTxRef;                     # Top transaction on database
-      ): Result[void,KvtError] =
-  ## Given a *top level* handle, this function discards all database operations
-  ## performed for this transactio. The previous transaction is returned if
-  ## there was any.
-  ##
-  tx.txFrameRollback()
-
-proc commit*(
-    tx: KvtTxRef;                     # Top transaction on database
-      ): Result[void,KvtError] =
-  ## Given a *top level* handle, this function accepts all database operations
-  ## performed through this handle and merges it to the previous layer. The
-  ## previous transaction is returned if there was any.
-  ##
-  tx.txFrameCommit()
-
-proc collapse*(
-    tx: KvtTxRef;                     # Top transaction on database
-    commit: bool;                     # Commit if `true`, otherwise roll back
-      ): Result[void,KvtError] =
-  ## Iterated application of `commit()` or `rollback()` performing the
-  ## something similar to
-  ## ::
-  ##   while true:
-  ##     discard tx.commit() # ditto for rollback()
-  ##     if db.topTx.isErr: break
-  ##     tx = db.topTx.value
-  ##
-  tx.txFrameCollapse commit
-
 # ------------------------------------------------------------------------------
 # Public functions: save database
 # ------------------------------------------------------------------------------
@@ -121,24 +54,11 @@ proc persist*(
   ##
   # Register for saving if piggybacked on remote database
   if db.backend.kind == BackendRdbTriggered:
-    ? db.txStowOk(persistent=true)
+    ? db.txPersistOk()
     ? db.backend.setWrReqFn db
     return err(TxPersistDelayed)
 
-  db.txStow(persistent=true)
+  db.txPersist()
-
-proc stow*(
-    db: KvtDbRef;                     # Database
-      ): Result[void,KvtError] =
-  ## This function is similar to `persist()` stopping short of performing the
-  ## final step storing on the persistent database. It fails if there is a
-  ## pending transaction.
-  ##
-  ## The function merges all staged data from the top layer cache onto the
-  ## backend stage area and leaves it there. This function can be seen as
-  ## a sort of a bottom level transaction `commit()`.
-  ##
-  db.txStow(persistent=false)
 
 # ------------------------------------------------------------------------------
 # End

nimbus/db/kvt/kvt_tx/tx_frame.nim

@@ -18,14 +18,14 @@ import
   results,
   ".."/[kvt_desc, kvt_layers]
 
-func txFrameIsTop*(tx: KvtTxRef): bool
+func isTop*(tx: KvtTxRef): bool
 
 # ------------------------------------------------------------------------------
 # Private helpers
 # ------------------------------------------------------------------------------
 
 func getDbDescFromTopTx(tx: KvtTxRef): Result[KvtDbRef,KvtError] =
-  if not tx.txFrameIsTop():
+  if not tx.isTop():
     return err(TxNotTopTx)
   let db = tx.db
   if tx.level != db.stack.len:
@@ -49,15 +49,11 @@ func txFrameTop*(db: KvtDbRef): Result[KvtTxRef,KvtError] =
   else:
     ok(db.txRef)
 
-func txFrameIsTop*(tx: KvtTxRef): bool =
+func isTop*(tx: KvtTxRef): bool =
   ## Getter, returns `true` if the argument `tx` referes to the current top
   ## level transaction.
   tx.db.txRef == tx and tx.db.top.txUid == tx.txUid
 
-func txFrameLevel*(tx: KvtTxRef): int =
-  ## Getter, positive nesting level of transaction argument `tx`
-  tx.level
-
 func txFrameLevel*(db: KvtDbRef): int =
   ## Getter, non-negative nesting level (i.e. number of pending transactions)
   if not db.txRef.isNil:
@@ -93,7 +89,7 @@ proc txFrameBegin*(db: KvtDbRef): Result[KvtTxRef,KvtError] =
   ok db.txRef
 
 
-proc txFrameRollback*(
+proc rollback*(
     tx: KvtTxRef;                     # Top transaction on database
       ): Result[void,KvtError] =
   ## Given a *top level* handle, this function discards all database operations
@@ -110,7 +106,7 @@ proc txFrameRollback*(
   ok()
 
 
-proc txFrameCommit*(
+proc commit*(
     tx: KvtTxRef;                     # Top transaction on database
       ): Result[void,KvtError] =
   ## Given a *top level* handle, this function accepts all database operations
@@ -135,7 +131,7 @@ proc txFrameCommit*(
   ok()
 
 
-proc txFrameCollapse*(
+proc collapse*(
     tx: KvtTxRef;                     # Top transaction on database
     commit: bool;                     # Commit if `true`, otherwise roll back
       ): Result[void,KvtError] =

nimbus/db/kvt/kvt_tx/tx_stow.nim

@@ -8,7 +8,7 @@
 # at your option. This file may not be copied, modified, or distributed
 # except according to those terms.
 
-## Kvt DB -- Transaction stow/save helper
+## Kvt DB -- Transaction save helper
 ## ======================================
 ##
 {.push raises: [].}
@@ -23,22 +23,20 @@ import
 # Public functions
 # ------------------------------------------------------------------------------
 
-proc txStowOk*(
+proc txPersistOk*(
     db: KvtDbRef;                     # Database
-    persistent: bool;                 # Stage only unless `true`
       ): Result[void,KvtError] =
-  ## Verify that `txStow()` can go ahead
+  ## Verify that `txPersist()` can go ahead
   if not db.txRef.isNil:
     return err(TxPendingTx)
   if 0 < db.stack.len:
     return err(TxStackGarbled)
-  if persistent and not db.deltaPersistentOk():
+  if not db.deltaPersistentOk():
     return err(TxBackendNotWritable)
   ok()
 
-proc txStow*(
+proc txPersist*(
     db: KvtDbRef;                     # Database
-    persistent: bool;                 # Stage only unless `true`
       ): Result[void,KvtError] =
   ## The function saves the data from the top layer cache into the
   ## backend database.
@@ -46,7 +44,7 @@ proc txStow*(
   ## If there is no backend the function returns immediately with an error.
   ## The same happens if there is a pending transaction.
   ##
-  ? db.txStowOk persistent
+  ? db.txPersistOk()
 
   if 0 < db.top.sTab.len:
     # Note that `deltaMerge()` will return the `db.top` argument if the
@@ -58,7 +56,6 @@ proc txStow*(
     # New empty top layer
     db.top = LayerRef()
 
-  if persistent:
   # Move `balancer` data into persistent tables
   ? db.deltaPersistent()
 

nimbus/sync/beacon/worker/db.nim

@@ -81,7 +81,7 @@ proc dbStoreSyncStateLayout*(ctx: BeaconCtxRef; info: static[string]) =
 
   # While executing blocks there are frequent save cycles. Otherwise, an
   # extra save request might help to pick up an interrupted sync session.
-  if ctx.db.level() == 0 and ctx.stash.len == 0:
+  if ctx.db.txFrameLevel() == 0 and ctx.stash.len == 0:
     let number = ctx.db.getSavedStateBlockNumber()
     ctx.db.persistent(number).isOkOr:
       raiseAssert info & " persistent() failed: " & $$error
@@ -165,9 +165,9 @@ proc dbHeadersStash*(
   ##    ..
   ##
   let
-    txLevel = ctx.db.level()
+    txFrameLevel = ctx.db.txFrameLevel()
     last = first + revBlobs.len.uint64 - 1
-  if 0 < txLevel:
+  if 0 < txFrameLevel:
     # Need to cache it because FCU has blocked writing through to disk.
     for n,data in revBlobs:
       ctx.stash[last - n.uint64] = data

nimbus/transaction/call_evm.nim

@@ -38,7 +38,7 @@ proc rpcCallEvm*(args: TransactionArgs,
   let vmState = ? BaseVMState.new(topHeader, com)
   let params  = ? toCallParams(vmState, args, globalGasCap, header.baseFeePerGas)
 
-  var dbTx = com.db.ctx.newTransaction()
+  var dbTx = com.db.ctx.txFrameBegin()
   defer: dbTx.dispose() # always dispose state changes
 
   ok(runComputation(params, CallResult))
@@ -50,7 +50,7 @@ proc rpcCallEvm*(args: TransactionArgs,
   const globalGasCap = 0 # TODO: globalGasCap should configurable by user
   let params  = ? toCallParams(vmState, args, globalGasCap, header.baseFeePerGas)
 
-  var dbTx = com.db.ctx.newTransaction()
+  var dbTx = com.db.ctx.txFrameBegin()
   defer: dbTx.dispose() # always dispose state changes
 
   ok(runComputation(params, CallResult))
@@ -75,7 +75,7 @@ proc rpcEstimateGas*(args: TransactionArgs,
     hi : GasInt = GasInt args.gas.get(0.Quantity)
     cap: GasInt
 
-  var dbTx = com.db.ctx.newTransaction()
+  var dbTx = com.db.ctx.txFrameBegin()
   defer: dbTx.dispose() # always dispose state changes
 
   # Determine the highest gas limit can be used during the estimation.

tests/test_aristo/test_compute.nim

@@ -123,7 +123,7 @@ suite "Aristo compute":
       check:
         db.mergeAccountRecord(k, v) == Result[bool, AristoError].ok(true)
 
-    check db.txStow(1, true).isOk()
+    check db.txPersist(1).isOk()
 
     check db.computeKeys(root).isOk()
 

tests/test_aristo/test_helpers.nim

@@ -213,10 +213,7 @@ proc schedStow*(
     filterMeter = if db.balancer.isNil: 0
                   else: db.balancer.sTab.len + db.balancer.kMap.len
     persistent = MaxFilterBulk < max(layersMeter, filterMeter)
-  if persistent:
   db.persist()
-  else:
-    db.stow()
 
 # ------------------
 

tests/test_aristo/test_merge_proof.nim

@@ -55,7 +55,7 @@ proc saveToBackend(
     xCheckRc rc.error == 0
 
   block:
-    let rc = db.txTop()
+    let rc = db.txFrameTop()
     xCheckRc rc.error == 0
     tx = rc.value
 
@@ -72,7 +72,7 @@ proc saveToBackend(
     xCheckRc rc.error == 0
 
   block:
-    let rc = db.txTop()
+    let rc = db.txFrameTop()
     xCheckErr rc.value.level < 0 # force error
 
   block:
@@ -80,7 +80,7 @@ proc saveToBackend(
     xCheckRc rc.error == 0
 
   # Update layers to original level
-  tx = db.txBegin().value.to(AristoDbRef).txBegin().value
+  tx = db.txFrameBegin().value.to(AristoDbRef).txFrameBegin().value
 
   true
 
@@ -120,7 +120,7 @@ proc testMergeProofAndKvpList*(
   #     ps = PartStateRef.init(db)
 
   #     # Start transaction (double frame for testing)
-  #     tx = ps.db.txBegin().value.to(AristoDbRef).txBegin().value
+  #     tx = ps.db.txFrameBegin().value.to(AristoDbRef).txFrameBegin().value
   #     xCheck tx.isTop()
 
   #     # Update root

tests/test_aristo/test_tx.nim

@@ -109,7 +109,7 @@ proc randomisedLeafs(
 proc innerCleanUp(db: var AristoDbRef): bool {.discardable.}  =
   ## Defer action
   if not db.isNil:
-    let rx = db.txTop()
+    let rx = db.txFrameTop()
     if rx.isOk:
       let rc = rx.value.collapse(commit=false)
       xCheckRc rc.error == 0
@@ -140,7 +140,7 @@ proc saveToBackend(
     xCheckRc rc.error == 0
 
   block:
-    let rc = db.txTop()
+    let rc = db.txFrameTop()
     xCheckRc rc.error == 0
     tx = rc.value
 
@@ -157,7 +157,7 @@ proc saveToBackend(
     xCheckRc rc.error == 0
 
   block:
-    let rc = db.txTop()
+    let rc = db.txFrameTop()
     xCheckErr rc.value.level < 0 # force error
 
   block:
@@ -170,7 +170,7 @@ proc saveToBackend(
       noisy.say "***", "saveToBackend (8)", " debugID=", debugID
 
   # Update layers to original level
-  tx = db.txBegin().value.to(AristoDbRef).txBegin().value
+  tx = db.txFrameBegin().value.to(AristoDbRef).txFrameBegin().value
 
   true
 
@@ -268,8 +268,8 @@ proc testTxMergeAndDeleteOneByOne*(
   #       AristoDbRef.init(MemBackendRef)
 
   #   # Start transaction (double frame for testing)
-  #   xCheck db.txTop.isErr
+  #   xCheck db.txFrameTop.isErr
-  #   var tx = db.txBegin().value.to(AristoDbRef).txBegin().value
+  #   var tx = db.txFrameBegin().value.to(AristoDbRef).txFrameBegin().value
   #   xCheck tx.isTop()
   #   xCheck tx.level == 2
 
@@ -375,8 +375,8 @@ proc testTxMergeAndDeleteSubTree*(
   #       AristoDbRef.init(MemBackendRef)
 
   #   # Start transaction (double frame for testing)
-  #   xCheck db.txTop.isErr
+  #   xCheck db.txFrameTop.isErr
-  #   var tx = db.txBegin().value.to(AristoDbRef).txBegin().value
+  #   var tx = db.txFrameBegin().value.to(AristoDbRef).txFrameBegin().value
   #   xCheck tx.isTop()
   #   xCheck tx.level == 2
 

tests/test_forked_chain.nim

@@ -116,7 +116,7 @@ proc forkedChainMain*() =
       blk2 = cc.makeBlk(2, blk1)
       blk3 = cc.makeBlk(3, blk2)
 
-      dbTx = cc.db.ctx.newTransaction()
+      dbTx = cc.db.ctx.txFrameBegin()
       blk4 = cc.makeBlk(4, blk3)
       blk5 = cc.makeBlk(5, blk4)
       blk6 = cc.makeBlk(6, blk5)

tests/test_ledger.nim

@@ -212,7 +212,7 @@ proc runTrial3Survive(env: TestEnv, ledger: LedgerRef; inx: int; noisy = false)
   let eAddr = env.txs[inx].getRecipient
 
   block:
-    let dbTx = env.xdb.ctx.newTransaction()
+    let dbTx = env.xdb.ctx.txFrameBegin()
 
     block:
       let accTx = ledger.beginSavepoint
@@ -228,7 +228,7 @@ proc runTrial3Survive(env: TestEnv, ledger: LedgerRef; inx: int; noisy = false)
     dbTx.rollback()
 
   block:
-    let dbTx = env.xdb.ctx.newTransaction()
+    let dbTx = env.xdb.ctx.txFrameBegin()
 
     block:
       let accTx = ledger.beginSavepoint
@@ -247,7 +247,7 @@ proc runTrial4(env: TestEnv, ledger: LedgerRef; inx: int; rollback: bool) =
   let eAddr = env.txs[inx].getRecipient
 
   block:
-    let dbTx = env.xdb.ctx.newTransaction()
+    let dbTx = env.xdb.ctx.txFrameBegin()
 
     block:
       let accTx = ledger.beginSavepoint
@@ -277,7 +277,7 @@ proc runTrial4(env: TestEnv, ledger: LedgerRef; inx: int; rollback: bool) =
     dbTx.commit()
 
   block:
-    let dbTx = env.xdb.ctx.newTransaction()
+    let dbTx = env.xdb.ctx.txFrameBegin()
 
     block:
       let accTx = ledger.beginSavepoint
@@ -350,14 +350,14 @@ proc runLedgerTransactionTests(noisy = true) =
 
     test &"Run {env.txi.len} two-step trials with rollback":
       for n in env.txi:
-        let dbTx = env.xdb.ctx.newTransaction()
+        let dbTx = env.xdb.ctx.txFrameBegin()
         defer: dbTx.dispose()
         let ledger = env.com.getLedger()
         env.runTrial2ok(ledger, n)
 
     test &"Run {env.txi.len} three-step trials with rollback":
       for n in env.txi:
-        let dbTx = env.xdb.ctx.newTransaction()
+        let dbTx = env.xdb.ctx.txFrameBegin()
         defer: dbTx.dispose()
         let ledger = env.com.getLedger()
         env.runTrial3(ledger, n, rollback = true)
@@ -365,21 +365,21 @@ proc runLedgerTransactionTests(noisy = true) =
     test &"Run {env.txi.len} three-step trials with extra db frame rollback" &
         " throwing Exceptions":
       for n in env.txi:
-        let dbTx = env.xdb.ctx.newTransaction()
+        let dbTx = env.xdb.ctx.txFrameBegin()
         defer: dbTx.dispose()
         let ledger = env.com.getLedger()
         env.runTrial3Survive(ledger, n, noisy)
 
     test &"Run {env.txi.len} tree-step trials without rollback":
       for n in env.txi:
-        let dbTx = env.xdb.ctx.newTransaction()
+        let dbTx = env.xdb.ctx.txFrameBegin()
         defer: dbTx.dispose()
         let ledger = env.com.getLedger()
         env.runTrial3(ledger, n, rollback = false)
 
     test &"Run {env.txi.len} four-step trials with rollback and db frames":
       for n in env.txi:
-        let dbTx = env.xdb.ctx.newTransaction()
+        let dbTx = env.xdb.ctx.txFrameBegin()
         defer: dbTx.dispose()
         let ledger = env.com.getLedger()
         env.runTrial4(ledger, n, rollback = true)