implement functions to create itxn and add tests for those

Author: boblat

src/impl/inner-transactions.ts

@@ -158,21 +158,73 @@ export class ApplicationInnerTxn extends ApplicationTransaction implements itxn.
   }
 }
 
-export const createInnerTxn = (fields: InnerTxnFields): InnerTxn => {
+export const createInnerTxn = <TFields extends InnerTxnFields, T extends InnerTxn>(fields: TFields): T => {
   switch (fields.type) {
     case TransactionType.Payment:
-      return new PaymentInnerTxn(fields)
+      return new PaymentInnerTxn(fields) as T
     case TransactionType.AssetConfig:
-      return new AssetConfigInnerTxn(fields)
+      return new AssetConfigInnerTxn(fields) as T
     case TransactionType.AssetTransfer:
-      return new AssetTransferInnerTxn(fields as itxn.AssetTransferFields)
+      return new AssetTransferInnerTxn(fields as itxn.AssetTransferFields) as T
     case TransactionType.AssetFreeze:
-      return new AssetFreezeInnerTxn(fields as itxn.AssetFreezeFields)
+      return new AssetFreezeInnerTxn(fields as itxn.AssetFreezeFields) as T
     case TransactionType.ApplicationCall:
-      return new ApplicationInnerTxn(fields)
+      return new ApplicationInnerTxn(fields) as unknown as T
     case TransactionType.KeyRegistration:
-      return new KeyRegistrationInnerTxn(fields)
+      return new KeyRegistrationInnerTxn(fields) as T
     default:
-      internal.errors.internalError(`Invalid inner transaction type: ${fields.type}`)
+      throw new internal.errors.InternalError(`Invalid inner transaction type: ${fields.type}`)
+  }
+}
+
+export function submitGroup<TFields extends itxn.InnerTxnList>(...transactionFields: TFields): itxn.TxnFor<TFields> {
+  return transactionFields.map((f: (typeof transactionFields)[number]) => f.submit()) as itxn.TxnFor<TFields>
+}
+export function payment(fields: itxn.PaymentFields): itxn.PaymentItxnParams {
+  ensureItxnGroupBegin()
+  return new ItxnParams<itxn.PaymentFields, itxn.PaymentInnerTxn>(fields, TransactionType.Payment)
+}
+export function keyRegistration(fields: itxn.KeyRegistrationFields): itxn.KeyRegistrationItxnParams {
+  ensureItxnGroupBegin()
+  return new ItxnParams<itxn.KeyRegistrationFields, itxn.KeyRegistrationInnerTxn>(fields, TransactionType.KeyRegistration)
+}
+export function assetConfig(fields: itxn.AssetConfigFields): itxn.AssetConfigItxnParams {
+  ensureItxnGroupBegin()
+  return new ItxnParams<itxn.AssetConfigFields, itxn.AssetConfigInnerTxn>(fields, TransactionType.AssetConfig)
+}
+export function assetTransfer(fields: itxn.AssetTransferFields): itxn.AssetTransferItxnParams {
+  ensureItxnGroupBegin()
+  return new ItxnParams<itxn.AssetTransferFields, itxn.AssetTransferInnerTxn>(fields, TransactionType.AssetTransfer)
+}
+export function assetFreeze(fields: itxn.AssetFreezeFields): itxn.AssetFreezeItxnParams {
+  ensureItxnGroupBegin()
+  return new ItxnParams<itxn.AssetFreezeFields, itxn.AssetFreezeInnerTxn>(fields, TransactionType.AssetFreeze)
+}
+export function applicationCall(fields: itxn.ApplicationCallFields): itxn.ApplicationCallItxnParams {
+  ensureItxnGroupBegin()
+  return new ItxnParams<itxn.ApplicationCallFields, itxn.ApplicationInnerTxn>(fields, TransactionType.ApplicationCall)
+}
+
+export class ItxnParams<TFields extends InnerTxnFields, TTransaction extends InnerTxn> {
+  #fields: TFields & { type: TransactionType }
+  constructor(fields: TFields, type: TransactionType) {
+    this.#fields = { ...fields, type }
+  }
+  submit(): TTransaction {
+    return createInnerTxn<InnerTxnFields, TTransaction>(this.#fields)
+  }
+
+  set(p: Partial<TFields>) {
+    Object.assign(this.#fields, p)
+  }
+
+  copy() {
+    return new ItxnParams<TFields, TTransaction>(this.#fields, this.#fields.type)
+  }
+}
+
+const ensureItxnGroupBegin = () => {
+  if (!lazyContext.activeGroup.constructingItxnGroup.length) {
+    lazyContext.activeGroup.beginInnerTransactionGroup()
   }
 }

src/subcontexts/transaction-context.ts

@@ -183,7 +183,7 @@ export class TransactionGroup {
     if (!this.constructingItxnGroup.length) {
       internal.errors.internalError('itxn next without itxn begin')
     }
-    this.constructingItxnGroup.push({} as InnerTxnFields)
+    this.constructingItxnGroup.push({ type: TransactionType.Payment } as InnerTxnFields)
   }
 
   submitInnerTransactionGroup() {

src/test-execution-context.ts

@@ -10,6 +10,15 @@ import { ContractContext } from './subcontexts/contract-context'
 import { LedgerContext } from './subcontexts/ledger-context'
 import { TransactionContext } from './subcontexts/transaction-context'
 import { ValueGenerator } from './value-generators'
+import {
+  submitGroup as itxnSubmitGroup,
+  payment as itxnPayment,
+  keyRegistration as itxnKeyRegistration,
+  assetConfig as itxnAssetConfig,
+  assetTransfer as itxnAssetTransfer,
+  assetFreeze as itxnAssetFreeze,
+  applicationCall as itxnApplicationCall,
+} from './impl/inner-transactions'
 
 export class TestExecutionContext implements internal.ExecutionContext {
   #applicationLogs: Map<bigint, bytes[]>
@@ -90,6 +99,18 @@ export class TestExecutionContext implements internal.ExecutionContext {
     }
   }
 
+  get itxn() {
+    return {
+      submitGroup: itxnSubmitGroup,
+      payment: itxnPayment,
+      keyRegistration: itxnKeyRegistration,
+      assetConfig: itxnAssetConfig,
+      assetTransfer: itxnAssetTransfer,
+      assetFreeze: itxnAssetFreeze,
+      applicationCall: itxnApplicationCall,
+    }
+  }
+
   reset() {
     this.#applicationLogs.clear()
     this.#contractContext = new ContractContext()

tests/artifacts/state-ops/contract.algo.ts

@@ -4,8 +4,12 @@ import {
   arc4,
   assert,
   Asset,
+  BaseContract,
   Bytes,
   bytes,
+  Global,
+  GlobalState,
+  itxn,
   op,
   TransactionType,
   Txn,
@@ -375,3 +379,98 @@ export class ITxnOpsContract extends arc4.Contract {
     assert(op.GITxn.typeEnum(1) == TransactionType.Payment)
   }
 }
+
+const APPROVE = Bytes('\x09\x81\x01')
+export class ItxnDemoContract extends BaseContract {
+  name = GlobalState({ initialValue: Bytes() })
+
+  public approvalProgram(): boolean {
+    if (Txn.numAppArgs) {
+      switch (Txn.applicationArgs(0)) {
+        case Bytes('test1'):
+          this.test1()
+          break
+        case Bytes('test2'):
+          this.test2()
+          break
+        case Bytes('test3'):
+        case Bytes('test4'):
+          break
+      }
+    }
+    return true
+  }
+
+  private test1() {
+    this.name.value = Bytes('AST1')
+
+    const assetParams = itxn.assetConfig({
+      total: 1000,
+      assetName: this.name.value,
+      unitName: 'unit',
+      decimals: 3,
+      manager: Global.currentApplicationAddress,
+      reserve: Global.currentApplicationAddress,
+    })
+
+    this.name.value = Bytes('AST2')
+    const asset1_txn = assetParams.submit()
+    assetParams.set({
+      assetName: this.name.value,
+    })
+    const asset2_txn = assetParams.submit()
+
+    assert(asset1_txn.assetName === Bytes('AST1'), 'asset1_txn is correct')
+    assert(asset2_txn.assetName === Bytes('AST2'), 'asset2_txn is correct')
+    assert(asset1_txn.createdAsset.name === Bytes('AST1'), 'created asset 1 is correct')
+    assert(asset2_txn.createdAsset.name === Bytes('AST2'), 'created asset 2 is correct')
+
+    const appCreateParams = itxn.applicationCall({
+      approvalProgram: Bytes.fromHex('098101'),
+      clearStateProgram: Bytes.fromHex('098101'),
+      fee: 0,
+    })
+
+    assetParams.set({
+      assetName: 'AST3',
+    })
+
+    const [appCreateTxn, asset3_txn] = itxn.submitGroup(appCreateParams, assetParams)
+
+    assert(appCreateTxn.appId, 'app is created')
+    assert(asset3_txn.assetName === Bytes('AST3'), 'asset3_txn is correct')
+
+    appCreateParams.set({
+      note: '3rd',
+    })
+    assetParams.set({
+      note: '3rd',
+    })
+    itxn.submitGroup(appCreateParams, assetParams)
+  }
+
+  private test2() {
+    let createAppParams: itxn.ApplicationCallItxnParams
+    if (Txn.numAppArgs) {
+      const args = [Bytes('1'), Bytes('2')] as const
+      createAppParams = itxn.applicationCall({
+        approvalProgram: APPROVE,
+        clearStateProgram: APPROVE,
+        appArgs: args,
+        onCompletion: arc4.OnCompleteAction.NoOp,
+        note: 'with args param set',
+      })
+    } else {
+      createAppParams = itxn.applicationCall({
+        approvalProgram: APPROVE,
+        clearStateProgram: APPROVE,
+        appArgs: [Bytes('3'), '4', Bytes('5')],
+        note: 'no args param set',
+      })
+    }
+    const createAppTxn = createAppParams.submit()
+    assert(createAppTxn.appArgs(0) === Bytes('1'), 'correct args used 1')
+    assert(createAppTxn.appArgs(1) === Bytes('2'), 'correct args used 2')
+    assert(createAppTxn.note === Bytes('with args param set'))
+  }
+}

tests/state-op-codes.spec.ts

@@ -18,6 +18,7 @@ import { AccountCls } from '../src/impl/account'
 import { asBigInt, asNumber, asUint64Cls } from '../src/util'
 import { AppExpectingEffects } from './artifacts/created-app-asset/contract.algo'
 import {
+  ItxnDemoContract,
   ITxnOpsContract,
   StateAcctParamsGetContract,
   StateAppParamsContract,
@@ -352,8 +353,18 @@ describe('State op codes', async () => {
       expect(asNumber((ctx.txn.lastActive as ApplicationTransaction).numLogs)).toEqual(0)
       expect((ctx.txn.lastActive as ApplicationTransaction).lastLog).toEqual(Bytes(''))
 
-      // Test created_app and created_asset (should be created for these transactions)
+      // Test created_app (should be created for these transactions)
       expect(appItxn.createdApp).toBeTruthy()
     })
+
+    it('should be able to invoke demo contract', async () => {
+      const contract = ctx.contract.create(ItxnDemoContract)
+      ctx.txn.createScope([ctx.any.txn.applicationCall({ appArgs: [Bytes('test1')] })]).execute(() => {
+        contract.approvalProgram()
+      })
+      ctx.txn.createScope([ctx.any.txn.applicationCall({ appArgs: [Bytes('test2')] })]).execute(() => {
+        contract.approvalProgram()
+      })
+    })
   })
 })