@goplausible/algorand-mcp 3.0.7

package/dist/resources/knowledge/taxonomy/tealscript:guides_Supported Types_arrays.md

@@ -0,0 +1,104 @@
+---
+title: Arrays, Tuples, and Objects
+---
+
+TEALScript supports various forms of arrays and tuples. In general, it is always recommended to use **static** types in arrays whenever possible and avoid booleans. Dynamic types and booleans are much more expensive to use and have some limitations listed below. 
+
+## Pass by Reference
+All arrays and objects are passed by reference even if in contract state, much like TypeScript. TEALScript, however, will not let a function mutate an array that was passed as an argument.
+
+If you wish to pass by value you can use `clone`.
+
+```ts
+const x: uint64[] = [1,2,3];
+const y = x;
+y[0] = 4
+
+log(y) // [4, 2, 3]
+log(x) // [4, 2, 3]
+
+const z = clone(x)
+z[1] = 5
+
+log(x) // [4, 2, 3] note x has NOT changed
+log(z) // [4, 5, 3]
+```
+
+## Instantiation
+
+When instantiating an array or object, a type **MUST** be defined. For example, `const x: uint64[] = [1, 2, 3]`. If you omit the type, the compiler will throw an error `const x = [1, 2, 3] // ERROR`
+
+## Static Arrays
+
+The most efficient and capable type of arrays are static arrays. To define a static array type in TEALScript you need to use the `StaticArray` generic type. For example, `StaticArray<uint64, 10>` for an array of 10 unsigned 64-bit integers. It should be noted that putting the length in a bracket (ie. `uint64[10]`) is **NOT** valid TypeScript syntax thus not officially supported by TEALScript.
+
+### Partial Definition
+
+If you have a static array but only want to initialize some of the initial values, you can it instantiate with an array less than the defined length. The remaning values will be zero bytes. For example, the following instantiations create the same underlying byte array
+
+```ts
+const x: <StaticArray, 3> = [1]
+const y: <StaticArray, 3> = [1, 0, 0]
+```
+
+### forEach iteration
+
+The most efficient way to iterate over an array is to use `.forEach`. This is currently only supported on static arrays. `.forEach` also works on arrays larger than 4kb stored in boxes. 
+
+```ts
+  staticForEach(): uint64 {
+    const a: StaticArray<uint64, 3> = [1, 2, 3];
+    let sum = 0;
+
+    a.forEach((v) => {
+      sum += v;
+    });
+    return sum; // 6
+  }
+```
+
+
+It should be noted that the second argument (current index) is not currently supported. The iterator function must also be explicitly defined as an arrow function (rather than passing in another function). Both of these features are being considered for future releases.
+
+### Supported Methods
+
+The following array methods are supported on static arrays (note the limitations on `forEach` above)
+
+* [length](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length)
+* [forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
+
+## Dynamic Arrays
+
+Dynamic arrays are supported in TEALScript but anything beyond dynamic arrays of static types is very inefficient. For example, `uint64[]` is fairly efficient but `uint64[][]` is much less efficient. 
+
+### Tecnical Explanation
+
+Under the hood, TEALScript will chop off the length prefix of dynamic arrays during runtime. This means `uint64[]` is just a bunch of 8-byte slices concatenated together. This makes all operations, whether its reading or writing, much more simple. Nested dynamic types are encoded as dynamic tuples, this requires much more opcodes to read/write the tuple head and tail values. 
+
+### Supported Methods
+
+Dynamic arrays in TEALScript support the following methods and they function just as they do in TypeScript. It should be noted that `splice` is rather heavy in terms of opcode cost so it should be used sparringly.
+
+* [pop](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop)
+* [push](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
+* [splice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)
+* [length](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length)
+
+## Objects
+
+Object can be defined much like in TypeScript. The same efficiencies of static vs dynamic types also applies to objects. 
+
+Currently no `Object` methods are supported in TEALScript.
+
+### Technical Explanation 
+
+Under the hood, TEALScript objects are just tuples. For example `[uint64, uint8]` is the same byteslice as `{ foo: uint64, bar: uint8 }`. The order of elements in the tuple depends on the order they are defined in the type defintion. For example, the following definitions result in the same byteslice.
+
+```ts
+type MyType = { foo: uint64, bar: uint8 }
+
+...
+
+const x: MyType = { foo: 1, bar: 2}
+const y: MyType = { bar: 2, foo: 1 }
+```

package/dist/resources/knowledge/taxonomy/tealscript:guides_Supported Types_numbers.md

@@ -0,0 +1,49 @@
+---
+title: Numbers
+---
+
+The native numeric type in the AVM is unsigned 64-bit integers, `uint64`. Thus any math operations using `uint64` will be more efficient than any alternatives. As such, you should always use `uint64` when possible. You can, however, use any of the number types defined in ARC-0004.
+
+It should be noted that at the TypeScript level, all numbers are aliases to the standard `number` class. This is to ensure all arithmetic operators function on all numeric types as expected since they cannot be overwritten in TypeScript. As such, any number-related type errors might not show in the IDE and will only throw an error during compilation.
+
+## Integers
+
+You can define specific-width unsigned integers with the `uint<N>` generic type. This type takes one type argument, which is the bit width. The bit width must be divisible by 8.
+
+### Examples
+
+#### Correct: Unsigned 64-bit integer
+
+```ts
+const n = 1
+```
+
+#### Correct: Unsigned 8-bit integer
+```ts
+const n: uint<8> = 1
+```
+
+## Unsigned Fixed-Point Decimals
+
+To represent decimals, use the `ufixed<N,M>` generic type. The first type argument is the bit width, which must be divisible by 8. The second argument is the number of decimals places, which must be less than 160. 
+
+### Examples
+
+#### Correct: Unsigned 64-bit With Two Decimals
+```ts
+const n: ufixed<64, 2> = 1.23
+```
+
+#### Incorrect: Missing type
+```ts
+const n = 1.23 // ERROR: Missing type
+```
+
+#### Incorrect: Not Precise Enough
+```ts
+const n: ufixed<64, 2> = 1.234 // ERROR: Precision of 2 decimals places, but 3 are given
+```
+
+## Math
+
+See [math](../math.md)

package/dist/resources/knowledge/taxonomy/tealscript:guides_atomic_txn.md

@@ -0,0 +1,22 @@
+---
+title: Atomic Transaciton Arguments
+---
+
+## Argument Types
+
+If you are writing a method that must be accompanied by an atomic trasnaction, you can set the argument type to one of the following types: `PayTxn`, `AssetTransferTxn`, `AppCallTxn`, `KeyRegTxn`, `AssetConfigTxn`, or `AssetFreezeTxn`
+
+## Verifying An Atomic Transaction
+
+Simply having an atomic trasnsaction as an argument doesn't gurantee anything about the transaction itself. As such, it's important to verify the fields of the transaction to ensure it is doing what you want. There are multiple methods for verifying the different types of transactions: `verifyPayTxn`, `verifyAssetConfigTxn`, `verifyAssetTransferTxn`, `verifyAppCallTxn`, and `verifyKeyRegTxn`. If you the transaction could be multiple different types, use the `verifyTxn` method.
+
+### Example
+
+```ts
+fundContractAccount(payment: PayTxn): void {
+    verifyPayTxn({
+        receiver: this.app.address,
+        amount: { greaterThan: 100_000 }
+    })
+}
+```

package/dist/resources/knowledge/taxonomy/tealscript:guides_features.md

@@ -0,0 +1,256 @@
+---
+title: Supported AVM Features
+---
+
+# Supported AVM Features
+
+## ARCS
+| ARC | Name | Description |
+| --- | --- | --- |
+| 4 | Application Binary Interface (ABI)	 | ABI method routing is automatically down for public methods. All ABI types are natively supported. Compiler outputs ARC4 JSON |
+| 22 | Add `read-only` annotation to ABI methods | Decorating a method with `@abi.readonly` will mark it as readonly |
+| 28 | Algorand Event Log Spec | Use `EventLogger` to log ARC28 events |
+| 32 | Application Specification | Compiler generates an arc32 JSON file |
+
+## ABI Types
+| ABI Type | TEALScript |
+| --- | --- |
+| `address` | `Address` |
+| `uintN` | `uint64`, `uint32`, `uint16`, `uint8`, `uint128`, `uint256`, or `uint<N>` |
+| `bool` | `boolean` |
+| `ufixedNxM` | `ufixed<N, M>` |
+| `T[]` | `T[]` |
+| `T[N]` | `StaticArray<T, N>`, `bytes32`, or `bytes64` |
+| `[T1, T2, ..., TN]` | `[T1, T2, ..., TN]` or `{keyone: T1, keytwo: T2, ..., keyN: TN}` |
+| `string` | `string` |
+| `application` | `ApplicationReference` |
+| `asset` | `AssetReference` |
+| `account` | `AccountReference` |
+| `txn` | `Txn` |
+| `pay` | `PayTxn` |
+| `keyreg` | `KeyRegTxn` |
+| `acfg` | `AssetConfigTxn` |
+| `axfer` | `AssetTransferTxn` |
+| `afrz` | `AssetFreezeTxn` |
+## Opcodes
+
+### Flow Control
+| Opcode | TEALScript |
+| --- | --- |
+| `err` | `throw Error()` |
+| `bnz` | Used automatically in loops and conditionals |
+| `bz` | Used automatically in loops and conditionals |
+| `b` | Used automatically in loops and conditionals |
+| `return` | Used when the top-level function returns |
+| `assert` | `assert` |
+| `bury` | Stack manipulation is not officially supported |
+| `popn` | Stack manipulation is not officially supported |
+| `dupn` | Stack manipulation is not officially supported |
+| `pop` | Stack manipulation is not officially supported |
+| `dup` | Stack manipulation is not officially supported |
+| `dup2` | Stack manipulation is not officially supported |
+| `dig` | Stack manipulation is not officially supported |
+| `swap` | Stack manipulation is not officially supported |
+| `select` | Not officially supported yet, but could be used to optimize conditionals in the future |
+| `cover` | Stack manipulation is not officially supported |
+| `uncover` | Stack manipulation is not officially supported |
+| `callsub` | Used when calling a function |
+| `retsub` | `return` |
+| `proto` | Used automatically in functions |
+| `frame_dig` | Used automatically in functions |
+| `frame_bury` | Used automatically in functions |
+| `switch` | Not officially supported yet, but could be used to optimize conditionals in the future |
+| `match` | Not officially supported yet, but could be used to optimize conditionals in the future |
+
+### Cryptography
+| Opcode | TEALScript |
+| --- | --- |
+| `sha256` | `sha256` |
+| `keccak256` | `keccak256` |
+| `sha512_256` | `sha512_256` |
+| `ed25519verify` | `ed25519Verify` |
+| `ecdsa_verify` | `ecdsaVerify` |
+| `ecdsa_pk_decompress` | `ecdsaPkDecompress` |
+| `ecdsa_pk_recover` | `ecdsaPkRecover` |
+| `ed25519verify_bare` | `ed25519VerifyBare` |
+| `sha3_256` | `sha3_256` |
+| `vrf_verify` | `vrfVerify` |
+| `ec_add` | `ecAdd` |
+| `ec_scalar_mul` | `ecScalarMul` |
+| `ec_pairing_check` | `ecPairingCheck` |
+| `ec_multi_scalar_mul` | `ecMultiScalarMul` |
+| `ec_subgroup_check` | `ecSubgroupCheck` |
+| `ec_map_to` | `ecMapTo` |
+
+### Arithmetic
+| Opcode | TEALScript |
+| --- | --- |
+| `+` | Natively supported |
+| `-` | Natively supported |
+| `/` | Natively supported |
+| `*` | Natively supported |
+| `<` | Natively supported |
+| `>` | Natively supported |
+| `<=` | Natively supported |
+| `>=` | Natively supported |
+| `&&` | Natively supported |
+| `\|\|` | Natively supported |
+| `==` | Natively supported |
+| `!=` | Natively supported |
+| `!` | Natively supported |
+| `itob` | Natively supported |
+| `btoi` | Natively supported |
+| `%` | Natively supported |
+| `\|` | Natively supported |
+| `&` | Natively supported |
+| `^` | Natively supported |
+| `~` | Natively supported |
+| `mulw` | `mulw` |
+| `addw` | `addw` |
+| `divmodw` | `divmodw` |
+| `shl` | `<<` |
+| `shr` | `>>` |
+| `sqrt` | Natively supported |
+| `bitlen` | `bitlen` |
+| `exp` | `**` |
+| `expw` | `expw` |
+| `divw` | `divw` |
+
+### Byte Array Manipulation
+| Opcode | TEALScript |
+| --- | --- |
+| `len` | `.length` on bytes |
+| `concat` | `concat` or `+` |
+| `substring` | `String.substring` or `substring` |
+| `substring3` | `String.substring` or `substring` |
+| `getbit` | `getbit` |
+| `setbit` | `setbit` |
+| `getbyte` | `getbyte` |
+| `setbyte` | `setbyte` |
+| `extract` | `extract3` |
+| `extract3` | `extract3` |
+| `extract_uint16` | `extractUint16` |
+| `extract_uint32` | `extractUint32` |
+| `extract_uint64` | `extractUint64` |
+| `replace2` | `replace3` |
+| `replace3` | `replace3` |
+| `base64_decode` | `base64Decode` |
+| `json_ref` | `jsonRef` |
+
+### Loading Values
+| Opcode | TEALScript |
+| --- | --- |
+| `intcblock` | Constant block not officially supported |
+| `intc` | Constant block not officially supported |
+| `intc_0` | Constant block not officially supported |
+| `intc_1` | Constant block not officially supported |
+| `intc_2` | Constant block not officially supported |
+| `intc_3` | Constant block not officially supported |
+| `bytecblock` | Constant block not officially supported |
+| `bytec` | Constant block not officially supported |
+| `bytec_0` | Constant block not officially supported |
+| `bytec_1` | Constant block not officially supported |
+| `bytec_2` | Constant block not officially supported |
+| `bytec_3` | Constant block not officially supported |
+| `arg` | `LogicSig.logic` arguments |
+| `arg_0` | `LogicSig.logic` arguments |
+| `arg_1` | `LogicSig.logic` arguments |
+| `arg_2` | `LogicSig.logic` arguments |
+| `arg_3` | `LogicSig.logic` arguments |
+| `txn` | `this.txn` |
+| `global` | `globals` |
+| `gtxn` | `this.txnGroup` or transaction argument |
+| `load` | `ScratchSlot` |
+| `store` | `ScratchSlot` |
+| `txna` | `this.txn` |
+| `gtxna` | `this.txnGroup` or transaction argument |
+| `gtxns` | `this.txnGroup` or transaction argument |
+| `gtxnsa` | `this.txnGroup` or transaction argument |
+| `gload` | `Txn.load` |
+| `gloads` | `Txn.load` |
+| `gaid` | `this.txnGroup` or transaction argument |
+| `gaids` | `this.txnGroup` or transaction argument |
+| `loads` | `ScratchSlot` |
+| `stores` | `ScratchSlot` |
+| `pushbytes` | Used by `TemplateVar` |
+| `pushint` | Used by `TemplateVar` |
+| `pushbytess` | Not used yet, but could be used for optimizations in future |
+| `pushints` | Not used yet, but could be used for optimizations in future |
+| `bzero` | `bzero` |
+| `txnas` | `this.txn` |
+| `gtxnas` | `this.txnGroup` or transaction argument |
+| `gtxnsas` | `this.txnGroup` or transaction argument |
+| `args` | `LogicSig.logic` arguments |
+| `gloadss` | `Txn.load` |
+
+### State Access
+| Opcode | TEALScript |
+| --- | --- |
+| `balance` | `Address.balance` and `Address.hasBalance` |
+| `app_opted_in` | `Address.isOptedInToApp()` |
+| `app_local_get` | Method call on LocalStateKey on `LocalStateMap` |
+| `app_local_get_ex` | `AppID.local()` |
+| `app_global_get` | Method call on `GlobalStateKey` on `GlobalStateMap` |
+| `app_global_get_ex` | `AppID.global()` |
+| `app_local_put` | Method call on LocalStateKey on `LocalStateMap` |
+| `app_global_put` | Method call on `GlobalStateKey` on `GlobalStateMap` |
+| `app_local_del` | Method call on LocalStateKey on `LocalStateMap` |
+| `app_global_del` | Method call on `GlobalStateKey` on `GlobalStateMap` |
+| `asset_holding_get` | `Address.assetBalance` and `Address.isOptedInToAsset` |
+| `asset_params_get` | Method calls on `AssetID` |
+| `app_params_get` | Method calls on `AppID` |
+| `acct_params_get` | Method calls on `Address` |
+| `min_balance` | `Address.minBalance` |
+| `log` | `log` or `EventEmitter` |
+| `block` | `blocks` |
+
+### Byte Array Arithmetic
+| Opcode | TEALScript |
+| --- | --- |
+| `bsqrt` | Natively supported |
+| `b+` | Natively supported |
+| `b-` | Natively supported |
+| `b/` | Natively supported |
+| `b*` | Natively supported |
+| `b<` | Natively supported |
+| `b>` | Natively supported |
+| `b<=` | Natively supported |
+| `b>=` | Natively supported |
+| `b==` | Natively supported |
+| `b!=` | Natively supported |
+| `b%` | Natively supported |
+
+### Byte Array Logic
+| Opcode | TEALScript |
+| --- | --- |
+| `b\|` | Natively supported |
+| `b&` | Natively supported |
+| `b^` | Natively supported |
+| `b~` | Natively supported |
+
+### Inner Transactions
+| Opcode | TEALScript |
+| --- | --- |
+| `itxn_begin` | `this.pendingGroup.add...` or `send...` |
+| `itxn_field` | `this.pendingGroup.add...` or `send...` |
+| `itxn_submit` | `this.pendingGroup.execute` or `send...` |
+| `itxn` | `this.itxn` |
+| `itxna` | `this.itxn` |
+| `itxn_next` | `this.pendingGroup.add...` |
+| `gitxn` | `this.lastInnerGroup` |
+| `gitxna` | `this.lastInnerGroup` |
+| `itxnas` | `this.itxn` |
+| `gitxnas` | `this.lastInnerGroup` |
+
+### Box Access
+| Opcode | TEALScript |
+| --- | --- |
+| `box_create` | Method call on `BoxKey` or `BoxMap` |
+| `box_extract` | Method call on `BoxKey` or `BoxMap` |
+| `box_replace` | Method call on `BoxKey` or `BoxMap` |
+| `box_del` | Method call on `BoxKey` or `BoxMap` |
+| `box_len` | Method call on `BoxKey` or `BoxMap` |
+| `box_get` | Method call on `BoxKey` or `BoxMap` |
+| `box_put` | Method call on `BoxKey` or `BoxMap` |
+| `box_splice` | Method call on `BoxKey` or `BoxMap` |
+| `box_resize` | Method call on `BoxKey` or `BoxMap` |

package/dist/resources/knowledge/taxonomy/tealscript:guides_getting_started.md

@@ -0,0 +1,88 @@
+---
+title: Getting Started
+---
+
+## Using Algokit
+
+The recommended way to get started with TEALScript is to use the Algokit template:
+
+```
+algokit init -t tealscript
+```
+
+This will set up a project repository with TEALScript, ESLint, algokit generate, and some tests.
+
+More information about how to use the template is provided in the template's [README](https://github.com/algorandfoundation/tealscript-algokit-template/blob/master/template_content/README.md).
+
+
+## Manual Installation
+
+If you do not wish to use the above Algokit template, you can manually add TEALScript to any project with npm.
+ 
+### Installing TEALScript
+
+TEALScript can be installed from npm via `npm install @algorandfoundation/tealscript`. 
+
+### Writing First Contract
+
+To write your first smart contract, import the `Contract` class and create a new class that extends `Contract`.
+
+```ts
+import { Contract } from '@algorandfoundation/tealscript';
+
+class FirstContract extends Contract {
+```
+
+This is where all of the method definitions will go. You can then write a method that is typed and written like a regular TypeScript method:
+
+```ts
+import { Contract } from '@algorandfoundation/tealscript';
+
+class FirstContract extends Contract {
+  add(a: uint64, b: uint64): uint64 {
+    return a + b
+  }
+}
+```
+
+### Compiling
+
+To compile a TEALScript smart contract, run `npx tealscript <file> [artifact directory]`
+
+* `<file>` is the .ts file containing your TEALScript source code 
+* `[artifact directory]` is an optional directory to output the artifacts generated by TEALScript. If a directory isn't given, the current working directory will be used.
+
+To learn more about method definitions and decorators for specific smart contract actions (such as creating, updating, or deleting the contract) see [methods](./methods.md).
+
+### ESLint
+
+**Note:** This is assuming you are extending the `airbnb-base`. Other standards might have additional rules that need to be disabled or modified.
+
+If you are using ESLint, the following rules must be disabled: 
+
+| ESLint Rule              | Reason                                                            |
+| ------------------------ | ----------------------------------------------------------------- |
+| `object-shorthand`       | Object shorthand is not yet supported by TEALScript               |
+| `no-undef`               | The global TEALScript functions are not actually defined anywhere |
+| `class-methods-use-this` | Not all methods will actually use `this`                          |
+| `max-classes-per-file`   | Multiple contracts can be defined in a single file                |
+| `no-bitwise`             | Bitwise operations are supported by TEALScript                    |
+
+#### .eslintrc.js
+
+Rather than disabling these directly in the file, you can also create some rule overrides in your `.eslintrc.js`. For example, if you end all of your TEALScript contracts with `.algo.ts` you can add this to your config:
+
+```js
+overrides: [
+    {
+      files: ['*.algo.ts'],
+      rules: {
+        'object-shorthand': 'off',
+        'class-methods-use-this': 'off',
+        'no-undef': 'off',
+        'max-classes-per-file': 'off',
+        'no-bitwise': 'off',
+      },
+    }
+  ],
+```

package/dist/resources/knowledge/taxonomy/tealscript:guides_inner_transactions.md

@@ -0,0 +1,43 @@
+---
+title: Inner Transactions
+---
+
+Algorand Smart Contracts have the ability to send transactions from the application's contract address. Transactions sent from a contract address via an application call is called an inner transaction. 
+
+## Inner Transaction
+
+To send a single inner transaction, one of the following methods can be used.
+
+| Function                     | Usage                                         |
+| ---------------------------- | --------------------------------------------- |
+| `sendPayment`                | Send a payment transaction                    |
+| `sendAssetTransfer`          | Send an asset transfer transaction            |
+| `sendAssetCreation`          | Send a transcation that creates a transcation |
+| `sendAssetConfig`            | Send an asset config transaction              |
+| `sendAssetFreeze`            | Send an asset freeze transaction              |
+| `sendAppCall`                | Send an application call                      |
+| `sendMethodCall`             | Call an ABI method of another app             |
+| `sendOnlineKeyRegistration`  | Send a rekreg transaction to register offline |
+| `sendOfflineKeyRegistration` | Send a rekreg transaction to register offline |
+
+## Inner Transaction Group
+
+You can also send multiple inner transactions in the same group. To add transactions to a group, `this.pendingGroup` is used. It should be noted that at any given time only one group can be constructed at a time. This means 
+
+| Function                                      | Usage                                        |
+| --------------------------------------------- | -------------------------------------------- |
+| `this.pendingGroup.addPayment`                | Add a payment transaction                    |
+| `this.pendingGroup.addAssetTransfer`          | Add an asset transfer transaction            |
+| `this.pendingGroup.addAssetCreation`          | Add a transcation that creates a transcation |
+| `this.pendingGroup.addAssetConfig`            | Add an asset config transaction              |
+| `this.pendingGroup.addAssetFreeze`            | Add an asset freeze transaction              |
+| `this.pendingGroup.addAppCall`                | Add an application call                      |
+| `this.pendingGroup.addMethodCall`             | Add an ABI method call to another app        |
+| `this.pendingGroup.addOnlineKeyRegistration`  | Add a rekreg transaction to register offline |
+| `this.pendingGroup.addOfflineKeyRegistration` | Add a rekreg transaction to register offline |
+
+Once transactions have been added to the pending group, the group can be submitted via `this.pendingGroup.submit()`
+
+## Inner Transaction Fields
+
+The fields of the most recent inner transaction can be read via `this.itxn`

package/dist/resources/knowledge/taxonomy/tealscript:guides_lifecycle.md

@@ -0,0 +1,88 @@
+---
+title: Lifecycle Methods
+---
+
+## Create, Update, and Delete
+
+By default, Algorand applications can be created, updated, and deleted. In TEALScript, applications can be created by default, but cannot be updated to deleted. The default `createApplication` method won't run any logic, but rather simply create the application on the chain. 
+
+### Modifying create logic
+
+To modify the logic executed upon applicaiton creation (for example, to set default storage values) your contract class must implement a method to override `createApplication`.
+
+#### Example
+
+```typescript
+class Counter extends Contract {
+  counter = GlobalStateKey<uint64>();
+
+  createApplication(startingNumber: uint64): void {
+    this.counter.value = startingNumber
+  }
+}
+```
+
+### Implementing a updateApplication Method
+
+By default, TEALScript contracts cannot be updated. To allow a contract to be updated, a method that overrides `Contract.updateApplication` must be implemented.
+
+#### Example
+
+```typescript
+class Counter extends Contract {
+  counter = GlobalStateKey<uint64>();
+
+  createApplication(startingNumber: uint64): void {
+    this.counter.value = startingNumber
+  }
+
+  updateApplication(): void {
+    assert(this.txn.sender === this.app.creator)
+  }
+}
+```
+
+### Implementing a deleteApplication Method
+
+By defualt, TEALScript contracts cannot be deleted. To allow a contract to be deleted, a method that overrides `deleteApplication` must be implemented.
+
+#### Example
+
+```typescript
+class Counter extends Contract {
+  counter = GlobalStateKey<uint64>();
+
+  createApplication(startingNumber: uint64): void {
+    this.counter.value = startingNumber
+  }
+
+  deleteApplication(): void {
+    assert(this.txn.sender === this.app.creator)
+  }
+}
+```
+
+## OptIn, CloseOut, and ClearState
+
+If your contract uses local state, you will need to override the `optInToApplication` method and override `closeOutOfApplication` and/or `clearState` as desired. To learn more about contract state, see [this page](./storage.md)
+
+## Advanced OnComplete Control
+
+To have more granular control on what OnComplete a specific method allows, use the `allow.call` or `allow.create` decorator to control allowed OnCompletes when calling or creating the application. 
+
+### Example
+
+```typescript
+class Counter extends Contract {
+  counter = LocalStateKey<uint64>();
+
+  // This method will increment a counter in local state
+  @allow.create('OptIn') // Allow an OptIn create so the creators counter can be set when creating the app
+  @allow.call('OptIn')   // Allow anyone to OptIn to the contract so they can use local state
+  @allow.call('NoOp')    // Allow anyone to call the app again with a NoOp call (can only OptIn once)
+  useLocalState(): void {
+    if (!this.counter(this.txn.sender).exists) this.counter(this.txn.sender).value = 1
+    else this.counter(this.txn.sender).value = this.counter(this.txn.sender).value + 1
+  }
+}
+```