application.py

from typing import Literal

from pyteal import *
from beaker import *

# Define some types by name for handy reference

VrfProof = abi.StaticBytes[Literal[80]]
VrfHash = abi.StaticBytes[Literal[64]]


BlockSeed = abi.StaticBytes[Literal[32]]


class BlockDetails(abi.NamedTuple):
    ts: abi.Field[abi.Uint64]
    seed: abi.Field[BlockSeed]


Signature = abi.StaticBytes[Literal[64]]


class JsonExampleResult(abi.NamedTuple):
    string_key: abi.Field[abi.String]
    uint_key: abi.Field[abi.Uint64]
    obj_key: abi.Field[abi.String]


class DemoAVM7(Application):
    """Examples for teal ops that are new for AVM 7"""

    @external
    def vrf_verify(
        self,
        msg: abi.DynamicBytes,
        proof: VrfProof,
        pub_key: abi.Address,
        *,
        output: VrfHash,
    ):
        """
        Verify that some message was used to generate a proof generated by a given public key

        Cost: Takes 5700 ops
        """
        return Seq(
            # Use the Algorand VRF
            vrf_result := VrfVerify.algorand(
                # Note: in practice the message is likely to be something like:
                #    sha512_256(concat(itob(round), block.seed(round)))
                # Get the bytes from the message
                msg.get(),
                # Get the bytes from the proof
                proof.get(),
                # Note: in practice this is likely to be some hardcoded public key or one of
                #   a set of "pre-approved" public keys
                # Get the pubkey bytes
                pub_key.get(),
            ),
            # Check Successful
            Assert(vrf_result.output_slots[1].load() == Int(1)),
            # Write the result to the output
            output.set(vrf_result.output_slots[0].load()),
        )

    @external
    def block(self, round: abi.Uint64, *, output: BlockDetails):
        """New block operations for getting timestamp or seed of a historical round"""
        return Seq(
            (ts := abi.Uint64()).set(Block.timestamp(round.get())),
            (seed := abi.make(BlockSeed)).set(Block.seed(round.get())),
            output.set(ts, seed),
        )

    @external
    def b64decode(self, b64encoded: abi.String, *, output: abi.String):
        """Base64Decode can be used to decode either a std or url encoded string

        Cost: 1 + 1 per 16 bytes of A

        Note:
            IF you have the option to decode prior to submitting the app call
            transaction, you _should_.
            This should _only_ be used in the case that there is no way to decode
            the bytestring prior to submitting the transaction.
        """
        return output.set(Base64Decode.std(b64encoded.get()))

    @external
    def json_ref(self, json_str: abi.String, *, output: JsonExampleResult):
        """
        Cost: 25 + 2 per 7 bytes of A

        """
        return Seq(
            (s := abi.String()).set(
                JsonRef.as_string(json_str.get(), Bytes("string_key"))
            ),
            (i := abi.Uint64()).set(
                JsonRef.as_uint64(json_str.get(), Bytes("uint_key"))
            ),
            (o := abi.String()).set(
                JsonRef.as_object(json_str.get(), Bytes("obj_key"))
            ),
            output.set(s, i, o),
        )

    @external
    def sha3_256(self, to_hash: abi.String, *, output: abi.DynamicBytes):
        """
        Cost: 130
        """
        return Seq(
            output.set(Sha3_256(to_hash.get())),
        )

    @external
    def replace(
        self,
        orig: abi.String,
        start: abi.Uint64,
        replace_with: abi.String,
        *,
        output: abi.String,
    ):
        """
        replace(abcdef, 1, xyz) => axyzef
        cannot _grow_ original string
        """

        return output.set(Replace(orig.get(), start.get(), replace_with.get()))

    @external
    def ed25519verify_bare(
        self, msg: abi.String, pubkey: abi.Address, sig: Signature, *, output: abi.Bool
    ):
        return output.set(Ed25519Verify_Bare(msg.get(), sig.get(), pubkey.get()))

    @external
    def noop(self):
        return Approve()

    @delete(authorize=Authorize.only(Global.creator_address()))
    def delete(self):
        return Approve()