feat: add v11 block functions

Author: boblat

src/impl/block.ts

@@ -1,38 +1,62 @@
-import { Account, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript'
+import { Account, bytes, internal, Uint64, uint64 } from '@algorandfoundation/algorand-typescript'
 import { lazyContext } from '../context-helpers/internal-context'
-import { asUint64 } from '../util'
-import { itob } from './pure'
+import { asUint64, getRandomBytes } from '../util'
+
+export class BlockData {
+  seed: bytes
+  timestamp: uint64
+  proposer: Account
+  feesCollected: uint64
+  bonus: uint64
+  branch: bytes
+  feeSink: Account
+  protocol: bytes
+  txnCounter: uint64
+  proposerPayout: uint64
+
+  constructor() {
+    this.seed = getRandomBytes(32).asAlgoTs()
+    this.timestamp = asUint64(Date.now())
+    this.proposer = Account()
+    this.feesCollected = Uint64(0)
+    this.bonus = Uint64(0)
+    this.branch = getRandomBytes(32).asAlgoTs()
+    this.feeSink = Account()
+    this.protocol = getRandomBytes(32).asAlgoTs()
+    this.txnCounter = Uint64(0)
+    this.proposerPayout = Uint64(0)
+  }
+}
 
 export const Block: internal.opTypes.BlockType = {
   blkSeed: function (a: internal.primitives.StubUint64Compat): bytes {
-    return itob(lazyContext.ledger.getBlockContent(a).seed)
+    return lazyContext.ledger.getBlockData(a).seed
   },
   blkTimestamp: function (a: internal.primitives.StubUint64Compat): uint64 {
-    return asUint64(lazyContext.ledger.getBlockContent(a).timestamp)
+    return lazyContext.ledger.getBlockData(a).timestamp
   },
-  // TODO: implement v11 methods
-  blkProposer: function (_a: uint64): Account {
-    throw new Error('Function not implemented.')
+  blkProposer: function (a: uint64): Account {
+    return lazyContext.ledger.getBlockData(a).proposer
   },
-  blkFeesCollected: function (_a: uint64): uint64 {
-    throw new Error('Function not implemented.')
+  blkFeesCollected: function (a: uint64): uint64 {
+    return lazyContext.ledger.getBlockData(a).feesCollected
   },
-  blkBonus: function (_a: uint64): uint64 {
-    throw new Error('Function not implemented.')
+  blkBonus: function (a: uint64): uint64 {
+    return lazyContext.ledger.getBlockData(a).bonus
   },
-  blkBranch: function (_a: uint64): bytes {
-    throw new Error('Function not implemented.')
+  blkBranch: function (a: uint64): bytes {
+    return lazyContext.ledger.getBlockData(a).branch
   },
-  blkFeeSink: function (_a: uint64): Account {
-    throw new Error('Function not implemented.')
+  blkFeeSink: function (a: uint64): Account {
+    return lazyContext.ledger.getBlockData(a).feeSink
   },
-  blkProtocol: function (_a: uint64): bytes {
-    throw new Error('Function not implemented.')
+  blkProtocol: function (a: uint64): bytes {
+    return lazyContext.ledger.getBlockData(a).protocol
   },
-  blkTxnCounter: function (_a: uint64): uint64 {
-    throw new Error('Function not implemented.')
+  blkTxnCounter: function (a: uint64): uint64 {
+    return lazyContext.ledger.getBlockData(a).txnCounter
   },
-  blkProposerPayout: function (_a: uint64): uint64 {
-    throw new Error('Function not implemented.')
+  blkProposerPayout: function (a: uint64): uint64 {
+    return lazyContext.ledger.getBlockData(a).proposerPayout
   },
 }

src/subcontexts/ledger-context.ts

@@ -4,15 +4,11 @@ import { MAX_UINT64 } from '../constants'
 import { AccountData, AssetHolding } from '../impl/account'
 import { ApplicationData } from '../impl/application'
 import { AssetData } from '../impl/asset'
+import { BlockData } from '../impl/block'
 import { GlobalData } from '../impl/global'
 import { GlobalStateCls } from '../impl/state'
 import { asBigInt, asMaybeBytesCls, asMaybeUint64Cls, asUint64, asUint64Cls, iterBigInt } from '../util'
 
-interface BlockData {
-  seed: bigint
-  timestamp: bigint
-}
-
 export class LedgerContext {
   appIdIter = iterBigInt(1001n, MAX_UINT64)
   assetIdIter = iterBigInt(1001n, MAX_UINT64)
@@ -124,19 +120,16 @@ export class LedgerContext {
     })
   }
 
-  setBlock(
-    index: internal.primitives.StubUint64Compat,
-    seed: internal.primitives.StubUint64Compat,
-    timestamp: internal.primitives.StubUint64Compat,
-  ): void {
-    const i = asBigInt(index)
-    const s = asBigInt(seed)
-    const t = asBigInt(timestamp)
-
-    this.blocks.set(i, { seed: s, timestamp: t })
+  patchBlockData(index: internal.primitives.StubUint64Compat, data: Partial<BlockData>): void {
+    const i = asUint64(index)
+    const blockData = this.blocks.get(i) ?? new BlockData()
+    this.blocks.set(i, {
+      ...blockData,
+      ...data,
+    })
   }
 
-  getBlockContent(index: internal.primitives.StubUint64Compat): BlockData {
+  getBlockData(index: internal.primitives.StubUint64Compat): BlockData {
     const i = asBigInt(index)
     if (this.blocks.has(i)) {
       return this.blocks.get(i)!

tests/state-op-codes.spec.ts

@@ -12,7 +12,7 @@ import { AccountCls } from '../src/impl/account'
 import { InnerTxn } from '../src/impl/itxn'
 import { ApplicationTransaction } from '../src/impl/transactions'
 import { DeliberateAny } from '../src/typescript-helpers'
-import { asBigInt, asNumber, asUint64Cls, asUint8Array, encodeAddress, getRandomBytes } from '../src/util'
+import { asBigInt, asBigUintCls, asNumber, asUint64Cls, asUint8Array, encodeAddress, getRandomBytes } from '../src/util'
 import { AppExpectingEffects } from './artifacts/created-app-asset/contract.algo'
 import {
   ItxnDemoContract,
@@ -491,14 +491,40 @@ describe('State op codes', async () => {
   describe('Block', async () => {
     it('should return the correct field value of the block', async () => {
       const index = 42
-      const seed = 123
+      const seed = asBigUintCls(123n).toBytes().asAlgoTs()
       const timestamp = 1234567890
-      ctx.ledger.setBlock(index, seed, timestamp)
-      const seedResult = op.btoi(Block.blkSeed(Uint64(index)))
-      const timestampResult = Block.blkTimestamp(Uint64(index))
+      const proposer = ctx.any.account()
+      const feesCollected = 1000
+      const bonus = 12
+      const branch = getRandomBytes(32).asAlgoTs()
+      const feeSink = ctx.any.account()
+      const protocol = getRandomBytes(32).asAlgoTs()
+      const txnCounter = 32
+      const proposerPayout = 42
+
+      ctx.ledger.patchBlockData(index, {
+        seed,
+        timestamp,
+        proposer,
+        feesCollected,
+        bonus,
+        branch,
+        feeSink,
+        protocol,
+        txnCounter,
+        proposerPayout,
+      })
 
-      expect(seedResult).toEqual(Uint64(seed))
-      expect(timestampResult).toEqual(Uint64(timestamp))
+      expect(Block.blkSeed(index)).toEqual(seed)
+      expect(Block.blkTimestamp(index)).toEqual(timestamp)
+      expect(Block.blkProposer(index)).toEqual(proposer)
+      expect(Block.blkFeesCollected(index)).toEqual(feesCollected)
+      expect(Block.blkBonus(index)).toEqual(bonus)
+      expect(Block.blkBranch(index)).toEqual(branch)
+      expect(Block.blkFeeSink(index)).toEqual(feeSink)
+      expect(Block.blkProtocol(index)).toEqual(protocol)
+      expect(Block.blkTxnCounter(index)).toEqual(txnCounter)
+      expect(Block.blkProposerPayout(index)).toEqual(proposerPayout)
     })
     it('should throw error if the block is not set', async () => {
       const index = 42