Merge pull request #9 from algorandfoundation/feat-test-contracts

feat: add test contracts in typescript

Author: boblat

package-lock.json

@@ -63,8 +63,8 @@
   },
   "dependencies": {
     "@algorandfoundation/algokit-utils": "^6.2.1",
-    "@algorandfoundation/algorand-typescript": "^0.0.1-alpha.15",
-    "@algorandfoundation/puya-ts": "^1.0.0-alpha.14",
+    "@algorandfoundation/algorand-typescript": "^0.0.1-alpha.16",
+    "@algorandfoundation/puya-ts": "^1.0.0-alpha.24",
     "algosdk": "^2.9.0",
     "elliptic": "^6.5.7",
     "js-sha256": "^0.11.0",

package.json

@@ -1,4 +1,4 @@
-import { arc4, bytes, Bytes, gtxn, internal } from '@algorandfoundation/algorand-typescript'
+import { arc4, bytes, Bytes, Ecdsa, gtxn, internal, VrfVerify } from '@algorandfoundation/algorand-typescript'
 import algosdk from 'algosdk'
 import { ec } from 'elliptic'
 import { sha256 as js_sha256 } from 'js-sha256'
@@ -68,7 +68,7 @@ export const ed25519verify = (
 }
 
 export const ecdsaVerify = (
-  v: internal.opTypes.Ecdsa,
+  v: Ecdsa,
   a: internal.primitives.StubBytesCompat,
   b: internal.primitives.StubBytesCompat,
   c: internal.primitives.StubBytesCompat,
@@ -91,13 +91,13 @@ export const ecdsaVerify = (
 }
 
 export const ecdsaPkRecover = (
-  v: internal.opTypes.Ecdsa,
+  v: Ecdsa,
   a: internal.primitives.StubBytesCompat,
   b: internal.primitives.StubUint64Compat,
   c: internal.primitives.StubBytesCompat,
   d: internal.primitives.StubBytesCompat,
 ): readonly [bytes, bytes] => {
-  if (v !== internal.opTypes.Ecdsa.Secp256k1) {
+  if (v !== Ecdsa.Secp256k1) {
     internal.errors.internalError(`Unsupported ECDSA curve: ${v}`)
   }
   const dataBytes = internal.primitives.BytesCls.fromCompat(a)
@@ -117,7 +117,7 @@ export const ecdsaPkRecover = (
   return [Bytes(x), Bytes(y)]
 }
 
-export const ecdsaPkDecompress = (v: internal.opTypes.Ecdsa, a: internal.primitives.StubBytesCompat): readonly [bytes, bytes] => {
+export const ecdsaPkDecompress = (v: Ecdsa, a: internal.primitives.StubBytesCompat): readonly [bytes, bytes] => {
   const bytesA = internal.primitives.BytesCls.fromCompat(a)
 
   const ecdsa = new ec(curveMap[v])
@@ -130,7 +130,7 @@ export const ecdsaPkDecompress = (v: internal.opTypes.Ecdsa, a: internal.primiti
 }
 
 export const vrfVerify = (
-  _s: internal.opTypes.VrfVerify,
+  _s: VrfVerify,
   _a: internal.primitives.StubBytesCompat,
   _b: internal.primitives.StubBytesCompat,
   _c: internal.primitives.StubBytesCompat,
@@ -145,6 +145,6 @@ export const EllipticCurve = new Proxy({} as internal.opTypes.EllipticCurveType,
 })
 
 const curveMap = {
-  [internal.opTypes.Ecdsa.Secp256k1]: 'secp256k1',
-  [internal.opTypes.Ecdsa.Secp256r1]: 'p256',
+  [Ecdsa.Secp256k1]: 'secp256k1',
+  [Ecdsa.Secp256r1]: 'p256',
 }

src/impl/crypto.ts

@@ -1,4 +1,4 @@
-import { biguint, Bytes, bytes, internal, Uint64, uint64 } from '@algorandfoundation/algorand-typescript'
+import { Base64, biguint, Bytes, bytes, internal, Uint64, uint64 } from '@algorandfoundation/algorand-typescript'
 import { BITS_IN_BYTE, MAX_BYTES_SIZE, MAX_UINT64, MAX_UINT8, UINT64_SIZE } from '../constants'
 import { notImplementedError, testInvariant } from '../errors'
 import { asBigUint, asBytes, asMaybeBytesCls, asMaybeUint64Cls, asUint64Cls, binaryStringToBytes } from '../util'
@@ -10,8 +10,8 @@ export const addw = (a: internal.primitives.StubUint64Compat, b: internal.primit
   return toUint128(sum)
 }
 
-export const base64Decode = (e: internal.opTypes.Base64, a: internal.primitives.StubBytesCompat): bytes => {
-  const encoding = e === internal.opTypes.Base64.StdEncoding ? 'base64' : 'base64url'
+export const base64Decode = (e: Base64, a: internal.primitives.StubBytesCompat): bytes => {
+  const encoding = e === Base64.StdEncoding ? 'base64' : 'base64url'
   const bytesValue = internal.primitives.BytesCls.fromCompat(a)
   const stringValue = bytesValue.toString()
 

src/impl/pure.ts

@@ -28,6 +28,16 @@ export const nodeFactory = {
       [left, right, factory.createStringLiteral(op)],
     )
   },
+  augmentedAssignmentBinaryOp(left: ts.Expression, right: ts.Expression, op: string) {
+    return factory.createAssignment(
+      left,
+      factory.createCallExpression(
+        factory.createPropertyAccessExpression(factory.createIdentifier('runtimeHelpers'), factory.createIdentifier('binaryOp')),
+        undefined,
+        [left, right, factory.createStringLiteral(op.replace('=', ''))],
+      ),
+    )
+  },
 
   prefixUnaryOp(operand: ts.Expression, op: string) {
     return factory.createCallExpression(

src/test-transformer/node-factory.ts

@@ -40,8 +40,6 @@ export function supportedBinaryOpString(x: BinaryOperator): string | undefined {
     case ts.SyntaxKind.AmpersandAmpersandEqualsToken:
     case ts.SyntaxKind.AmpersandAmpersandToken:
     case ts.SyntaxKind.AmpersandEqualsToken:
-    case ts.SyntaxKind.AsteriskAsteriskEqualsToken:
-    case ts.SyntaxKind.AsteriskEqualsToken:
     case ts.SyntaxKind.BarBarEqualsToken:
     case ts.SyntaxKind.BarBarToken:
     case ts.SyntaxKind.BarEqualsToken:
@@ -52,11 +50,7 @@ export function supportedBinaryOpString(x: BinaryOperator): string | undefined {
     case ts.SyntaxKind.ExclamationEqualsToken:
     case ts.SyntaxKind.InKeyword:
     case ts.SyntaxKind.InstanceOfKeyword:
-    case ts.SyntaxKind.PercentEqualsToken:
-    case ts.SyntaxKind.PlusEqualsToken:
     case ts.SyntaxKind.QuestionQuestionEqualsToken:
-    case ts.SyntaxKind.MinusEqualsToken:
-    case ts.SyntaxKind.SlashEqualsToken:
     case ts.SyntaxKind.QuestionQuestionToken:
     case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:
     case ts.SyntaxKind.LessThanLessThanEqualsToken:
@@ -66,6 +60,25 @@ export function supportedBinaryOpString(x: BinaryOperator): string | undefined {
   }
 }
 
+export function supportedAugmentedAssignmentBinaryOpString(x: BinaryOperator): string | undefined {
+  switch (x) {
+    case ts.SyntaxKind.PlusEqualsToken:
+      return '+='
+    case ts.SyntaxKind.MinusEqualsToken:
+      return '-='
+    case ts.SyntaxKind.SlashEqualsToken:
+      return '/='
+    case ts.SyntaxKind.AsteriskEqualsToken:
+      return '*='
+    case ts.SyntaxKind.AsteriskAsteriskEqualsToken:
+      return '**='
+    case ts.SyntaxKind.PercentEqualsToken:
+      return '%='
+    default:
+      return undefined
+  }
+}
+
 export function supportedPrefixUnaryOpString(x: PrefixUnaryOperator): string | undefined {
   switch (x) {
     case ts.SyntaxKind.TildeToken:

src/test-transformer/supported-binary-op-string.ts

@@ -4,7 +4,11 @@ import type { TypeInfo } from '../encoders'
 import { DeliberateAny } from '../typescript-helpers'
 import { TransformerConfig } from './index'
 import { nodeFactory } from './node-factory'
-import { supportedBinaryOpString, supportedPrefixUnaryOpString } from './supported-binary-op-string'
+import {
+  supportedAugmentedAssignmentBinaryOpString,
+  supportedBinaryOpString,
+  supportedPrefixUnaryOpString,
+} from './supported-binary-op-string'
 
 const { factory } = ts
 
@@ -34,7 +38,7 @@ export class SourceFileVisitor {
         }
       },
       sourceLocation(node: ts.Node): SourceLocation {
-        return SourceLocation.fromNode(sourceFile, node, program.getCurrentDirectory())
+        return SourceLocation.fromNode(node, program.getCurrentDirectory())
       },
     }
   }
@@ -81,9 +85,13 @@ class FunctionOrMethodVisitor {
     }
 
     if (ts.isBinaryExpression(node)) {
-      const tokenText = supportedBinaryOpString(node.operatorToken.kind)
-      if (tokenText) {
-        return nodeFactory.binaryOp(node.left, node.right, tokenText)
+      const opTokenText = supportedBinaryOpString(node.operatorToken.kind)
+      if (opTokenText) {
+        return nodeFactory.binaryOp(node.left, node.right, opTokenText)
+      }
+      const augmentedAssignmentOpTokenText = supportedAugmentedAssignmentBinaryOpString(node.operatorToken.kind)
+      if (augmentedAssignmentOpTokenText) {
+        return nodeFactory.augmentedAssignmentBinaryOp(node.left, node.right, augmentedAssignmentOpTokenText)
       }
     }
     if (ts.isPrefixUnaryExpression(node)) {

src/test-transformer/visitors.ts

@@ -0,0 +1,95 @@
+import { arc4, bytes, Ecdsa, ensureBudget, op, OpUpFeeSource, uint64, VrfVerify } from '@algorandfoundation/algorand-typescript'
+
+export class CryptoOpsContract extends arc4.Contract {
+  @arc4.abimethod()
+  public verify_sha256(a: bytes, pad_size: uint64): bytes {
+    const paddedA = op.bzero(pad_size).concat(a)
+    const result = op.sha256(paddedA)
+    return result
+  }
+
+  @arc4.abimethod()
+  public verify_sha3_256(a: bytes, pad_size: uint64): bytes {
+    const paddedA = op.bzero(pad_size).concat(a)
+    const result = op.sha3_256(paddedA)
+    return result
+  }
+
+  @arc4.abimethod()
+  public verify_keccak_256(a: bytes, pad_size: uint64): bytes {
+    const paddedA = op.bzero(pad_size).concat(a)
+    const result = op.keccak256(paddedA)
+    return result
+  }
+
+  @arc4.abimethod()
+  public verify_sha512_256(a: bytes, pad_size: uint64): bytes {
+    const paddedA = op.bzero(pad_size).concat(a)
+    const result = op.sha512_256(paddedA)
+    return result
+  }
+
+  // TODO: return arc4.Bool to match python version when arc4 types are available
+  @arc4.abimethod()
+  public verify_ed25519verify(a: bytes, b: bytes, c: bytes): boolean {
+    ensureBudget(1900, OpUpFeeSource.GroupCredit)
+    const result = op.ed25519verify(a, b, c)
+    return result
+  }
+
+  // TODO: return arc4.Bool to match python version when arc4 types are available
+  @arc4.abimethod()
+  public verify_ed25519verify_bare(a: bytes, b: bytes, c: bytes): boolean {
+    ensureBudget(1900, OpUpFeeSource.GroupCredit)
+    const result = op.ed25519verifyBare(a, b, c)
+    return result
+  }
+
+  @arc4.abimethod()
+  public verify_ecdsa_verify_k1(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes): boolean {
+    ensureBudget(3000, OpUpFeeSource.GroupCredit)
+    const result_k1 = op.ecdsaVerify(Ecdsa.Secp256k1, a, b, c, d, e)
+    return result_k1
+  }
+
+  @arc4.abimethod()
+  public verify_ecdsa_verify_r1(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes): boolean {
+    ensureBudget(3000, OpUpFeeSource.GroupCredit)
+    const result_r1 = op.ecdsaVerify(Ecdsa.Secp256r1, a, b, c, d, e)
+    return result_r1
+  }
+
+  @arc4.abimethod()
+  public verify_ecdsa_recover_k1(a: bytes, b: uint64, c: bytes, d: bytes): readonly [bytes, bytes] {
+    ensureBudget(3000, OpUpFeeSource.GroupCredit)
+    return op.ecdsaPkRecover(Ecdsa.Secp256k1, a, b, c, d)
+  }
+
+  @arc4.abimethod()
+  public verify_ecdsa_recover_r1(a: bytes, b: uint64, c: bytes, d: bytes): readonly [bytes, bytes] {
+    /**
+     * Must fail, AVM does not support Secp256r1 for recover
+     */
+    ensureBudget(3000, OpUpFeeSource.GroupCredit)
+    return op.ecdsaPkRecover(Ecdsa.Secp256r1, a, b, c, d)
+  }
+
+  @arc4.abimethod()
+  public verify_ecdsa_decompress_k1(a: bytes): readonly [bytes, bytes] {
+    ensureBudget(700, OpUpFeeSource.GroupCredit)
+    return op.ecdsaPkDecompress(Ecdsa.Secp256k1, a)
+  }
+
+  @arc4.abimethod()
+  public verify_ecdsa_decompress_r1(a: bytes): readonly [bytes, bytes] {
+    ensureBudget(700, OpUpFeeSource.GroupCredit)
+    return op.ecdsaPkDecompress(Ecdsa.Secp256r1, a)
+  }
+
+  @arc4.abimethod()
+  public verify_vrf_verify(a: bytes, b: bytes, c: bytes): readonly [bytes, boolean] {
+    ensureBudget(5700, OpUpFeeSource.GroupCredit)
+    const result = op.vrfVerify(VrfVerify.VrfAlgorand, a, b, c)
+    return result
+  }
+}