@alephium/web3 1.3.0 → 1.5.0

package/src/codec/transaction-codec.ts

@@ -16,9 +16,6 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { Parser } from 'binary-parser'
-import { DecodedArray } from './array-codec'
-
 import { UnsignedTxCodec, UnsignedTx, unsignedTxCodec } from './unsigned-tx-codec'
 import { Signature, signaturesCodec } from './signature-codec'
 import { ContractOutputRef, contractOutputRefsCodec } from './contract-output-ref-codec'
@@ -26,61 +23,28 @@ import { Either } from './either-codec'
 import { AssetOutput, AssetOutputCodec } from './asset-output-codec'
 import { ContractOutput, ContractOutputCodec } from './contract-output-codec'
 import { FixedAssetOutput, Transaction as ApiTransaction } from '../api/api-alephium'
-import { binToHex, hexToBinUnsafe, concatBytes } from '../utils'
+import { binToHex, hexToBinUnsafe } from '../utils'
 import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
-import { Codec } from './codec'
+import { byteCodec, ObjectCodec } from './codec'
 import { Output, outputCodec, outputsCodec } from './output-codec'
 
 export interface Transaction {
   unsigned: UnsignedTx
   scriptExecutionOk: number
-  contractInputs: DecodedArray<ContractOutputRef>
-  generatedOutputs: DecodedArray<Output>
-  inputSignatures: DecodedArray<Signature>
-  scriptSignatures: DecodedArray<Signature>
+  contractInputs: ContractOutputRef[]
+  generatedOutputs: Output[]
+  inputSignatures: Signature[]
+  scriptSignatures: Signature[]
 }
 
