feat: add tests for voting example contract

boblat · boblat · commit 3b2a05db2d59 · 2024-12-31T14:55:27.000+08:00
diff --git a/examples/hello-world-abi/contract.spec.ts b/examples/hello-world-abi/contract.spec.ts
@@ -1,7 +1,6 @@
 import { assert, Bytes, TransactionType } from '@algorandfoundation/algorand-typescript'
 import { TestExecutionContext } from '@algorandfoundation/algorand-typescript-testing'
 import { afterEach, describe, expect, it } from 'vitest'
-import { ABI_RETURN_VALUE_LOG_PREFIX } from '../../src/constants'
 import HelloWorldContract from './contract.algo'
 
 describe('HelloWorldContract', () => {
@@ -16,9 +15,8 @@ describe('HelloWorldContract', () => {
 
     expect(result).toBe('Bananas')
     const bananasBytes = Bytes('Bananas')
-    const abiLog = ABI_RETURN_VALUE_LOG_PREFIX.concat(bananasBytes)
     const logs = ctx.exportLogs(ctx.txn.lastActive.appId.id, 's', 'b')
-    expect(logs).toStrictEqual([result, abiLog])
+    expect(logs).toStrictEqual([result, bananasBytes])
   })
   it('logs the returned value when sayHello is called', async () => {
     const contract = ctx.contract.create(HelloWorldContract)
@@ -27,8 +25,7 @@ describe('HelloWorldContract', () => {
 
     expect(result).toBe('Hello John Doe')
     const helloBytes = Bytes('Hello John Doe')
-    const abiLog = ABI_RETURN_VALUE_LOG_PREFIX.concat(helloBytes)
     const logs = ctx.exportLogs(ctx.txn.lastActive.appId.id, 's', 'b')
-    expect(logs).toStrictEqual([result, abiLog])
+    expect(logs).toStrictEqual([result, helloBytes])
   })
 })
diff --git a/examples/htlc-logicsig/signature.spec.ts b/examples/htlc-logicsig/signature.spec.ts
@@ -2,9 +2,11 @@ import { Account, Bytes } from '@algorandfoundation/algorand-typescript'
 import { TestExecutionContext } from '@algorandfoundation/algorand-typescript-testing'
 import algosdk from 'algosdk'
 import { afterEach, describe, expect, it } from 'vitest'
-import { ZERO_ADDRESS } from '../../src/constants'
 import HashedTimeLockedLogicSig from './signature.algo'
 
+const ZERO_ADDRESS_B32 = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ'
+const ZERO_ADDRESS = Bytes.fromBase32(ZERO_ADDRESS_B32)
+
 describe('HTLC LogicSig', () => {
   const ctx = new TestExecutionContext()
 
diff --git a/examples/precompiled/contract.spec.ts b/examples/precompiled/contract.spec.ts
@@ -1,11 +1,12 @@
-import { arc4 } from '@algorandfoundation/algorand-typescript'
+import { arc4, Bytes } from '@algorandfoundation/algorand-typescript'
 import { TestExecutionContext } from '@algorandfoundation/algorand-typescript-testing'
 import { afterEach, describe, it } from 'vitest'
-import { ABI_RETURN_VALUE_LOG_PREFIX, MAX_BYTES_SIZE } from '../../src/constants'
-import { asUint64Cls } from '../../src/util'
 import { HelloFactory } from './contract.algo'
 import { Hello, HelloTemplate, HelloTemplateCustomPrefix, LargeProgram, TerribleCustodialAccount } from './precompiled-apps.algo'
 
+const MAX_BYTES_SIZE = 4096
+const ABI_RETURN_VALUE_LOG_PREFIX = Bytes.fromHex('151F7C75')
+
 describe('pre compiled app calls', () => {
   const ctx = new TestExecutionContext()
   afterEach(() => {
@@ -58,7 +59,7 @@ describe('pre compiled app calls', () => {
     // Arrange
     const largeProgramApp = ctx.any.application({
       approvalProgram: ctx.any.bytes(20),
-      appLogs: [ABI_RETURN_VALUE_LOG_PREFIX.concat(asUint64Cls(MAX_BYTES_SIZE).toBytes().asAlgoTs())],
+      appLogs: [ABI_RETURN_VALUE_LOG_PREFIX.concat(Bytes(MAX_BYTES_SIZE))],
     })
     ctx.setCompiledApp(LargeProgram, largeProgramApp.id)
 
diff --git a/examples/voting/contract.algo.ts b/examples/voting/contract.algo.ts
@@ -154,7 +154,7 @@ export class VotingRoundApp extends arc4.Contract {
         note: note,
         fee: Global.minTxnFee,
       })
-      .submit().configAsset
+      .submit().createdAsset
   }
 
   @abimethod({ readonly: true })
diff --git a/examples/voting/contract.spec.ts b/examples/voting/contract.spec.ts
@@ -0,0 +1,96 @@
+import { Bytes, Uint64 } from '@algorandfoundation/algorand-typescript'
+import { bytesToUint8Array, TestExecutionContext } from '@algorandfoundation/algorand-typescript-testing'
+import { DynamicArray, UintN8 } from '@algorandfoundation/algorand-typescript/arc4'
+import nacl from 'tweetnacl'
+import { afterEach, describe, expect, it } from 'vitest'
+import { VotingRoundApp } from './contract.algo'
+
+describe('VotingRoundApp', () => {
+  const ctx = new TestExecutionContext()
+
+  const boostrapMinBalanceReq = Uint64(287100)
+  const voteMinBalanceReq = Uint64(21300)
+  const tallyBoxSize = 208
+  const keyPair = nacl.sign.keyPair()
+  const voteId = ctx.any.string()
+
+  const createContract = () => {
+    const contract = ctx.contract.create(VotingRoundApp)
+    const snapshotPublicKey = Bytes(keyPair.publicKey)
+    const metadataIpfsCid = ctx.any.string(16)
+    const startTime = ctx.any.uint64(Date.now() - 10_000, Date.now())
+    const endTime = ctx.any.uint64(Date.now() + 10_000, Date.now() + 100_000)
+    const optionCounts = new DynamicArray<UintN8>(
+      ...Array(13)
+        .fill(0)
+        .map(() => new UintN8(2)),
+    )
+    const quorum = ctx.any.uint64()
+    const nftImageUrl = ctx.any.string(64)
+    contract.create(voteId, snapshotPublicKey, metadataIpfsCid, startTime, endTime, optionCounts, quorum, nftImageUrl)
+    return contract
+  }
+
+  afterEach(() => {
+    ctx.reset()
+  })
+
+  it('shoulld be able to bootstrap', () => {
+    const contract = createContract()
+    const app = ctx.ledger.getApplicationForContract(contract)
+    contract.bootstrap(ctx.any.txn.payment({ receiver: app.address, amount: boostrapMinBalanceReq }))
+
+    expect(contract.isBootstrapped.value).toEqual(true)
+    expect(contract.tallyBox.value).toEqual(Bytes.fromHex('00'.repeat(tallyBoxSize)))
+  })
+
+  it('should be able to get pre conditions', () => {
+    const contract = createContract()
+    const app = ctx.ledger.getApplicationForContract(contract)
+    contract.bootstrap(ctx.any.txn.payment({ receiver: app.address, amount: boostrapMinBalanceReq }))
+
+    const account = ctx.any.account()
+    const signature = nacl.sign.detached(bytesToUint8Array(account.bytes), keyPair.secretKey)
+    ctx.txn.createScope([ctx.any.txn.applicationCall({ sender: account })]).execute(() => {
+      const preconditions = contract.getPreconditions(Bytes(signature))
+
+      expect(preconditions.is_allowed_to_vote).toEqual(1)
+      expect(preconditions.is_voting_open).toEqual(1)
+      expect(preconditions.has_already_voted).toEqual(0)
+      expect(preconditions.current_time).toEqual(ctx.txn.activeGroup.latestTimestamp)
+    })
+  })
+
+  it('should be able to vote', () => {
+    const contract = createContract()
+    const app = ctx.ledger.getApplicationForContract(contract)
+    contract.bootstrap(ctx.any.txn.payment({ receiver: app.address, amount: boostrapMinBalanceReq }))
+
+    const account = ctx.any.account()
+    const signature = nacl.sign.detached(bytesToUint8Array(account.bytes), keyPair.secretKey)
+    const answerIds = new DynamicArray<UintN8>(
+      ...Array(13)
+        .fill(0)
+        .map(() => new UintN8(Math.ceil(Math.random() * 10) % 2)),
+    )
+
+    ctx.txn.createScope([ctx.any.txn.applicationCall({ appId: app, sender: account })]).execute(() => {
+      contract.vote(ctx.any.txn.payment({ receiver: app.address, amount: voteMinBalanceReq }), Bytes(signature), answerIds)
+
+      expect(contract.votesByAccount.get(account).bytes).toEqual(answerIds.bytes)
+      expect(contract.voterCount.value).toEqual(13)
+    })
+  })
+
+  it('should be able to close', () => {
+    const contract = createContract()
+    const app = ctx.ledger.getApplicationForContract(contract)
+    contract.bootstrap(ctx.any.txn.payment({ receiver: app.address, amount: boostrapMinBalanceReq }))
+
+    contract.close()
+
+    expect(contract.closeTime.value).toEqual(ctx.txn.lastGroup.latestTimestamp)
+    expect(contract.nftAsset.value.name).toEqual(`[VOTE RESULT] ${voteId}`)
+    expect(contract.nftAsset.value.unitName).toEqual('VOTERSLT')
+  })
+})
diff --git a/src/decode-logs.ts b/src/decode-logs.ts
@@ -1,20 +1,27 @@
 import { bytes, op } from '@algorandfoundation/algorand-typescript'
+import { ABI_RETURN_VALUE_LOG_PREFIX } from './constants'
+import { asNumber } from './util'
 
 export type LogDecoding = 'i' | 's' | 'b'
 
 export type DecodedLog<T extends LogDecoding> = T extends 'i' ? bigint : T extends 's' ? string : Uint8Array
 export type DecodedLogs<T extends [...LogDecoding[]]> = {
   [Index in keyof T]: DecodedLog<T[Index]>
 } & { length: T['length'] }
+
+const ABI_RETURN_VALUE_LOG_PREFIX_LENGTH = asNumber(ABI_RETURN_VALUE_LOG_PREFIX.length)
 export function decodeLogs<const T extends [...LogDecoding[]]>(logs: bytes[], decoding: T): DecodedLogs<T> {
   return logs.map((log, i) => {
+    const value = log.slice(0, ABI_RETURN_VALUE_LOG_PREFIX_LENGTH).equals(ABI_RETURN_VALUE_LOG_PREFIX)
+      ? log.slice(ABI_RETURN_VALUE_LOG_PREFIX_LENGTH)
+      : log
     switch (decoding[i]) {
       case 'i':
-        return op.btoi(log)
+        return op.btoi(value)
       case 's':
-        return log.toString()
+        return value.toString()
       default:
-        return log
+        return value
     }
   }) as DecodedLogs<T>
 }
diff --git a/src/encoders.ts b/src/encoders.ts
@@ -1,11 +1,12 @@
 import { biguint, BigUint, bytes, internal, TransactionType, uint64, Uint64 } from '@algorandfoundation/algorand-typescript'
-import { OnCompleteAction } from '@algorandfoundation/algorand-typescript/arc4'
+import { ARC4Encoded, OnCompleteAction } from '@algorandfoundation/algorand-typescript/arc4'
 import { AccountCls } from './impl/account'
 import { ApplicationCls } from './impl/application'
 import { AssetCls } from './impl/asset'
-import { arc4Encoders, getArc4Encoder } from './impl/encoded-types'
+import { BytesBackedCls, Uint64BackedCls } from './impl/base'
+import { arc4Encoders, encodeArc4Impl, getArc4Encoder } from './impl/encoded-types'
 import { DeliberateAny } from './typescript-helpers'
-import { asBytes, asUint8Array } from './util'
+import { asBytes, asMaybeBigUintCls, asMaybeBytesCls, asMaybeUint64Cls, asUint64Cls, asUint8Array, nameOfType } from './util'
 
 export type TypeInfo = {
   name: string
@@ -59,3 +60,31 @@ export const encoders: Record<string, fromBytes<DeliberateAny>> = {
 export const getEncoder = <T>(typeInfo: TypeInfo): fromBytes<T> => {
   return getArc4Encoder<T>(typeInfo, encoders)
 }
+
+export const toBytes = (val: unknown): bytes => {
+  const uint64Val = asMaybeUint64Cls(val)
+  if (uint64Val !== undefined) {
+    return uint64Val.toBytes().asAlgoTs()
+  }
+  const bytesVal = asMaybeBytesCls(val)
+  if (bytesVal !== undefined) {
+    return bytesVal.asAlgoTs()
+  }
+  const bigUintVal = asMaybeBigUintCls(val)
+  if (bigUintVal !== undefined) {
+    return bigUintVal.toBytes().asAlgoTs()
+  }
+  if (val instanceof BytesBackedCls) {
+    return val.bytes
+  }
+  if (val instanceof Uint64BackedCls) {
+    return asUint64Cls(val.uint64).toBytes().asAlgoTs()
+  }
+  if (val instanceof ARC4Encoded) {
+    return val.bytes
+  }
+  if (Array.isArray(val) || typeof val === 'object') {
+    return encodeArc4Impl('', val)
+  }
+  internal.errors.internalError(`Invalid type for bytes: ${nameOfType(val)}`)
+}
diff --git a/src/impl/app-global.ts b/src/impl/app-global.ts
@@ -1,6 +1,7 @@
 import { Application, Bytes, bytes, internal, Uint64, uint64 } from '@algorandfoundation/algorand-typescript'
 import { lazyContext } from '../context-helpers/internal-context'
-import { asBytes, toBytes } from '../util'
+import { toBytes } from '../encoders'
+import { asBytes } from '../util'
 import { getApp } from './app-params'
 
 export const AppGlobal: internal.opTypes.AppGlobalType = {
diff --git a/src/impl/app-local.ts b/src/impl/app-local.ts
@@ -1,6 +1,7 @@
 import { Account, Application, Bytes, bytes, internal, Uint64, uint64 } from '@algorandfoundation/algorand-typescript'
 import { lazyContext } from '../context-helpers/internal-context'
-import { asBytes, toBytes } from '../util'
+import { toBytes } from '../encoders'
+import { asBytes } from '../util'
 import { getAccount } from './acct-params'
 import { getApp } from './app-params'
 
diff --git a/src/impl/box.ts b/src/impl/box.ts
@@ -1,7 +1,8 @@
 import { bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript'
 import { MAX_BOX_SIZE } from '../constants'
 import { lazyContext } from '../context-helpers/internal-context'
-import { asBytes, asBytesCls, asNumber, asUint8Array, conactUint8Arrays, toBytes } from '../util'
+import { toBytes } from '../encoders'
+import { asBytes, asBytesCls, asNumber, asUint8Array, conactUint8Arrays } from '../util'
 
 export const Box: internal.opTypes.BoxType = {
   create(a: internal.primitives.StubBytesCompat, b: internal.primitives.StubUint64Compat): boolean {
diff --git a/src/impl/inner-transactions.ts b/src/impl/inner-transactions.ts
@@ -1,7 +1,7 @@
 import { Account, Application, arc4, Asset, bytes, internal, itxn, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript'
 import { lazyContext } from '../context-helpers/internal-context'
 import { Mutable } from '../typescript-helpers'
-import { asBytes } from '../util'
+import { asBytes, asNumber } from '../util'
 import { getApp } from './app-params'
 import { getAsset } from './asset-params'
 import { InnerTxn, InnerTxnFields } from './itxn'
@@ -66,12 +66,15 @@ export class AssetConfigInnerTxn extends AssetConfigTransaction implements itxn.
   /* @internal */
   constructor(fields: itxn.AssetConfigFields) {
     const { assetName, unitName, url, ...rest } = mapCommonFields(fields)
-    const createdAsset = lazyContext.any.asset({
-      name: typeof assetName === 'string' ? asBytes(assetName) : assetName,
-      unitName: typeof unitName === 'string' ? asBytes(unitName) : unitName,
-      url: typeof url === 'string' ? asBytes(url) : url,
-      ...rest,
-    })
+    const createdAsset =
+      !rest.configAsset || !asNumber(rest.configAsset.id)
+        ? lazyContext.any.asset({
+            name: typeof assetName === 'string' ? asBytes(assetName) : assetName,
+            unitName: typeof unitName === 'string' ? asBytes(unitName) : unitName,
+            url: typeof url === 'string' ? asBytes(url) : url,
+            ...rest,
+          })
+        : undefined
 
     super({
       assetName: typeof assetName === 'string' ? asBytes(assetName) : assetName,
diff --git a/src/impl/match.ts b/src/impl/match.ts
@@ -33,11 +33,11 @@ export const matchImpl: typeof match = (subject, test): boolean => {
       getBigIntValue(subject.uint64 as unknown as internal.primitives.Uint64Cls) ===
       getBigIntValue((test as unknown as Uint64BackedCls).uint64 as unknown as internal.primitives.Uint64Cls)
     )
-  } else if (subject instanceof ARC4Encoded) {
-    return subject.bytes.equals((test as unknown as ARC4Encoded).bytes)
-  } else if (Array.isArray(subject)) {
-    return (test as []).map((x, i) => matchImpl((subject as DeliberateAny)[i], x as DeliberateAny)).every((x) => x)
-  } else if (typeof subject === 'object') {
+  } else if (test instanceof ARC4Encoded) {
+    return (subject as unknown as ARC4Encoded).bytes.equals(test.bytes)
+  } else if (Array.isArray(test)) {
+    return test.map((x, i) => matchImpl((subject as DeliberateAny)[i], x as DeliberateAny)).every((x) => x)
+  } else if (typeof test === 'object') {
     return Object.entries(test!)
       .map(([k, v]) => matchImpl((subject as DeliberateAny)[k], v as DeliberateAny))
       .every((x) => x)
diff --git a/src/impl/state.ts b/src/impl/state.ts
@@ -17,9 +17,9 @@ import {
 import { AccountMap } from '../collections/custom-key-map'
 import { MAX_BOX_SIZE } from '../constants'
 import { lazyContext } from '../context-helpers/internal-context'
-import { getEncoder, TypeInfo } from '../encoders'
+import { getEncoder, toBytes, TypeInfo } from '../encoders'
 import { getGenericTypeInfo } from '../runtime-helpers'
-import { asBytes, asBytesCls, asNumber, asUint8Array, conactUint8Arrays, toBytes } from '../util'
+import { asBytes, asBytesCls, asNumber, asUint8Array, conactUint8Arrays } from '../util'
 
 export class GlobalStateCls<ValueType> {
   private readonly _type: string = GlobalStateCls.name
diff --git a/src/impl/transactions.ts b/src/impl/transactions.ts
@@ -13,17 +13,9 @@ import {
 } from '@algorandfoundation/algorand-typescript'
 import { ABI_RETURN_VALUE_LOG_PREFIX, MAX_ITEMS_IN_LOG } from '../constants'
 import { lazyContext } from '../context-helpers/internal-context'
+import { toBytes } from '../encoders'
 import { Mutable, ObjectKeys } from '../typescript-helpers'
-import {
-  asBytes,
-  asMaybeBytesCls,
-  asMaybeUint64Cls,
-  asNumber,
-  asUint64Cls,
-  combineIntoMaxBytePages,
-  getRandomBytes,
-  toBytes,
-} from '../util'
+import { asBytes, asMaybeBytesCls, asMaybeUint64Cls, asNumber, asUint64Cls, combineIntoMaxBytePages, getRandomBytes } from '../util'
 
 const baseDefaultFields = () => ({
   sender: lazyContext.defaultSender,
diff --git a/src/index.ts b/src/index.ts
@@ -1 +1,2 @@
 export { TestExecutionContext } from './test-execution-context'
+export { asUint8Array as bytesToUint8Array } from './util'
diff --git a/src/runtime-helpers.ts b/src/runtime-helpers.ts
@@ -36,7 +36,7 @@ type UnaryOps = '~'
 
 function tryGetBigInt(value: unknown): bigint | undefined {
   if (typeof value == 'bigint') return value
-  if (typeof value == 'number') return BigInt(value)
+  if (typeof value == 'number' && Number.isInteger(value)) return BigInt(value)
   if (value instanceof internal.primitives.Uint64Cls) return value.valueOf()
   if (value instanceof internal.primitives.BigUintCls) return value.valueOf()
   return undefined
diff --git a/src/subcontexts/contract-context.ts b/src/subcontexts/contract-context.ts
@@ -21,7 +21,7 @@ import {
 import { BytesMap } from '../collections/custom-key-map'
 import { checkRoutingConditions } from '../context-helpers/context-util'
 import { lazyContext } from '../context-helpers/internal-context'
-import type { TypeInfo } from '../encoders'
+import { toBytes, type TypeInfo } from '../encoders'
 import { AccountCls } from '../impl/account'
 import { ApplicationCls } from '../impl/application'
 import { AssetCls } from '../impl/asset'
@@ -37,7 +37,6 @@ import {
 } from '../impl/transactions'
 import { getGenericTypeInfo } from '../runtime-helpers'
 import { DeliberateAny, IConstructor } from '../typescript-helpers'
-import { toBytes } from '../util'
 
 type ContractOptionsParameter = Parameters<typeof contract>[0]
 
diff --git a/src/util.ts b/src/util.ts
diff --git a/src/value-generators/avm.ts b/src/value-generators/avm.ts
diff --git a/tests/references/box-map.spec.ts b/tests/references/box-map.spec.ts
diff --git a/tests/references/box.spec.ts b/tests/references/box.spec.ts

Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ export class VotingRoundApp extends arc4.Contract {`
`154`	`154`	`note: note,`
`155`	`155`	`fee: Global.minTxnFee,`
`156`	`156`	`})`
`157`		`- .submit().configAsset`
	`157`	`+ .submit().createdAsset`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`@abimethod({ readonly: true })`