implement gloadBytes, gloadUint64, Block, and add tests for those

Author: boblat

src/impl/block.ts

@@ -0,0 +1,13 @@
+import { bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript'
+import { lazyContext } from '../context-helpers/internal-context'
+import { itob } from './pure'
+import { asUint64 } from '../util'
+
+export const Block: internal.opTypes.BlockType = {
+  blkSeed: function (a: internal.primitives.StubUint64Compat): bytes {
+    return itob(lazyContext.ledger.getBlockContent(a).seed)
+  },
+  blkTimestamp: function (a: internal.primitives.StubUint64Compat): uint64 {
+    return asUint64(lazyContext.ledger.getBlockContent(a).timestamp)
+  },
+}

src/impl/index.ts

@@ -8,4 +8,5 @@ export { GTxn } from './gtxn'
 export * from './pure'
 export { Txn, gaid } from './txn'
 export { GITxn, ITxn, ITxnCreate } from './itxn'
-export { Scratch } from './scratch'
+export { Scratch, gloadBytes, gloadUint64 } from './scratch'
+export { Block } from './block'

src/impl/scratch.ts

@@ -1,20 +1,44 @@
 import { bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript'
 import { lazyContext } from '../context-helpers/internal-context'
 
+export const gloadUint64: internal.opTypes.GloadUint64Type = (
+  a: internal.primitives.StubUint64Compat,
+  b: internal.primitives.StubUint64Compat,
+): uint64 => {
+  const txn = lazyContext.activeGroup.getTransaction(a)
+  const result = txn.getScratchSlot(b)
+  if (result instanceof internal.primitives.Uint64Cls) {
+    return result as uint64
+  }
+  throw new internal.errors.InternalError('invalid scratch slot type')
+}
+
+export const gloadBytes: internal.opTypes.GloadBytesType = (
+  a: internal.primitives.StubUint64Compat,
+  b: internal.primitives.StubUint64Compat,
+): bytes => {
+  const txn = lazyContext.activeGroup.getTransaction(a)
+  const result = txn.getScratchSlot(b)
+  if (result instanceof internal.primitives.BytesCls) {
+    return result as bytes
+  }
+  throw new internal.errors.InternalError('invalid scratch slot type')
+}
+
 export const Scratch: internal.opTypes.ScratchType = {
   loadBytes: function (a: internal.primitives.StubUint64Compat): bytes {
     const result = lazyContext.activeGroup.activeTransaction.getScratchSlot(a)
     if (result instanceof internal.primitives.BytesCls) {
       return result as bytes
     }
-    throw new internal.errors.InternalError('Invalid scratch slot type')
+    throw new internal.errors.InternalError('invalid scratch slot type')
   },
   loadUint64: function (a: internal.primitives.StubUint64Compat): uint64 {
     const result = lazyContext.activeGroup.activeTransaction.getScratchSlot(a)
     if (result instanceof internal.primitives.Uint64Cls) {
       return result as uint64
     }
-    throw new internal.errors.InternalError('Invalid scratch slot type')
+    throw new internal.errors.InternalError('invalid scratch slot type')
   },
   store: function (
     a: internal.primitives.StubUint64Compat,

src/impl/txn.ts

@@ -1,19 +1,10 @@
 import { Account, Application, arc4, Asset, bytes, internal, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript'
 import { lazyContext } from '../context-helpers/internal-context'
 import { asNumber, asUint64, asUint64Cls } from '../util'
-// import {
-//   getApplicationTransaction,
-//   getAssetConfigTransaction,
-//   getAssetFreezeTransaction,
-//   getAssetTransferTransaction,
-//   getKeyRegistrationTransaction,
-//   getPaymentTransaction,
-//   getTransaction,
-// } from './gtxn'
 
 export const gaid = (a: internal.primitives.StubUint64Compat): uint64 => {
   const group = lazyContext.activeGroup
-  const transaction = group.transactions[asNumber(a)]
+  const transaction = group.getTransaction(a)
   if (transaction.type === TransactionType.ApplicationCall) {
     return transaction.createdApp.id
   } else if (transaction.type === TransactionType.AssetConfig) {

src/subcontexts/ledger-context.ts

@@ -7,13 +7,19 @@ import { AssetData } from '../impl/asset'
 import { GlobalData } from '../impl/global'
 import { asBigInt, 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)
   applicationDataMap = new Map<bigint, ApplicationData>()
   appIdContractMap = new Map<bigint, BaseContract>()
   accountDataMap = new AccountMap<AccountData>()
   assetDataMap = new Map<bigint, AssetData>()
+  blocks = new Map<bigint, BlockData>()
   globalData = new GlobalData()
 
   addAppIdContractMap(appId: internal.primitives.StubUint64Compat, contract: BaseContract): void {
@@ -76,4 +82,24 @@ export class LedgerContext {
       ...data,
     }
   }
+
+  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 })
+  }
+
+  getBlockContent(index: internal.primitives.StubUint64Compat): BlockData {
+    const i = asBigInt(index)
+    if (this.blocks.has(i)) {
+      return this.blocks.get(i)!
+    }
+    throw internal.errors.internalError(`Block ${i} not set`)
+  }
 }

tests/state-op-codes.spec.ts

@@ -32,6 +32,7 @@ import {
   INITIAL_BALANCE_MICRO_ALGOS,
 } from './avm-invoker'
 import { asUint8Array } from './util'
+import { Block, gloadBytes, gloadUint64 } from '../src/impl'
 
 describe('State op codes', async () => {
   const ctx = new TestExecutionContext()
@@ -376,4 +377,65 @@ describe('State op codes', async () => {
       expect(() => ctx.txn.lastGroup.getScratchSlot(256)).toThrow('invalid scratch slot')
     })
   })
+
+  describe('gloadBytes', async () => {
+    it('should return the correct field value of the scratch slot', async () => {
+      ctx.txn.createScope([ctx.any.txn.applicationCall({ scratchSpace: [Uint64(0), Bytes('hello'), Bytes('world')] })]).execute(() => {
+        const slot1 = gloadBytes(0, 1)
+        const slot2 = gloadBytes(0, 2)
+        expect(slot1).toStrictEqual('hello')
+        expect(slot2).toStrictEqual('world')
+      })
+    })
+    it('should throw error if the scratch slot is not a bytes type', async () => {
+      ctx.txn.createScope([ctx.any.txn.applicationCall({ scratchSpace: [Uint64(0), Bytes('hello'), Bytes('world')] })]).execute(() => {
+        expect(() => gloadBytes(0, 0)).toThrow('invalid scratch slot type')
+      })
+    })
+    it('should throw error if the scratch slot is out of range', async () => {
+      ctx.txn.createScope([ctx.any.txn.applicationCall({ scratchSpace: [Uint64(0), Bytes('hello'), Bytes('world')] })]).execute(() => {
+        expect(() => gloadBytes(0, 256)).toThrow('invalid scratch slot')
+      })
+    })
+  })
+
+  describe('gloadUint64', async () => {
+    it('should return the correct field value of the scratch slot', async () => {
+      ctx.txn.createScope([ctx.any.txn.applicationCall({ scratchSpace: [Uint64(7), Uint64(42), Bytes('world')] })]).execute(() => {
+        const slot0 = gloadUint64(0, 0)
+        const slot1 = gloadUint64(0, 1)
+        expect(slot0).toStrictEqual(7n)
+        expect(slot1).toStrictEqual(42n)
+      })
+    })
+    it('should throw error if the scratch slot is not a uint64 type', async () => {
+      ctx.txn.createScope([ctx.any.txn.applicationCall({ scratchSpace: [Uint64(7), Uint64(42), Bytes('world')] })]).execute(() => {
+        expect(() => gloadUint64(0, 2)).toThrow('invalid scratch slot type')
+      })
+    })
+    it('should throw error if the scratch slot is out of range', async () => {
+      ctx.txn.createScope([ctx.any.txn.applicationCall({ scratchSpace: [Uint64(7), Uint64(42), Bytes('world')] })]).execute(() => {
+        expect(() => gloadUint64(0, 256)).toThrow('invalid scratch slot')
+      })
+    })
+  })
+
+  describe('Block', async () => {
+    it('should return the correct field value of the block', async () => {
+      const index = 42
+      const seed = 123
+      const timestamp = 1234567890
+      ctx.ledger.setBlock(index, seed, timestamp)
+      const seedResult = op.btoi(Block.blkSeed(Uint64(index)))
+      const timestampResult = Block.blkTimestamp(Uint64(index))
+
+      expect(seedResult).toEqual(Uint64(seed))
+      expect(timestampResult).toEqual(Uint64(timestamp))
+    })
+    it('should throw error if the block is not set', async () => {
+      const index = 42
+      expect(() => Block.blkSeed(Uint64(index))).toThrow('Block 42 not set')
+      expect(() => Block.blkTimestamp(Uint64(index))).toThrow('Block 42 not set')
+    })
+  })
 })