-export class TransactionCodec implements Codec<Transaction> {
-  parser = new Parser()
-    .nest('unsigned', {
-      type: unsignedTxCodec.parser
-    })
-    .uint8('scriptExecutionOk')
-    .nest('contractInputs', {
-      type: contractOutputRefsCodec.parser
-    })
-    .nest('generatedOutputs', {
-      type: outputsCodec.parser
-    })
-    .nest('inputSignatures', {
-      type: signaturesCodec.parser
-    })
-    .nest('scriptSignatures', {
-      type: signaturesCodec.parser
-    })
-
-  encode(decodedTx: Transaction): Uint8Array {
-    return concatBytes([
-      unsignedTxCodec.encode(decodedTx.unsigned),
-      new Uint8Array([decodedTx.scriptExecutionOk]),
-      contractOutputRefsCodec.encode(decodedTx.contractInputs.value),
-      outputsCodec.encode(decodedTx.generatedOutputs.value),
-      signaturesCodec.encode(decodedTx.inputSignatures.value),
-      signaturesCodec.encode(decodedTx.scriptSignatures.value)
-    ])
-  }
-
-  decode(input: Uint8Array): Transaction {
-    return this.parser.parse(input)
-  }
-
+export class TransactionCodec extends ObjectCodec<Transaction> {
   encodeApiTransaction(input: ApiTransaction): Uint8Array {
     const decodedTx = TransactionCodec.fromApiTransaction(input)
     return this.encode(decodedTx)
   }
 
   decodeApiTransaction(input: Uint8Array): ApiTransaction {
-    const decodedTx = this.parser.parse(input)
+    const decodedTx = this.decode(input)
     return TransactionCodec.toApiTransaction(decodedTx)
   }
 
@@ -88,14 +52,14 @@ export class TransactionCodec implements Codec<Transaction> {
     const txId = UnsignedTxCodec.txId(transaction.unsigned)
     const unsigned = UnsignedTxCodec.toApiUnsignedTx(transaction.unsigned)
     const scriptExecutionOk = !!transaction.scriptExecutionOk
-    const contractInputs = transaction.contractInputs.value.map((contractInput) => {
+    const contractInputs = transaction.contractInputs.map((contractInput) => {
       const hint = contractInput.hint
       const key = binToHex(contractInput.key)
       return { hint, key }
     })
     const txIdBytes = hexToBinUnsafe(txId)
-    const generatedOutputs = transaction.generatedOutputs.value.map((output, index) => {
-      if (output.either === 0) {
+    const generatedOutputs = transaction.generatedOutputs.map((output, index) => {
+      if (output.kind === 'Left') {
         const fixedAssetOutput = AssetOutputCodec.toFixedAssetOutput(txIdBytes, output.value as AssetOutput, index)
         return { ...fixedAssetOutput, type: 'AssetOutput' }
       } else {
@@ -103,8 +67,8 @@ export class TransactionCodec implements Codec<Transaction> {
       }
     })
 
-    const inputSignatures = transaction.inputSignatures.value.map((signature) => binToHex(signature.value))
-    const scriptSignatures = transaction.scriptSignatures.value.map((signature) => binToHex(signature.value))
+    const inputSignatures = transaction.inputSignatures.map((signature) => binToHex(signature))
+    const scriptSignatures = transaction.scriptSignatures.map((signature) => binToHex(signature))
 
     return { unsigned, scriptExecutionOk, contractInputs, generatedOutputs, inputSignatures, scriptSignatures }
   }
@@ -117,30 +81,37 @@ export class TransactionCodec implements Codec<Transaction> {
     })
     const generatedOutputs: Either<AssetOutput, ContractOutput>[] = tx.generatedOutputs.map((output) => {
       if (output.type === 'AssetOutput') {
-        return outputCodec.fromLeft(AssetOutputCodec.fromFixedAssetOutput(output as FixedAssetOutput))
+        return { kind: 'Left', value: AssetOutputCodec.fromFixedAssetOutput(output as FixedAssetOutput) }
       } else if (output.type === 'ContractOutput') {
-        return outputCodec.fromRight(ContractOutputCodec.convertToOutput(output as ApiContractOutput))
+        return { kind: 'Right', value: ContractOutputCodec.convertToOutput(output as ApiContractOutput) }
       } else {
         throw new Error('Invalid output type')
       }
     })
 
     const inputSignatures: Signature[] = tx.inputSignatures.map((signature) => {
-      return { value: hexToBinUnsafe(signature) }
+      return hexToBinUnsafe(signature)
     })
     const scriptSignatures: Signature[] = tx.scriptSignatures.map((signature) => {
-      return { value: hexToBinUnsafe(signature) }
+      return hexToBinUnsafe(signature)
     })
 
     return {
       unsigned,
       scriptExecutionOk,
-      contractInputs: contractOutputRefsCodec.fromArray(contractInputs),
-      generatedOutputs: outputsCodec.fromArray(generatedOutputs),
-      inputSignatures: signaturesCodec.fromArray(inputSignatures),
-      scriptSignatures: signaturesCodec.fromArray(scriptSignatures)
+      contractInputs: contractInputs,
+      generatedOutputs: generatedOutputs,
+      inputSignatures: inputSignatures,
+      scriptSignatures: scriptSignatures
     }
   }
 }
 
-export const transactionCodec = new TransactionCodec()
+export const transactionCodec = new TransactionCodec({
+  unsigned: unsignedTxCodec,
+  scriptExecutionOk: byteCodec,
+  contractInputs: contractOutputRefsCodec,
+  generatedOutputs: outputsCodec,
+  inputSignatures: signaturesCodec,
+  scriptSignatures: signaturesCodec
+})

package/src/codec/unlock-script-codec.ts

@@ -15,179 +15,52 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-import { Parser } from 'binary-parser'
-import { ArrayCodec, DecodedArray } from './array-codec'
-import { compactUnsignedIntCodec, compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
-import { Codec, fixedSizeBytes } from './codec'
-import { DecodedScript, scriptCodec } from './script-codec'
-import { ByteString, byteStringCodec } from './bytestring-codec'
-import { LockupScript, lockupScriptCodec } from './lockup-script-codec'
-import { concatBytes } from '../utils'
-
-export interface P2PKH {
-  publicKey: Uint8Array
-}
-
-class P2PKHCodec implements Codec<P2PKH> {
-  parser = fixedSizeBytes('publicKey', 33)
-
-  encode(input: P2PKH): Uint8Array {
-    return input.publicKey
-  }
-
-  decode(input: Uint8Array): P2PKH {
-    return this.parser.parse(input)
-  }
-}
-const p2pkhCodec = new P2PKHCodec()
-
-export interface P2MPKH {
-  publicKeys: DecodedArray<{
-    publicKey: P2PKH
-    index: DecodedCompactInt
-  }>
-}
-
-class P2MPKHCodec implements Codec<P2MPKH> {
-  parser = Parser.start().nest('publicKeys', {
-    type: ArrayCodec.arrayParser(
-      Parser.start()
-        .nest('publicKey', { type: p2pkhCodec.parser })
-        .nest('index', { type: compactUnsignedIntCodec.parser })
-    )
-  })
-
-  encode(input: P2MPKH): Uint8Array {
-    return concatBytes([
-      compactUnsignedIntCodec.encode(input.publicKeys.length),
-      ...input.publicKeys.value.map((v) => {
-        return concatBytes([v.publicKey.publicKey, compactUnsignedIntCodec.encode(v.index)])
-      })
-    ])
-  }
-
-  decode(input: Uint8Array): any {
-    return this.parser.parse(input)
-  }
-}
-const p2mpkhCodec = new P2MPKHCodec()
-
-export interface Val {
-  type: number
-  val: number | DecodedCompactInt | ByteString | LockupScript
-}
-class ValCodec implements Codec<Val> {
-  parser = Parser.start()
-    .int8('type')
-    .choice('val', {
-      tag: 'type',
-      choices: {
-        0x00: new Parser().uint8('value'), // Boolean
-        0x01: compactSignedIntCodec.parser, // I256
-        0x02: compactUnsignedIntCodec.parser, // U256
-        0x03: byteStringCodec.parser, // ByteVec
-        0x04: lockupScriptCodec.parser // Address
-      }
-    })
-
-  encode(input: Val): Uint8Array {
-    const valType = input.type
-
-    if (valType === 0x00) {
-      // Boolean
-      return new Uint8Array([valType, input.val as number])
-    } else if (valType === 0x01) {
-      // I256
-      return new Uint8Array([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
-    } else if (valType === 0x02) {
-      // U256
-      return new Uint8Array([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
-    } else if (valType === 0x03) {
-      // ByteVec
-      return new Uint8Array([valType, ...byteStringCodec.encode(input.val as ByteString)])
-    } else if (valType === 0x04) {
-      // Address
-      return new Uint8Array([valType, ...lockupScriptCodec.encode(input.val as LockupScript)])
-    } else {
-      throw new Error(`ValCodec: unsupported val type: ${valType}`)
-    }
-  }
-
-  decode(input: Uint8Array): Val {
-    return this.parser.parse(input)
-  }
+import { ArrayCodec } from './array-codec'
+import { i32Codec } from './compact-int-codec'
+import { Codec, EnumCodec, FixedSizeCodec, ObjectCodec } from './codec'
+import { Script, scriptCodec } from './script-codec'
+import { Val, valsCodec } from './val'
+
+export type P2PKH = Uint8Array
+export interface KeyWithIndex {
+  publicKey: P2PKH
+  index: number
 }
-
-const valCodec = new ValCodec()
-const valsCodec = new ArrayCodec(valCodec)
-
+export type P2MPKH = KeyWithIndex[]
 export interface P2SH {
-  script: DecodedScript
-  params: DecodedArray<Val>
-}
-
-export class P2SHCodec implements Codec<P2SH> {
-  parser = Parser.start()
-    .nest('script', {
-      type: scriptCodec.parser
-    })
-    .nest('params', {
-      type: valsCodec.parser
-    })
-
-  encode(input: P2SH): Uint8Array {
-    return concatBytes([scriptCodec.encode(input.script), valsCodec.encode(input.params.value)])
-  }
-
-  decode(input: Uint8Array): P2SH {
-    return this.parser.parse(input)
-  }
+  script: Script
+  params: Val[]
 }
-
-const p2shCodec = new P2SHCodec()
-
-export interface UnlockScript {
-  scriptType: number
-  script: P2PKH | P2MPKH | P2SH
-}
-
-export class UnlockScriptCodec implements Codec<UnlockScript> {
-  parser = Parser.start()
-    .uint8('scriptType')
-    .choice('script', {
-      tag: 'scriptType',
-      choices: {
-        0: p2pkhCodec.parser,
-        1: p2mpkhCodec.parser,
-        2: p2shCodec.parser,
-        3: Parser.start() // TODO: SameAsPrevious, FIXME
-      }
-    })
-
-  encode(input: UnlockScript): Uint8Array {
-    const scriptType = input.scriptType
-    const inputUnLockScript = input.script
-
-    if (scriptType === 0) {
-      // P2PKH
-      return new Uint8Array([scriptType, ...p2pkhCodec.encode(inputUnLockScript as P2PKH)])
-    } else if (scriptType === 1) {
-      // P2MPKH
-      return new Uint8Array([scriptType, ...p2mpkhCodec.encode(inputUnLockScript as P2MPKH)])
-    } else if (scriptType === 2) {
-      // P2SH
-      return new Uint8Array([scriptType, ...p2shCodec.encode(inputUnLockScript as P2SH)])
-    } else if (scriptType === 3) {
-      // SameAsPrevious
-      return new Uint8Array([scriptType])
-    } else {
-      throw new Error(`TODO: encode unlock script: ${scriptType}`)
-    }
+export type SameAsPrevious = 'SameAsPrevious'
+
+export type UnlockScript =
+  | { kind: 'P2PKH'; value: P2PKH }
+  | { kind: 'P2MPKH'; value: P2MPKH }
+  | { kind: 'P2SH'; value: P2SH }
+  | { kind: 'SameAsPrevious'; value: SameAsPrevious }
+
+const p2pkhCodec = new FixedSizeCodec(33)
+const keyWithIndexCodec = new ObjectCodec<KeyWithIndex>({
+  publicKey: p2pkhCodec,
+  index: i32Codec
+})
+const p2mpkhCodec: Codec<P2MPKH> = new ArrayCodec(keyWithIndexCodec)
+const p2shCodec = new ObjectCodec<P2SH>({
+  script: scriptCodec,
+  params: valsCodec
+})
+const sameAsPreviousCodec = new (class extends Codec<SameAsPrevious> {
+  encode(): Uint8Array {
+    return new Uint8Array([])
   }
-
-  decode(input: Uint8Array): UnlockScript {
-    return this.parser.parse(input)
+  _decode(): SameAsPrevious {
+    return 'SameAsPrevious'
   }
-}
-
-export const unlockScriptCodec = new UnlockScriptCodec()
+})()
+
+export const unlockScriptCodec = new EnumCodec<UnlockScript>('unlock script', {
+  P2PKH: p2pkhCodec,
+  P2MPKH: p2mpkhCodec,
+  P2SH: p2shCodec,
+  SameAsPrevious: sameAsPreviousCodec
+})

package/src/codec/unsigned-tx-codec.ts

@@ -15,70 +15,34 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-import { Parser } from 'binary-parser'
 import { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium'
-import { binToHex, concatBytes, hexToBinUnsafe } from '../utils'
-import { DecodedScript, scriptCodec, statefulScriptCodecOpt } from './script-codec'
+import { binToHex, hexToBinUnsafe } from '../utils'
+import { Script, scriptCodec, statefulScriptCodecOpt } from './script-codec'
 import { Option } from './option-codec'
-import { DecodedCompactInt, compactSignedIntCodec, compactUnsignedIntCodec } from './compact-int-codec'
+import { i32Codec, u256Codec } from './compact-int-codec'
 import { Input, InputCodec, inputsCodec } from './input-codec'
 import { AssetOutput, AssetOutputCodec, assetOutputsCodec } from './asset-output-codec'
-import { DecodedArray } from './array-codec'
 import { blakeHash } from './hash'
-import { Codec } from './codec'
+import { byteCodec, ObjectCodec } from './codec'
 
 export interface UnsignedTx {
   version: number
   networkId: number
-  statefulScript: Option<DecodedScript>
-  gasAmount: DecodedCompactInt
-  gasPrice: DecodedCompactInt
-  inputs: DecodedArray<Input>
-  fixedOutputs: DecodedArray<AssetOutput>
+  statefulScript: Option<Script>
+  gasAmount: number
+  gasPrice: bigint
+  inputs: Input[]
+  fixedOutputs: AssetOutput[]
 }
 
-export class UnsignedTxCodec implements Codec<UnsignedTx> {
-  parser = new Parser()
-    .uint8('version')
-    .uint8('networkId')
-    .nest('statefulScript', {
-      type: statefulScriptCodecOpt.parser
-    })
-    .nest('gasAmount', {
-      type: compactSignedIntCodec.parser
-    })
-    .nest('gasPrice', {
-      type: compactUnsignedIntCodec.parser
-    })
-    .nest('inputs', {
-      type: inputsCodec.parser
-    })
-    .nest('fixedOutputs', {
-      type: assetOutputsCodec.parser
-    })
-
-  encode(decodedUnsignedTx: UnsignedTx): Uint8Array {
-    return concatBytes([
-      new Uint8Array([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
-      statefulScriptCodecOpt.encode(decodedUnsignedTx.statefulScript),
-      compactSignedIntCodec.encode(decodedUnsignedTx.gasAmount),
-      compactUnsignedIntCodec.encode(decodedUnsignedTx.gasPrice),
-      inputsCodec.encode(decodedUnsignedTx.inputs.value),
-      assetOutputsCodec.encode(decodedUnsignedTx.fixedOutputs.value)
-    ])
-  }
-
-  decode(input: Uint8Array): UnsignedTx {
-    return this.parser.parse(input)
-  }
-
+export class UnsignedTxCodec extends ObjectCodec<UnsignedTx> {
   encodeApiUnsignedTx(input: ApiUnsignedTx): Uint8Array {
     const decoded = UnsignedTxCodec.fromApiUnsignedTx(input)
     return this.encode(decoded)
   }
 
   decodeApiUnsignedTx(input: Uint8Array): ApiUnsignedTx {
-    const decoded = this.parser.parse(input)
+    const decoded = this.decode(input)
     return UnsignedTxCodec.toApiUnsignedTx(decoded)
   }
 
@@ -91,13 +55,13 @@ export class UnsignedTxCodec implements Codec<UnsignedTx> {
     const txIdBytes = hexToBinUnsafe(txId)
     const version = unsigned.version
     const networkId = unsigned.networkId
-    const gasAmount = compactSignedIntCodec.toI32(unsigned.gasAmount)
-    const gasPrice = compactUnsignedIntCodec.toU256(unsigned.gasPrice).toString()
-    const inputs = InputCodec.toAssetInputs(unsigned.inputs.value)
-    const fixedOutputs = AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs.value)
+    const gasAmount = unsigned.gasAmount
+    const gasPrice = unsigned.gasPrice.toString()
+    const inputs = InputCodec.toAssetInputs(unsigned.inputs)
+    const fixedOutputs = AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs)
     let scriptOpt: string | undefined = undefined
-    if (unsigned.statefulScript.option === 1) {
-      scriptOpt = binToHex(scriptCodec.encode(unsigned.statefulScript.value!))
+    if (unsigned.statefulScript.kind === 'Some') {
+      scriptOpt = binToHex(scriptCodec.encode(unsigned.statefulScript.value))
     }
 
     return { txId, version, networkId, gasAmount, scriptOpt, gasPrice, inputs, fixedOutputs }
@@ -106,18 +70,25 @@ export class UnsignedTxCodec implements Codec<UnsignedTx> {
   static fromApiUnsignedTx(unsignedTx: ApiUnsignedTx): UnsignedTx {
     const version = unsignedTx.version
     const networkId = unsignedTx.networkId
-    const gasAmount = compactSignedIntCodec.fromI32(unsignedTx.gasAmount)
-    const gasPrice = compactUnsignedIntCodec.fromU256(BigInt(unsignedTx.gasPrice))
-    const inputsValue = InputCodec.fromAssetInputs(unsignedTx.inputs)
-    const inputs = inputsCodec.fromArray(inputsValue)
-    const fixedOutputsValue = AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs)
-    const fixedOutputs = assetOutputsCodec.fromArray(fixedOutputsValue)
-    const statefulScript = statefulScriptCodecOpt.fromBytes(
-      unsignedTx.scriptOpt ? hexToBinUnsafe(unsignedTx.scriptOpt) : undefined
-    )
+    const gasAmount = unsignedTx.gasAmount
+    const gasPrice = BigInt(unsignedTx.gasPrice)
+    const inputs = InputCodec.fromAssetInputs(unsignedTx.inputs)
+    const fixedOutputs = AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs)
+    const statefulScript: Option<Script> =
+      unsignedTx.scriptOpt !== undefined
+        ? { kind: 'Some', value: scriptCodec.decode(hexToBinUnsafe(unsignedTx.scriptOpt)) }
+        : { kind: 'None', value: undefined }
 
     return { version, networkId, gasAmount, gasPrice, inputs, fixedOutputs, statefulScript }
   }
 }
 
-export const unsignedTxCodec = new UnsignedTxCodec()
+export const unsignedTxCodec = new UnsignedTxCodec({
+  version: byteCodec,
+  networkId: byteCodec,
+  statefulScript: statefulScriptCodecOpt,
+  gasAmount: i32Codec,
+  gasPrice: u256Codec,
+  inputs: inputsCodec,
+  fixedOutputs: assetOutputsCodec
+})

package/src/codec/val.ts

@@ -0,0 +1,40 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { i256Codec, u256Codec } from './compact-int-codec'
+import { ByteString, byteStringCodec } from './bytestring-codec'
+import { boolCodec, EnumCodec } from './codec'
+import { LockupScript, lockupScriptCodec } from './lockup-script-codec'
+import { ArrayCodec } from './array-codec'
+
+export type ValBool = { kind: 'Bool'; value: boolean }
+export type ValI256 = { kind: 'I256'; value: bigint }
+export type ValU256 = { kind: 'U256'; value: bigint }
+export type ValByteVec = { kind: 'ByteVec'; value: ByteString }
+export type ValAddress = { kind: 'Address'; value: LockupScript }
+
+export type Val = ValBool | ValI256 | ValU256 | ValByteVec | ValAddress
+
+export const valCodec = new EnumCodec<Val>('val', {
+  Bool: boolCodec,
+  I256: i256Codec,
+  U256: u256Codec,
+  ByteVec: byteStringCodec,
+  Address: lockupScriptCodec
+})
+export const valsCodec = new ArrayCodec(valCodec)

package/src/contract/contract.ts

@@ -64,8 +64,6 @@ import * as blake from 'blakejs'
 import { isContractDebugMessageEnabled } from '../debug'
 import {
   contract,
-  compactUnsignedIntCodec,
-  compactSignedIntCodec,
   Method,
   LoadLocal,
   LoadImmFieldByIndex,
@@ -86,7 +84,8 @@ import {
   CallExternal,
   Dup,
   CallerAddress,
-  ByteConst
+  i32Codec,
+  BytesConst
 } from '../codec'
 
 const crypto = new WebCrypto()
@@ -112,7 +111,8 @@ export const DEFAULT_NODE_COMPILER_OPTIONS: node.CompilerOptions = {
   ignoreUnusedFieldsWarnings: false,
   ignoreUnusedPrivateFunctionsWarnings: false,
   ignoreUpdateFieldsCheckWarnings: false,
-  ignoreCheckExternalCallerWarnings: false
+  ignoreCheckExternalCallerWarnings: false,
+  ignoreUnusedFunctionReturnWarnings: false
 }
 
 export const DEFAULT_COMPILER_OPTIONS: CompilerOptions = { errorOnWarnings: true, ...DEFAULT_NODE_COMPILER_OPTIONS }
@@ -1010,6 +1010,12 @@ export abstract class ContractFactory<I extends ContractInstance, F extends Fiel
     }
   }
 
+  async deployTemplate(signer: SignerProvider): Promise<DeployContractResult<I>> {
+    return this.deploy(signer, {
+      initialFields: this.contract.getInitialFieldsWithDefaultValues() as F
+    })
+  }
+
   // This is used for testing contract functions
   stateForTest(initFields: F, asset?: Asset, address?: string): ContractState<F> {
     const newAsset = {
@@ -1681,10 +1687,10 @@ export async function signExecuteMethod<I extends ContractInstance, F extends Fi
 ): Promise<SignExecuteScriptTxResult> {
   const methodIndex = contract.contract.getMethodIndex(methodName)
   const functionSig = contract.contract.functions[methodIndex]
-  const usePreapprovedAssets = contract.contract.decodedMethods[methodIndex].usePreapprovedAssets
+  const methodUsePreapprovedAssets = contract.contract.decodedMethods[methodIndex].usePreapprovedAssets
   const bytecodeTemplate = getBytecodeTemplate(
     methodIndex,
-    usePreapprovedAssets,
+    methodUsePreapprovedAssets,
     functionSig,
     contract.contract.structs,
     params.attoAlphAmount,
@@ -1716,7 +1722,7 @@ export async function signExecuteMethod<I extends ContractInstance, F extends Fi
 
 function getBytecodeTemplate(
   methodIndex: number,
-  usePreapprovedAssets: boolean,
+  methodUsePreapprovedAssets: boolean,
   functionSig: FunctionSig,
   structs: Struct[],
   attoAlphAmount?: Number256,
@@ -1725,14 +1731,19 @@ function getBytecodeTemplate(
   // For the default TxScript main function
   const numberOfMethods = '01'
   const isPublic = '01'
-  const modifier = usePreapprovedAssets ? '03' : '00'
+  const scriptUseApprovedAssets = attoAlphAmount !== undefined || tokens !== undefined
+  const modifier = scriptUseApprovedAssets ? '03' : '00'
   const argsLength = '00'
   const returnsLength = '00'
 
+  if (methodUsePreapprovedAssets && !scriptUseApprovedAssets) {
+    throw new Error('The contract call requires preapproved assets but none are provided')
+  }
+
   const [templateVarStoreLocalInstrs, templateVarsLength] = getTemplateVarStoreLocalInstrs(functionSig, structs)
 
-  const approveAlphInstrs: string[] = getApproveAlphInstrs(usePreapprovedAssets ? attoAlphAmount : undefined)
-  const approveTokensInstrs: string[] = getApproveTokensInstrs(usePreapprovedAssets ? tokens : undefined)
+  const approveAlphInstrs: string[] = getApproveAlphInstrs(methodUsePreapprovedAssets ? attoAlphAmount : undefined)
+  const approveTokensInstrs: string[] = getApproveTokensInstrs(methodUsePreapprovedAssets ? tokens : undefined)
   const callerInstrs: string[] = getCallAddressInstrs(approveAlphInstrs.length / 2 + approveTokensInstrs.length / 3)
 
   // First template var is the contract
@@ -1797,14 +1808,7 @@ function getApproveTokensInstrs(tokens?: Token[]): string[] {
   if (tokens) {
     tokens.forEach((token) => {
       const tokenIdBin = hexToBinUnsafe(token.id)
-      approveTokensInstrs.push(
-        encodeInstr(
-          ByteConst({
-            length: compactSignedIntCodec.fromI32(tokenIdBin.length),
-            value: tokenIdBin
-          })
-        )
-      )
+      approveTokensInstrs.push(encodeInstr(BytesConst(tokenIdBin)))
       approveTokensInstrs.push(encodeU256Const(BigInt(token.amount)))
       approveTokensInstrs.push(encodeInstr(ApproveToken))
     })
@@ -1891,7 +1895,7 @@ function encodeLoadLocalInstr(index: number): string {
 }
 
 function encodeI32(value: number): string {
-  return binToHex(compactSignedIntCodec.encodeI32(value))
+  return binToHex(i32Codec.encode(value))
 }
 
 function encodeU256Const(value: bigint): string {
@@ -1902,7 +1906,7 @@ function encodeU256Const(value: bigint): string {
   if (value < 6) {
     return (BigInt(0x0c) + value).toString(16).padStart(2, '0')
   } else {
-    return encodeInstr(U256Const(compactUnsignedIntCodec.fromU256(BigInt(value))))
+    return encodeInstr(U256Const(value))
   }
 }