@goplausible/algorand-mcp 3.0.7

package/dist/resources/knowledge/taxonomy/developer:docs:details:dapps:smart-contracts:smartsigs:walkthrough.md

@@ -0,0 +1,159 @@
+title: CLI smart signatures
+
+This guide covers working with the `goal` command-line tool with smart signatures.
+
+TEAL programs can be written with any editor and are compiled using the `goal` command-line tool. They can also be built using python with the [PyTeal Library](/docs/get-details/dapps/writing-contracts/pyteal). The command-line tool provides the ability to use these compiled programs within transactions. 
+
+# Simple TEAL example
+The simplest program you can write in TEAL is probably the following:
+
+```go
+// simple.teal
+// Do not use this in a real application
+int 0
+```
+This simplistic example always returns false and should never be used in a real transaction. 
+
+The following command illustrates compiling this program:
+
+```
+goal clerk compile simple.teal
+// Compile output
+simple.teal: 6Z3C3LDVWGMX23BMSYMANACQOSINPFIRF77H7N3AWJZYV6OH6GWTJKVMXY
+```
+
+The compilation returns an Algorand Address. This is the contract account address if the TEAL program is used as a contract account. If the TEAL program is intended to be used as a delegated signature, the logic should be signed with a private key. This is done using the `-s` option with the `goal clerk compile` command. The following example shows using goal to compile and sign the TEAL program in one operation.
+
+```
+goal clerk compile simple.teal -o mydelegatedsig.lsig -s -a C3MKH24QL3GHSD5CDQ47ZNQZMNZRX4MUTV6LVPAXMWAXMIISYSOWPGH674 -d ~/node/data
+```
+
+Logic is signed with a specific address specified with the `-a` option. If no default wallet is assigned, the `-w` option is used to specify the wallet that contains the account that is signing the logic.
+
+The `-o` option specifies the name of the logic signature file. In this example, the file mydelegatedsig.lsig is created. This file can be shared to let others submit transactions with the authority of the original signer. When this logic signature is used in a transaction the logic will determine if the transaction is approved. The following example shows how the logic signature is used in a transaction with `goal`
+
+```
+goal clerk send -f C3MKH24QL3GHSD5CDQ47ZNQZMNZRX4MUTV6LVPAXMWAXMIISYSOWPGH674 -a 1000000 -t STF6TH6PKINM4CDIQHNSC7QEA4DM5OJKKSACAPWGTG776NWSQOMAYVGOQE -L mydelegatedsig.lsig -d ~/node/data
+```
+The `-f` option specifies the account that signed the logic signature and the -t option specifies the receiver of the transaction. The transaction fee is paid by the account that signed the logic signature. 
+
+# Compiling TEAL options
+Compiling a teal program using the `goal clerk compile` compiles and writes the binary raw bytes to a file with the same name as the source file with a `.tok` extension. Specifying the `-n` option will compile the TEAL program, but not write out the binary. The console will display the compiled TEAL's address.
+
+```
+$ goal clerk compile -n simple.teal
+simple.teal: KI4DJG2OOFJGUERJGSWCYGFZWDNEU2KWTU56VRJHITP62PLJ5VYMBFDBFE
+```
+
+Removing the `-n` option writes the binary to a file named simple.teal.tok. Supplying the `-o` option allows the binary to be written to a specific location and filename.
+
+```
+goal clerk compile  simple.teal -o /tmp/mytealbinary.tealc
+```
+
+The raw binary TEAL program can be disassembled using the `-D` option.
+
+```
+$ goal clerk compile -D /tmp/mytealbinary.tealc
+// Terminal Output
+// version 1
+intcblock 0
+intc_0
+```
+
+In the above examples, the TEAL program is compiled and can be used as a contract account as discussed in the [Usage Modes](../modes) documentation. To use TEAL for account [delegation](../modes#delegated-account), the program must be signed by an account or a multi-signature account. This can be done with `goal` using the `-s` option. The following will produce a LogicSig file.
+
+```
+goal clerk compile  simple.teal -o /tmp/simple.lsig -s -d ~/node/data
+```
+
+In the example above, the `-o` option is used to produce the logic signature file, which contains the raw program binary and the signature as discussed in the [Logic Signature](../modes#logic-signatures) documentation. Using the `-a` option allows the TEAL program to be signed by a specific account.
+
+```
+goal clerk compile  simple.teal -o /tmp/simple.lsig -s -a LSJY4JD5J626BMJY2NMODBP64WDQP5OS4M6YF2F5BWQUS22I3YJYCXHHIA -d ~/node/data
+```
+
+A logic signature file can be disassembled in the same way as the standard binary.
+
+```
+goal clerk compile -D /tmp/simple.lsig
+// Console Output
+// version 1
+intcblock 0
+intc_0
+LogicSig: {
+  "sig": "45on5JUofgMjxL9e7IiPzCwutMHj3hFS1bKnCpxjgQ06dhikUgQSadqxcSOMKlcpN31W88hzkv3AeUUDLc4qAg=="
+}
+```
+
+# Creating a multi-signature delegated logic sig
+In the previous section, a logic signature was created using a single account. As discussed in the [Logic Signature](../modes#logic-signatures) documentation, LogicSigs can also be created using a multi-signature account. For example, a three account multi-signature account with a threshold level of 2 can be created using the following command.
+
+```
+goal account multisig new -T 2 DFPKC2SJP3OTFVJFMCD356YB7BOT4SJZTGWLIPPFEWL3ZABUFLTOY6ILYE LSJY4JD5J626BMJY2NMODBP64WDQP5OS4M6YF2F5BWQUS22I3YJYCXHHIA YYKRMERAFXMXCDWMBNR6BUUWQXDCUR53FPUGXLUYS7VNASRTJW2ENQ7BMQ -d ~/node/data
+```
+
+This creates a multi-sig account that requires at least two signatures to authorize a transaction. To create a logic signature, any one of the three accounts can sign the logic and create a logic signature file. This is done using the `goal clerk multisig signprogram` command.
+
+```
+goal clerk multisig signprogram -p /tmp/simple.teal -a YYKRMERAFXMXCDWMBNR6BUUWQXDCUR53FPUGXLUYS7VNASRTJW2ENQ7BMQ -A 5DLEJBZHDG4XTIILEEJ6HSLG2YFGHNDAKIUAFASMFV234CJGEDQYMJ6LMI -o /tmp/simple.lsig -d ~/node/data
+```
+
+In the above example, the `-p` option specifies the TEAL program file. The TEAL program bytes can also be passed directly using the `-P` option. The `-a` option specifies which account is signing the logic and the `-A` specifies the multi-signature address. 
+
+At this point the logic signature file only contains one signature and the threshold is set to two. This means that in order for the logic signature to be used, one of the two remaining accounts must also sign the logic signature file. This is done using the `-L` option with the `goal clerk multisig signprogram` command.
+
+```
+goal clerk multisig signprogram -L /tmp/simple.lsig -a LSJY4JD5J626BMJY2NMODBP64WDQP5OS4M6YF2F5BWQUS22I3YJYCXHHIA -A 5DLEJBZHDG4XTIILEEJ6HSLG2YFGHNDAKIUAFASMFV234CJGEDQYMJ6LMI -d ~/node/data
+```
+
+Decompiling the logic signature shows the number of current signatures.
+
+```
+$ goal clerk compile -D /tmp/simple.lsig
+// Console Output
+// version 1
+intcblock 0
+intc_0
+LogicSig: {
+  "msig": {
+    "subsig": [
+      {
+        "pk": "YYKRMERAFXMXCDWMBNR6BUUWQXDCUR53FPUGXLUYS7VNASRTJW2ENQ7BMQ",
+        "s": "h7/CyM7aiJnDnXOjyNeY2DlOZhqieaWafO0n2Hi4d9IfyFozjKQL9/kB2x7QQV+bPRTORdbYCXpL2x6c5razAw=="
+      },
+      {
+        "pk": "LSJY4JD5J626BMJY2NMODBP64WDQP5OS4M6YF2F5BWQUS22I3YJYCXHHIA",
+        "s": "/s/BsHGK+RThEmrc2Wre/VVBX6jtqcMS/pZQTA0iBE3S5d+D4BFeD2JXRSAW/oD78V9SlLXSfOYGAfEnianaDw=="
+      }
+    ],
+    "thr": 2,
+    "v": 1
+  }
+}
+```
+# Passing parameters to TEAL with goal
+Parameters can be passed to a TEAL program using `goal`. The parameters must be passed as base64 encoded strings. For example, to pass “mystringargument” to a stateless TEAL program, the argument can be encoded using an `echo` command with base64. The `-w0` argument disables wrapping that defaults to 76 characters. 
+
+```
+$ echo -n mystringargument | base64 -w0
+bXlzdHJpbmdhcmd1bWVudA==
+```
+
+The base64 encoded string is passed to the TEAL program using the `--argb64` option. The `goal` command line can be passed multiple parameters using the `--argb64` option multiple times. The parameter order is specific and will directly map to the TEAL parameters array.
+
+```
+goal clerk send -a 1000 -c closeaccountotaddress --to toaddr --from-program myteal.teal --argb64 "bXlzdHJpbmdhcmd1bWVudA==" -d ~/node/data
+```
+
+The example above also illustrates using the `--from-program` option. This option instructs the compiler to compile a specific TEAL program and set it as the sender of the transaction. Because the `-s` option is not used, this account must be a contract account.
+
+Passing an integer to a TEAL program requires that it must be converted to a base64 encoded string as well when using `goal`. This can be done in many ways. The following example illustrates the conversion using a simple python command. 
+
+``` python
+$ python3 -c "import base64;print(base64.b64encode((123).to_bytes(8,'big')).decode('ascii'))"
+```
+
+The example above converts the integer value of 123 to a base64 encoded string. TEAL currently does not support negative numbers. 
+
+Each SDK provides facilities for passing parameters as well. These processes are described in the [Interact with smart signatures](../frontend/smartsigs.md) Usage documentation.

package/dist/resources/knowledge/taxonomy/developer:docs:details:dapps:writing-contracts:beaker.md

@@ -0,0 +1,341 @@
+title: Beaker
+
+!!! note
+For a native Python experience, checkout our [Algorand Python](https://algorandfoundation.github.io/puya/) docs.
+
+Beaker is a framework for building Smart Contracts using PyTeal. Beaker is designed to simplify writing, testing and deploying Algorand smart contracts. The Beaker source code available on [github](https://github.com/algorand-devrel/beaker). 
+
+This page provides an overview of the features available in Beaker. For complete details see the [Beaker's documentation](https://beaker.algo.xyz). 
+
+
+# Quick start videos
+
+If you prefer videos, take a look at this playlist to learn about Beaker. Most of the videos in the list are under 12 minutes each.
+
+<iframe width="100%" style="aspect-ratio:16/9" src="https://www.youtube-nocookie.com/embed/RhfC5Xd25dk" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
+
+# High Level Overview 
+Beaker provides several packages that extend PyTeal and provide convenience functionality for testing and deploying smart contracts. 
+
+The  `Application` class is Beaker's primary class. It is used to create [ABI](/docs/get-details/dapps/smart-contracts/ABI/) compliant Algorand smart contracts. Beaker also provides decorators to route specific [application transactions](/docs/get-details/dapps/smart-contracts/apps/) to the proper functionality within a smart contract. Beaker facilitates management of [local](/docs/get-details/dapps/smart-contracts/apps/state#local-storage) and [global](/docs/get-details/dapps/smart-contracts/apps/state#global-storage) state, and [box storage](/docs/get-details/dapps/smart-contracts/apps/state#box-storage). 
+
+The `ApplicationSpecification` class is used to generate a JSON manifest that describes the contract methods, source, and state schema used. This manifest can be used by other modules and utilities to deploy the smart contract. 
+
+The `ApplicationClient` class can be used to connect to an Algorand node and interact with a specific `Application`.
+
+Beaker's sandbox module can be used to quickly connect to the default docker sandbox installation to deploy and call a contract.  
+
+# Install
+
+Beaker can be installed using pip package manager.
+
+`pip install beaker-pyteal`
+
+Alternatively, Beaker can be installed with [AlgoKit](/docs/get-details/algokit) using the beaker project template.
+
+`algokit init --template beaker`
+
+Either of these methods will also install PyTeal in addition to Beaker.
+
+!!!note
+    Beaker requires python version 3.10 or higher
+
+
+# Initialize Application
+
+To create an application simply initialize a new Beaker Application object, supplying the name and description.
+
+<!-- ===BEAKER_INIT_APP=== -->
+```python
+from beaker import Application
+
+app = Application("MyRadApp", descr="This is a rad app")
+```
+[Snippet Source](https://github.com/algorand-devrel/beaker/blob/examples/examples/docs_app/app_handlers.py#L1-L4)
+<!-- ===BEAKER_INIT_APP=== -->
+
+This is enough to generate the `ApplicationSpecification` that can be exported for use by other tools. This spec can be generated using the `Application` `build` method. Optionally you can use the `export` method to export the approval and clear TEAL programs, the ABI contract manifest, and the application specification.
+
+!!!note
+    At this point a complete smart contract has been written, albeit with no utility.
+
+<!-- ===BEAKER_APP_SPEC=== -->
+```python
+app_spec = app.build()
+print(app_spec.to_json())
+```
+[Snippet Source](https://github.com/algorand-devrel/beaker/blob/examples/examples/docs_app/app_handlers.py#L7-L9)
+<!-- ===BEAKER_APP_SPEC=== -->
+
+
+
+# Add Method Handlers
+
+Method handlers can be added to provide functionality within the smart contract. This can be accomplished using the `external` decorator or by using a blueprint.
+
+
+
+## external
+
+To provide a method that can be invoked by an application call transaction, Beaker provides the `external` decorator. This instructs the framework to expose the method publicly for incoming transactions. The method is then defined with its required [method signature](/docs/get-details/dapps/smart-contracts/ABI/#methods), where the parameter types in the method signature describe the input types and output type.  These types of the arguments must be valid ABI data types, using [PyTeal's ABI](https://pyteal.readthedocs.io/en/stable/abi.html) package. Arguments and output types are optional, omitting any arguments is perfectly valid.
+
+!!! note
+    Note that input types come first, and if a value is returned it should be denoted in the method signature at the end using the notation `*, output: abi.ValidABIType`, which provides a variable to write the output into.
+
+<!-- ===BEAKER_HANDLERS_DIRECT=== -->
+```python
+import pyteal as pt
+
+
+# use the decorator provided on the `app` object to register a handler
+@app.external
+def add(a: pt.abi.Uint64, b: pt.abi.Uint64, *, output: pt.abi.Uint64) -> pt.Expr:
+    return output.set(a.get() + b.get())
+
+
+```
+[Snippet Source](https://github.com/algorand-devrel/beaker/blob/examples/examples/docs_app/app_handlers.py#L13-L22)
+<!-- ===BEAKER_HANDLERS_DIRECT=== -->
+
+In the example above the add method is defined to take two `Uint64` arguments (`a`, `b`) and return a `Uint64` (`output`).
+
+The full method signature for the above is `add(uint64,uint64)uint64` and will, by default, field only application call transactions with an `OnComplete` of `NoOp`.
+
+## On Complete handlers
+
+There are other decorators that can be used to modify the behavior of the method handler including `create`, `optin`, `closeout`, `clear`, `update`, and `delete`. These decorators can be used to register handlers for specific `OnComplete` values. See the [full docs](https://beaker.algo.xyz) for more details.
+
+## Blueprints
+
+Beaker allows for a pattern called `blueprints` apply a set of method handlers to an Application. Adding handlers using a blueprint allows for code re-use and makes it easier to add behaviors, especially for applications that wish to adhere to some ARC standard. 
+
+Blueprints can be defined using a standard python method definition that accepts an Application as an argument and applies the handlers.
+
+The code below defines a calculator blueprint that applies method handlers for a set of functions to implement a simple calculator. The blueprint must take an `Application` argument and optionally other arguments to modify the behavior of the blueprint
+
+An instantiated `Application` can apply this blueprint using the `.apply` method passing blueprint method as an argument. If other arguments in the blueprint method are defined, they can be passed with standard python kwarg format (i.e. `.apply(bp, arg1="hello")`)
+
+<!-- ===BEAKER_HANDLERS_BLUEPRINT=== -->
+```python
+# passing the app to this method will register the handlers on the app
+def calculator_blueprint(app: Application) -> Application:
+    @app.external
+    def add(a: pt.abi.Uint64, b: pt.abi.Uint64, *, output: pt.abi.Uint64) -> pt.Expr:
+        return output.set(a.get() + b.get())
+
+    @app.external
+    def sub(a: pt.abi.Uint64, b: pt.abi.Uint64, *, output: pt.abi.Uint64) -> pt.Expr:
+        return output.set(a.get() - b.get())
+
+    @app.external
+    def div(a: pt.abi.Uint64, b: pt.abi.Uint64, *, output: pt.abi.Uint64) -> pt.Expr:
+        return output.set(a.get() / b.get())
+
+    @app.external
+    def mul(a: pt.abi.Uint64, b: pt.abi.Uint64, *, output: pt.abi.Uint64) -> pt.Expr:
+        return output.set(a.get() * b.get())
+
+    return app
+
+
+calculator_app = Application("CalculatorApp", descr="This is a calculator app")
+calculator_app.apply(calculator_blueprint)
+
+calculator_app_spec = calculator_app.build()
+print(calculator_app_spec.to_json())
+```
+[Snippet Source](https://github.com/algorand-devrel/beaker/blob/examples/examples/docs_app/app_handlers.py#L25-L51)
+<!-- ===BEAKER_HANDLERS_BLUEPRINT=== -->
+
+An application that has a blueprint applied can also implement additional handlers or apply additional blueprints. Identical method signatures are not allowed. However, if necessary, an identical method signature still be registered by adding the override attribute to the decorator, `external(override=True)`.  
+
+# Add State 
+
+An Application can define the state it uses to store data. This is done by defining a class that contains some number of `StateValue` objects as attributes and passing an instance of that class to the Application constructor. 
+
+
+Beaker's `GlobalStateValue` class can be used to define and alter a contract's global state values. Global state values are defined by passing the `TealType` and a description the `GlobalStateValue` constructor. 
+
+!!! note
+    `TealType` is specific to the AVM and only `bytes`, `unit64` are acceptable values for state.
+
+
+The code below illustrates creating global integer counter that is stored in state. First, a `CounterState` class is created with an instance of a `GlobalStateValue` as an attribute. This class is then instantiated and passed in the `Application` constructor. Two method handlers are also added to the app to increment and decrement the counter.    
+
+
+<!-- ===BEAKER_STATE_GLOBAL=== -->
+```python
+import pyteal as pt
+from beaker import Application, GlobalStateValue
+
+
+class CounterState:
+    counter = GlobalStateValue(
+        stack_type=pt.TealType.uint64,
+        descr="A counter for showing how to use application state",
+    )
+
+
+app = Application(
+    "CounterApp", descr="An app that holds a counter", state=CounterState()
+)
+
+
+@app.external
+def increment() -> pt.Expr:
+    return app.state.counter.set(app.state.counter + pt.Int(1))
+
+
+@app.external
+def decrement() -> pt.Expr:
+    return app.state.counter.set(app.state.counter - pt.Int(1))
+
+
+app_spec = app.build()
+print(app_spec.global_state_schema.dictify())
+```
+[Snippet Source](https://github.com/algorand-devrel/beaker/blob/examples/examples/docs_app/app_state.py#L3-L31)
+<!-- ===BEAKER_STATE_GLOBAL=== -->
+
+
+
+Similarly, a `LocalStateValue` can be used to alter and store local state values. The code below is identical to the previous example, except the counter is stored locally.
+
+<!-- ===BEAKER_STATE_LOCAL=== -->
+```python
+import pyteal as pt
+from beaker import Application, LocalStateValue
+
+
+class LocalCounterState:
+    local_counter = LocalStateValue(
+        stack_type=pt.TealType.uint64,
+        descr="A counter for showing how to use application state",
+    )
+
+
+local_app = Application(
+    "CounterApp", descr="An app that holds a counter", state=LocalCounterState()
+)
+
+
+@local_app.external
+def user_increment() -> pt.Expr:
+    return local_app.state.local_counter.set(local_app.state.local_counter + pt.Int(1))
+
+
+@local_app.external
+def user_decrement() -> pt.Expr:
+    return local_app.state.local_counter.set(local_app.state.local_counter - pt.Int(1))
+
+
+local_app_spec = local_app.build()
+print(local_app_spec.local_state_schema.dictify())
+```
+[Snippet Source](https://github.com/algorand-devrel/beaker/blob/examples/examples/docs_app/app_state.py#L34-L62)
+<!-- ===BEAKER_STATE_LOCAL=== -->
+
+
+
+Beaker provides the `BoxMapping` and `BoxList` classes to work in conjunction with existing PyTeal [box functionality](/docs/get-details/dapps/smart-contracts/apps/state#box-storage).
+
+In the example below a `BoxMapping` instance is defined in the `MappingState` class. Each entry in the map is keyed using the type of `Address` and stores a `Uint64` value. 
+
+The method handler we define allows us to set an integer for the specific application caller's address. 
+
+
+<!-- ===BEAKER_STATE_MAPPING=== -->
+```python
+import pyteal as pt
+from beaker.lib.storage import BoxMapping
+
+
+class MappingState:
+    users = BoxMapping(pt.abi.Address, pt.abi.Uint64)
+
+
+mapping_app = Application(
+    "MappingApp", descr="An app that holds a mapping", state=MappingState()
+)
+
+
+@mapping_app.external
+def store_user_value(value: pt.abi.Uint64) -> pt.Expr:
+    # access an element in the mapping by key
+    return mapping_app.state.users[pt.Txn.sender()].set(value)
+
+
+```
+[Snippet Source](https://github.com/algorand-devrel/beaker/blob/examples/examples/docs_app/app_state.py#L65-L84)
+<!-- ===BEAKER_STATE_MAPPING=== -->
+
+The `BoxList` class can be used to store a list of specific _static_ ABI types. The example below creates a box named `users` that stores a list of five addresses. The `store_user` method is passed an address and an index. The passed-in address is then stored in the `BoxList` at the specified index.
+
+<!-- ===BEAKER_STATE_LIST=== -->
+```python
+import pyteal as pt
+from beaker.lib.storage import BoxList
+
+
+class ListState:
+    users = BoxList(pt.abi.Address, 5)
+
+
+list_app = Application("ListApp", descr="An app that holds a list", state=ListState())
+
+
+@list_app.external
+def store_user(user: pt.abi.Address, index: pt.abi.Uint64) -> pt.Expr:
+    # access an element in the list by index
+    return list_app.state.users[index.get()].set(user)
+
+
+```
+[Snippet Source](https://github.com/algorand-devrel/beaker/blob/examples/examples/docs_app/app_state.py#L88-L105)
+<!-- ===BEAKER_STATE_LIST=== -->
+
+# Interacting with the Application
+
+The contract can be deployed and tested using Beaker's sandbox module and the `ApplicationClient` class.
+The code below first retrieves the accounts from the currently running sandbox instance. A `ApplicationClient` (app_client) is then instantiated with an algod client, the `Application` class that is going to be used, and the first sandbox account (sandbox default starts with a couple of predefined accounts) which will be used to sign transactions.
+
+
+<!-- ===BEAKER_APP_CLIENT_INIT=== -->
+```python
+from beaker import sandbox, client
+
+# grab funded accounts from the sandbox KMD
+accts = sandbox.get_accounts()
+
+# get a client for the sandbox algod
+algod_client = sandbox.get_algod_client()
+
+# create an application client for the calculator app
+app_client = client.ApplicationClient(
+    algod_client, calculator_app, signer=accts[0].signer
+)
+```
+[Snippet Source](https://github.com/algorand-devrel/beaker/blob/examples/examples/docs_app/app_client.py#L3-L15)
+<!-- ===BEAKER_APP_CLIENT_INIT=== -->
+
+The instance of `AppliationClient` can deploy the calculator app now using the `create` method.
+
+<!-- ===BEAKER_APP_CLIENT_DEPLOY=== -->
+```python
+app_id, app_addr, txid = app_client.create()
+print(f"Created app with id: {app_id} and address: {app_addr} in tx: {txid}")
+```
+[Snippet Source](https://github.com/algorand-devrel/beaker/blob/examples/examples/docs_app/app_client.py#L19-L21)
+<!-- ===BEAKER_APP_CLIENT_DEPLOY=== -->
+
+The contract can then be used to call the contract. In this example the contracts `add` method is called, and two integers are passed as method arguments. Finally, the return value is printed.
+
+<!-- ===BEAKER_APP_CLIENT_CALL=== -->
+```python
+result = app_client.call("add", a=1, b=2)
+print(result.return_value)  # 3
+```
+[Snippet Source](https://github.com/algorand-devrel/beaker/blob/examples/examples/docs_app/app_client.py#L25-L27)
+<!-- ===BEAKER_APP_CLIENT_CALL=== -->
+
+This is only a small sample of what Beaker can do. For more see [Beaker's documentation](https://beaker.algo.xyz)