### Install Completium CLI and Initialize Configuration (Shell)

Source: https://github.com/completium/archetype-docs/blob/main/docs/installation.md

Installs the Completium CLI globally using npm and then initializes its configuration files. Requires Node.js and npm.

```Shell
$ npm install -g @completium/completium-cli
$ completium-cli init
```

--------------------------------

### Install Archetype Binary Compiler via Opam (Shell)

Source: https://github.com/completium/archetype-docs/blob/main/docs/installation.md

Installs the Archetype compiler binary using the Opam package manager. Requires Opam to be installed and configured.

```Shell
opam install archetype
```

--------------------------------

### Installing Beacon Wallet Integration Libraries

Source: https://github.com/completium/archetype-docs/blob/main/docs/dapps/project/index.md

Installs the necessary npm packages (@taquito/beacon-wallet and @airgap/beacon-sdk) to enable interaction with Tezos wallets using the Beacon standard.

```Shell
npm install @taquito/beacon-wallet @airgap/beacon-sdk
```

--------------------------------

### Build Archetype Binary Compiler from Source (Shell)

Source: https://github.com/completium/archetype-docs/blob/main/docs/installation.md

Clones the Archetype compiler source code from GitHub, navigates into the directory, installs build dependencies using make and opam, and then builds the project. Requires Git, make, and Opam.

```Shell
git clone https://github.com/completium/archetype-lang.git -b master
cd archetype-lang
make build-deps
eval $(opam env)
make all
```

--------------------------------

### Installing constate package

Source: https://github.com/completium/archetype-docs/blob/main/docs/dapps/project/index.md

Installs the constate package using npm, which is recommended for setting up contexts in React applications to manage application data and singleton instances.

```completium
npm install constate
```

--------------------------------

### Configure Archetype Binary Compiler Path and Mode (Shell)

Source: https://github.com/completium/archetype-docs/blob/main/docs/installation.md

Configures Completium CLI to use a locally installed binary version of the Archetype compiler. The first command sets the path to the executable, and the second switches the mode to 'binary'. Requires the Archetype binary to be installed separately.

```Shell
$ completium-cli set binary path archetype <PATH_TO_ARCHETYPE_BIN>
$ completium-cli set mode archetype binary
```

--------------------------------

### Install Archetype Docker Compiler (Shell)

Source: https://github.com/completium/archetype-docs/blob/main/docs/installation.md

Installs the Archetype compiler as a Docker container using Completium CLI. Requires Docker to be installed and running. This command also updates the container if it's already installed.

```Shell
completium-cli install archetype
```

--------------------------------

### Show Current Archetype Compiler Mode (Shell)

Source: https://github.com/completium/archetype-docs/blob/main/docs/installation.md

Prints the currently configured Archetype compiler mode (js, docker, or binary) used by Completium CLI to the console.

```Shell
completium-cli show mode archetype
```

--------------------------------

### Interactively Switch Archetype Compiler Mode (Shell)

Source: https://github.com/completium/archetype-docs/blob/main/docs/installation.md

Opens an interactive menu in the terminal to easily switch between different Archetype compiler modes (js, docker, binary) configured in Completium CLI.

```Shell
$ completium-cli switch mode archetype
```

--------------------------------

### Installing Taquito Tezos Library

Source: https://github.com/completium/archetype-docs/blob/main/docs/dapps/project/index.md

Installs the core Taquito library via npm, which is the main JavaScript/TypeScript library for interacting with the Tezos blockchain from a web DApp.

```Shell
npm install @taquito/taquito
```

--------------------------------

### Show Archetype Compiler Version (Shell)

Source: https://github.com/completium/archetype-docs/blob/main/docs/installation.md

Executes the configured Archetype compiler via Completium CLI and prints its version number to the console.

```Shell
completium-cli archetype version
```

--------------------------------

### Installing Completium CLI via npm

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/introduction.md

Installs the Completium CLI globally on your system using the npm package manager.

```completium
npm install -g @completium/completium-cli
```

--------------------------------

### Example: Showing Entrypoints for Remote Contract Address

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

Example usage of the `completium-cli show entries` command with a remote contract address, showing the output listing the available entrypoints and their parameters.

```completium
completium-cli show entries KT1EFgRdrT4r6QLx2riZiPNHjo7gcQM8n7f7
%confirm (_ : unit)
%submit (%ckey : address, %pscore : int)
%decide (_ : unit)
```

--------------------------------

### Check Archetype Binary Compiler Version (Bash)

Source: https://github.com/completium/archetype-docs/blob/main/docs/installation.md

Executes the compiled Archetype binary directly from its build path to verify its installation and print its version. This command is typically run after building from source.

```Bash
_build/default/src/compiler.exe -v
```

--------------------------------

### Initializing Completium CLI

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/introduction.md

Initializes the Completium CLI environment. This command must be run after the initial installation and every time a new version is installed.

```completium
completium-cli init
```

--------------------------------

### Example Contract Import (TS)

Source: https://github.com/completium/archetype-docs/blob/main/docs/dapps/project/contract.md

Provides an example of how to import a specific contract binding (e.g., 'Poll') generated by Completium, replacing the generic `FIXME` placeholder in the context setup.

```ts
import { Poll as Contract } from '../bindings/poll';
```

--------------------------------

### Call Example Contract Entrypoint in Archetype

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/instructions/operation.md

Demonstrates calling the `exec` entrypoint of the example `called_contract` (`c`) with 0 tez and a tuple `(4,5)` as the argument, matching the `nat * nat` signature.

```Archetype
transfer 0tz to c call exec<nat * nat>((4,5))
```

--------------------------------

### Starting Local Development Server with Yarn (Bash)

Source: https://github.com/completium/archetype-docs/blob/main/README.md

Starts a local development server for the Docusaurus website. This command typically watches for file changes and automatically refreshes the browser, enabling live development.

```bash
$ yarn start
```

--------------------------------

### Example: Deploying Archetype Contract with Parameters

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

Example usage of the `completium-cli deploy` command to deploy the `payment.arl` contract and provide the required `fee` parameter value using the `--parameters` option.

```completium
$ completium-cli deploy payment.arl --parameters '{ "fee" : "5tz" }'
```

--------------------------------

### Install Project Dependencies using npm

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/writingtests.md

Navigates into the newly created project directory and runs `npm i` to install the necessary Node.js packages declared in the `package.json` file, which are required for running tests and generating bindings.

```completium
$ cd myproject
npm i
```

--------------------------------

### Installing Completium DApp TypeScript Dependencies

Source: https://github.com/completium/archetype-docs/blob/main/docs/dapps/project/index.md

Installs the required npm packages (@completium/dapp-ts and @completium/archetype-ts-types) that are dependencies for using the TypeScript contract bindings generated by Completium CLI.

```Shell
npm install @completium/dapp-ts @completium/archetype-ts-types
```

--------------------------------

### Archetype Contract Entry Point Example

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/writingtests.md

An example of an Archetype contract entry point definition (`mint`) demonstrating access control (`called by owner`), providing context for the failing test example.

```Archetype
entry mint(tow : address, tid : nat, tmd: map<string, bytes>) {
  called by owner
  effect {
    /* ... */
  }
}
```

--------------------------------

### Example: Showing Contract Information for 'demo' Alias

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

Example usage of the `completium-cli show contract` command with the alias `demo`, showing the output including the contract's name, network, address, source path, language, version, and a link to a block explorer.

```completium
$ completium-cli show contract demo
Name:     demo
Network:  edo
Address:  KT1CQmaCLLdEQ3X9PmxoqEAy3Xusvs1J5wW1
Source:   /home/dev/.completium/sources/demo.arl
Language: archetype
Version:  1.2.2
Url:      https://better-call.dev/edo2net/KT1CQmaCLLdEQ3X9PmxoqEAy3Xusvs1J5wW1
```

--------------------------------

### Switch Archetype Compiler Mode to JS (Shell)

Source: https://github.com/completium/archetype-docs/blob/main/docs/installation.md

Configures Completium CLI to use the JavaScript version of the Archetype compiler. This is the default mode but can be used to switch back from other modes.

```Shell
completium-cli set mode archetype js
```

--------------------------------

### Installing Dependencies with Yarn (Bash)

Source: https://github.com/completium/archetype-docs/blob/main/README.md

Installs project dependencies using the Yarn package manager. This command reads the package.json file and downloads the required packages into the node_modules directory.

```bash
$ yarn
```

--------------------------------

### Call Example Current Contract Entrypoint in Archetype

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/instructions/operation.md

Provides a concrete example of calling the `exec` entrypoint within the current contract (`self`) with 0 tez and arguments `4` and `5`. Note the tuple syntax is implicit here.

```Archetype
transfer 0tz to entry self.exec(4,5)
```

--------------------------------

### Creating React App with TypeScript Template

Source: https://github.com/completium/archetype-docs/blob/main/docs/dapps/project/index.md

Initializes a new React project named 'my-dapp' using the create-react-app tool and specifies the TypeScript template for language support.

```Shell
npx create-react-app my-dapp --template TypeScript
```

--------------------------------

### Full launch.json Example for Archetype Debugging (JSON)

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/debug.md

Provides a complete example of a `launch.json` configuration for debugging an Archetype contract in VS Code. It includes settings for environment variables, constant parameters, and default storage.

```json
{
  // Use IntelliSense to learn about possible attributes.
  // Hover to view descriptions of existing attributes.
  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
  "version": "0.2.0",
  "configurations": [
    {
      "type": "archetype",
      "request": "launch",
      "name": "Archetype : debug",
      "program": "${file}",
      "env": {
        "now": "2023-10-27 09:25:11",
        "level": "10000",
        "caller": "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
        "source": "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
        "transferred": "0",
        "balance": "1000000",
        "inputs": {
          "spender": "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
          "from": "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
          "to": "tz1aSkwEot3L2kmUvcoxzjMomb9mvBNuzFK6",
          "value": "500"
        },
        "const_params": {
          "initial_holder": "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb",
          "total_supply": "1000",
          "metadata_coin": "0x00"
        },
        "storage": {
          "ledger": "{ Elt \"tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb\" (Pair 1000 {  }) }",
          "token_metadata": "{ Elt 0 (Pair 0 { Elt \"\" 0x00 }) }"
        }
      }
    }
  ]
}
```

--------------------------------

### Example: Deploying FA 1.2 Contract with Metadata File

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

Example usage of the `completium-cli deploy` command to deploy an FA 1.2 contract (`fa12.arl`) and attach metadata by providing the path to a JSON file using the `--metadata-storage` option.

```completium
$ completium-cli deploy fa12.arl --metadata-storage fa12_metadata.json
```

--------------------------------

### Archetype: Example Contract with Entrypoint

Source: https://github.com/completium/archetype-docs/blob/main/src/components/desc/getentrypoint_desc.md

Defines a simple Archetype contract named 'example' with a single entrypoint 'exec' that takes a natural number 'n' as an argument. This contract serves as an example for demonstrating how to retrieve an entrypoint.

```archetype
archetype example

entry exec(n : nat) { /* ... */ }

```

--------------------------------

### Retrieving Events with Completium Crank (TypeScript)

Source: https://github.com/completium/archetype-docs/blob/main/blog/2022-03-21-events.md

Provides a TypeScript example using the `@completium/event-well-crank` library to listen for and handle events. It shows how to register a handler function (`handleHBI`) for a specific event type (`HighestBidIncreased`) from a contract and start the crank process.

```typescript
import { startCrank } from '@completium/event-well-crank'
import {
  HighestBidIncreased,
  register_HighestBidIncreased } from './bid-bindings.ts'

const contract = "KT1..." // address of the emitter contract

const handleHBI = (hbi : HighestBidIncreased) => {
  // ...
  console.log(`${hbi.bidder} is now the highest bid bidder.`)
}

// register Handler
register_HighestBidIncreased(contract, handleHBI);

// Start crank
await startCrank();
```

--------------------------------

### Payback Entrypoint Example - Archetype

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

Illustrates an Archetype entrypoint named 'payback' that accepts two parameters: an integer 'i' and a natural number 'n'. This example is used to demonstrate calling contracts with arguments using the Completium CLI.

```archetype
archetype
entry payback (i : int, n : nat) {
  // ...
}
```

--------------------------------

### Example: Metadata JSON File for FA 1.2 Contract

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

Example content of a JSON file (`fa12_metadata.json`) used to provide metadata for an FA 1.2 compliant contract, including fields like symbol, name, decimals, description, and thumbnail URI.

```shell
$ cat fa12_metadata.json
{
  "symbol": "MTK",
  "name": "MyToken",
  "decimals": "1",
  "description": "description of MyToken",
  "thumbnailUri": "https://completium.com/img/logo_completium_128.png"
}
```

--------------------------------

### Example `while` Loop in Archetype

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/instructions/control.md

This provides a concrete example of a `while` loop that increments a variable `i` from 0 up to 19. The loop continues as long as `i` is less than 20.

```Archetype
var i = 0;
while i < 20 do
  instr1;
  i += 1
done
```

--------------------------------

### Install Node.js Dependencies

Source: https://github.com/completium/archetype-docs/blob/main/blog/2023-01-02-binding.md

Standard npm command to install project dependencies listed in package.json, including those required for the test framework and binding.

```completium
$ npm install
```

--------------------------------

### Deploying an Archetype contract with Completium CLI

Source: https://github.com/completium/archetype-docs/blob/main/docs/introduction.md

This command uses the Completium CLI to deploy the 'hello.arl' Archetype contract file to the Tezos blockchain. It assumes the Completium CLI is installed and configured.

```Completium
completium-cli deploy hello.arl
```

--------------------------------

### Example Archetype Contract for Calling

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/instructions/operation.md

Defines a simple Archetype contract named `called_contract` with a variable `r` and an entrypoint `exec` that takes two `nat` arguments and updates `r`. Used as an example target for `transfer` calls.

```Archetype
archetype called_contract\n\nvariable r : nat = 0\n\nentry exec(x : nat, y : nat) {\n    r := r * x + y\n}
```

--------------------------------

### Example: Registering Global Constant 'Pair 2 1'

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

Example usage of the `completium-cli register global constant` command with sample Michelson data, showing the output including the generated global address (hash).

```completium
$ completium-cli register global constant 'Pair 2 1'
...
      Global address: exprungfiFAFCszmNHNCDMtNkxiiHDpJUp128aLCJ5YxdsQZmyYt6S
```

--------------------------------

### Using useTezosToolkit Hook to Access Taquito (TSX)

Source: https://github.com/completium/archetype-docs/blob/main/docs/dapps/project/taquito.md

This example shows how to consume the `TezosToolkit` instance provided by the `Taquito` context. It imports the `useTezosToolkit` hook and calls it to get the toolkit instance, which is then used to query an account balance on the Tezos blockchain.

```tsx
import { useTezosToolkit } from '../store/Taquito'

const ttk = useTezosToolkit()
const balance = await ttk.tz.getBalance('tz1h4CiqWxNe4UxSpkwXy617RM6DaK6NU76P');
```

--------------------------------

### Example Mocha Test Structure (TypeScript)

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/writingtests.md

This example demonstrates how to use `describe` and `it` to structure tests for contract entry points, including asynchronous calls and assertions.

```TypeScript
describe('[HELLO] Call entries', async () => {
  it("Call 'exec'", async () => {
    await hello.exec({ as : alice })
    const s_after = await hello.get_s()
    assert(s_after === "Hello Archetype World!")
  })
  it("Call 'exec2'", async () => {
    await hello.exec2({ as : alice })
    const s_after = await hello.get_s()
    assert(s_after === "Hello TS Binding World!")
  })
})
```

--------------------------------

### Example: Deploying Archetype Contract with Amount

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

Example usage of the `completium-cli deploy` command to deploy an Archetype contract named `mycontract.arl` and send 15.5 tez during deployment. This command also creates a contract alias `mycontract`.

```completium
$ completium-cli deploy mycontract.arl --amount 15.5tz
```

--------------------------------

### Deploying Archetype Contract with completium-cli Parameters

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/declarations/contract.md

Example command using `completium-cli` to deploy an Archetype contract (`escrow.arl`) and provide values for its variable parameters (`seller`, `buyer`) via a JSON string.

```bash
completium-cli deploy escrow.arl --parameters '{ "seller" : "tz1VSUr8wwNhLAzempoch5d6hLRiTh8Cjcjb", "buyer" : "tz1aSkwEot3L2kmUvcoxzjMomb9mvBNuzFK6" }'
```

--------------------------------

### Emit Example Event in Archetype

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/instructions/operation.md

Demonstrates emitting the `HighestBidIncreased` event, populating its fields with the contract's `source` address and the `transferred` amount from the current call.

```Archetype
emit<HighestBidIncreased>({ source; transferred })
```

--------------------------------

### Example Archetype Event Declaration

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/instructions/operation.md

Defines an example event type `HighestBidIncreased` with fields for the bidder's address and the bid amount in tez. This event can then be emitted by the contract.

```Archetype
event HighestBidIncreased {\n  bidder : address;\n  amount : tez\n}
```

--------------------------------

### Example Test Output (Completium)

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/writingtests.md

This shows the typical output format when running tests structured with `describe` and `it` using the Completium test runner.

```completium
[HELLO] Call entry
    ✔ Call 'exec'
    ✔ Call 'exec2'
```

--------------------------------

### Showing Tezos Client Binary Path in Completium CLI

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/network.md

Displays the currently configured absolute path to the Tezos client binary that `completium-cli` is set to use. An example output shows the path.

```completium
completium-cli show binary path tezos-client
```

--------------------------------

### Declaring Archetype Event and Entry Point

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/binding.md

Defines an Archetype contract named 'example' containing an event 'HelloEvent' with a string field and an entry point 'exec' that emits an instance of 'HelloEvent'. This serves as the Archetype source for demonstrating event handling.

```archetype
archetype example

event HelloEvent {
  msg : string
}

entry exec() {
  emit<HelloEvent>({ "Hello from exec!" })
}
```

--------------------------------

### Displaying Completium CLI Help

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/introduction.md

Shows the list of available commands and options for the Completium CLI tool.

```completium
completium-cli help
```

--------------------------------

### Deploying Contract from Archetype with Variable Parameter (Archetype)

Source: https://github.com/completium/archetype-docs/blob/main/src/components/desc/create_contract.md

Shows how to originate a contract from an Archetype source file (`simple.arl`) using `create_contract`. Contract parameters are passed as a record. This example sets a variable parameter `owner` to the current caller's address.

```archetype
archetype anothercontract

import "simple.arl"

entry exec() {
  const op_addr : (operation * address) =
    create_contract(simple, none, 0tz, { owner = caller });
  operations := [op_addr[0]]
}
```

--------------------------------

### Using useConnect Hook for Wallet Login (TSX)

Source: https://github.com/completium/archetype-docs/blob/main/docs/dapps/project/beacon.md

This example demonstrates how to consume the `useConnect` hook from the `Beacon` context. It retrieves the `connect` function and attaches it to a button's `onClick` event handler, allowing the user to initiate the wallet connection process.

```tsx
import { useConnect } from '../store/Beacon'

const LoginButton = () => {
  const connect = useConnect()
  return <Button onClick={connect} />
}
```

--------------------------------

### Archetype Entrypoint Declaration Example

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/instructions/operation.md

Illustrates the syntax for declaring an entrypoint `e` in an Archetype contract, specifying an argument `x` of type `T`. This is a prerequisite for calling the entrypoint.

```Archetype
entry e(x : T) { /* ... */ }
```

--------------------------------

### Example TZIP-21 Metadata for Fungible Token (JSON)

Source: https://github.com/completium/archetype-docs/blob/main/docs/templates/tokenmetadata.md

This JSON object provides an example of the metadata structure for a fungible token following the TZIP-21 standard. It includes common fields like symbol, name, decimals, description, and URIs.

```JSON
{
  "symbol": "MyC",
  "name": "My Coin",
  "decimals": 6,
  "description": "An example of My Coin",
  "thumbnailUri": "ipfs://QmPibs6dkHjoJAkE9BiPURCnCBfphaT7P6y5MZ4eTYtyS9",
  "isTransferable": true,
  "isBooleanAmount": false,
  "shouldPreferSymbol": false
}
```

--------------------------------

### Example TZIP-16 Metadata JSON

Source: https://github.com/completium/archetype-docs/blob/main/docs/templates/metadata.md

Provides a standard JSON structure for TZIP-16 contract metadata, including fields like name, description, version, license, authors, homepage, and interfaces.

```json
{
  "name": "My Dapp",
  "description": "A description of My Dapp",
  "version": "1.0",
  "license": { "name": "MIT" },
  "authors": ["Mysterious team <contact@my_company.com>"],
  "homepage": "https://my_dapp.com",
  "interfaces": ["TZIP-012", "TZIP-016", "TZIP-017", "TZIP-021"]
}
```

--------------------------------

### Getting Entry Point Parameters and Executing Batch (TypeScript)

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/binding.md

Illustrates how to use the generated `get_set_param` method to obtain transaction parameters for the `set` entry point and then execute multiple calls in a batch using `exec_batch`.

```TypeScript
import { example } from `./binding/example.ts`

await example.deploy({ as : alice })

const set_param1 = await example.get_set_param("Hello Documentation!", { as : alice })
const set_param2 = await example.get_set_param("Hello Binding!", { as : alice })
// exec batch
await exec_batch([set_param1, set_param2], { as : alice })

const s = await example.get_s()
assert(s == "Hello Binding!")
```

--------------------------------

### Example Archetype Contract for Binding

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/binding.md

A simple Archetype contract with a parameter and a variable, used to illustrate contract binding features like deployment and entry point calls.

```archetype
archetype example(owner : address)

variable s : string = "Hello binding"

entry set(v : string) { s := v }
```

--------------------------------

### Example Michelson Contract Code (Formatted as JS)

Source: https://github.com/completium/archetype-docs/blob/main/blog/2024-04-26-v1.5.2.md

This snippet shows the Michelson code for an example contract used to demonstrate the decompiler. It includes entry points for 'divide', 'double', and 'replace', managing storage for votes and a stored value. The code is presented in a JavaScript object-like structure.

```js
{
  parameter (or (nat %divide) (or (unit %double) (nat %replace)));
  storage (pair (int %nbVotes) (nat %storedValue));
  code { DUP ;
         CDR ;
         SWAP ;
         CAR ;
         IF_LEFT
           { DUP ;
             PUSH nat 5 ;
             COMPARE ;
             LT ;
             IF {} { PUSH string "WrongCondition: params.divisor > 5" ; FAILWITH } ;
             SWAP ;
             DUP ;
             CAR ;
             SWAP ;
             CDR ;
             DIG 2 ;
             SWAP ;
             EDIV ;
             IF_NONE { PUSH int 26 ; FAILWITH } { CAR } ;
             SWAP ;
             PAIR }
           { IF_LEFT
               { DROP ; DUP ; CAR ; SWAP ; CDR ; PUSH nat 2 ; MUL ; SWAP ; PAIR }
               { SWAP ; DUP ; CDR ; SWAP ; CAR ; PUSH int 1 ; ADD ; PAIR ; CAR ; PAIR } } ;
         NIL operation ;
         PAIR }
}
```

--------------------------------

### Archetype Contract with Deployment Parameter

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

An example Archetype contract (`payment.arl`) that defines a parameter `fee` required during deployment. The contract includes a simple entrypoint `pay` that transfers an amount minus the fee.

```archetype
archetype payment(fee : tez)

variable amount : tez = 150tz

entry pay(seller : address) {
  transfer (amount - fee) to seller
}
```

--------------------------------

### Typescript Test Example using Contract Binding

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/framework.md

Demonstrates how to write a test script in Typescript using the generated contract binding for the `bind_demo` contract. It shows how to deploy the contract, invoke the `increase` entry point with specific arguments, retrieve the updated storage value (`total`), and assert that the final value matches the expected result using the `assert` library.

```Typescript
import { bind_demo }   from './binding/bind_hello'
import { Nat }         from "@completium/archetype-ts-types";
import { get_account } from "@completium/experiment-ts";
const assert = require('assert')

const alice = get_account('alice');
/* Deploy contract */
await bind_demo.deploy({ as: alice })
/* Invoke 'increase' entry point */
await bind_demo.increase([[ true, new Nat(2) ], [ false, new Nat(3) ]])
/* Retrieve storage's total value */
const total = await bind_demo.get_total()
/* Assert retrieved value */
assert(total.equals(new Nat(2)))
```

--------------------------------

### Switching Completium CLI Endpoint

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/network.md

Initiates an interactive process to select and switch the current network endpoint from a list of available options. An example output shows the interactive menu.

```completium
completium-cli switch endpoint
```

--------------------------------

### Showing Current Completium CLI Endpoint

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/network.md

Displays the URL of the network endpoint that `completium-cli` is currently configured to use. Example output shows the current network name and endpoint URL.

```completium
completium-cli show endpoint
```

--------------------------------

### Initializing Completium CLI Mockup Mode

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/network.md

Initializes the local mockup mode for testing smart contracts without a network. Makes registered accounts available and sets their balance. Sets the current endpoint to `mockup`. Requires the Tezos client (`octez-client`).

```completium
completium-cli mockup init
```

--------------------------------

### Archetype Transfer Call Low-Level Equivalent

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/instructions/operation.md

Illustrates the low-level Archetype code equivalent to the `transfer a to c call e<T>(x)` instruction. It involves getting the entrypoint, making the operation, and adding it to the `operations` list.

```Archetype
const e ?= get_entrypoint<T>("%e", c) : "ENTRY_NOT_FOUND";\nconst o  = make_operation(a, e, x);\noperations := reverse(prepend(reverse(operations), o))
```

--------------------------------

### Example Michelson Contract for Storage Getters

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/binding.md

A basic Michelson contract with a storage composed of a string and a nat, used to illustrate how storage getter methods are generated in the binding.

```michelson
{
  storage (pair (string %s) (nat %n));
  parameter unit;
  code { CDR;
         NIL operation;
         PAIR };
}
```

--------------------------------

### Deploying Contract from Archetype with Constant Parameter (Archetype)

Source: https://github.com/completium/archetype-docs/blob/main/src/components/desc/create_contract.md

Illustrates originating a contract from an Archetype source (`simple.arl`) using `create_contract`. This example demonstrates passing a literal value for a constant parameter `total_amount` within the parameter record.

```archetype
archetype anothercontract

import "simple.arl"

entry exec() {
  const op_addr : (operation * address) =
    create_contract(simple, none, 0tz, { total_amount = 1_000_000 });
  operations := [op_addr[0]]
}
```

--------------------------------

### Generating TypeScript Binding for Archetype Contract

Source: https://github.com/completium/archetype-docs/blob/main/docs/dapps/project/index.md

Uses the Completium CLI to generate a TypeScript binding file ('mycontract.ts') from an Archetype contract source file ('mycontract.arl'), providing a typed interface for contract calls.

```Shell
completium-cli generate binding-dapp-ts mycontract.arl > mycontract.ts
```

--------------------------------

### Getting Token Balance (Archetype)

Source: https://github.com/completium/archetype-docs/blob/main/src/components/desc/fa12_getbalance.md

This Archetype getter function, `getBalance`, retrieves the number of tokens owned by a specific address from the contract's ledger. It takes an `owner` address as input and returns a `nat` (natural number) representing the balance. If the owner is not found in the ledger, it returns 0.

```archetype
getter getBalance (owner : address) : nat {
  return (ledger[owner] ? the.tokens : 0)
}
```

--------------------------------

### Example Poll Definition JSON

Source: https://github.com/completium/archetype-docs/blob/main/docs/dapps/example/index.md

This JSON object defines the structure and content for a poll, including the question, an illustrative image URL, and a list of possible answers. This structure is uploaded to IPFS.

```json
{
  "utterance" : "What is your favorite food?",
  "img" : "https://1.bp.blogspot.com/-WOrNura8t1g/W6ufizUlixI/AAAAAAAAA38/X05agj6atWcxyyaRgOl07jMeaZnuF7JwgCLcBGAs/w1200-h630-p-k-no-nu/World-Food-Day.jpg",
  "choices" : [ "Pizza", "Burger", "Sushi", "Tacos", "Croissant" ]
}
```

--------------------------------

### Embedding Michelson instructions in Archetype

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/instructions/sequence.md

Demonstrates how to include a sequence of raw Michelson instructions within an Archetype entrypoint using the `michelson` instruction. This example checks if an input natural number is zero and fails if it is not.

```archetype
archetype michelson_instruction\n\nentry exec (i : nat) {\n  michelson {\n    PUSH nat 0;\n    COMPARE;\n    NEQ;\n    IF { PUSH string \"NOT_ZERO\"; FAILWITH } { PUSH nat 0 }\n  }\n}
```

--------------------------------

### Getting Default Expiry in Archetype

Source: https://github.com/completium/archetype-docs/blob/main/src/components/desc/permits_get_default_expiry.md

This Archetype function calculates a default expiry time for a given address. It first checks if the address exists in the `permits` map. If it does, it then checks for a user-specific expiry (`the.user_expiry`); if found, it uses that, otherwise it uses the global `default_expiry`. If the address is not in `permits`, it directly uses the global `default_expiry`.

```Archetype
function get_default_expiry(addr : address) : nat {
  return (permits[addr] ? (the.user_expiry ? the : default_expiry) : default_expiry)
}
```

--------------------------------

### Performing Division and Modulo on `tez` Values in Archetype

Source: https://github.com/completium/archetype-docs/blob/main/blog/2022-06-16-v1.3.0.md

Illustrates the new capability in Archetype 1.3.0 to perform division (`/`) and modulo (`%`) operations directly on `tez` values, showing examples that produce a `rational` and a `tez` value respectively.

```archetype
const a : rational = 5tz / 3tz;
const b : tez = 5tz % 2tz
```

--------------------------------

### Dangling Else Example in Archetype

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/instructions/control.md

Provides an example of a nested `if` statement to demonstrate how a dangling `else` is associated with the innermost `if` statement in Archetype.

```archetype
if a = 1 then
  if b = 1 then
    a := 42
else
  b := 42
```

--------------------------------

### Create Completium Project using CLI

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/writingtests.md

Uses the Completium CLI `create project` command to initialize a new project directory with default contract and test files, setting up the basic structure for smart contract development and testing.

```completium
completium-cli create project myproject
```

--------------------------------

### Declaring Local Constants with `constant` (Archetype)

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/declarations/entrypoint.md

This example demonstrates the declaration of local constants within an entry point using the `constant` section. Constants are declared with an identifier, the `is` keyword, and their value, separated by semicolons. These constants are immutable and available in subsequent sections.

```Archetype
entry consume(data: bytes) {
  called by consumer
  constant {
    hashed_data is blake2b(data);
    value       is get_value(hashed_data);
  }
  /* ... */
}
```

--------------------------------

### Initializing Completium CLI Mockup Mode with Specific Protocol

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/network.md

Initializes the local mockup mode, specifying a particular Tezos protocol hash for the simulation. Allows testing against a specific protocol version. Requires the Tezos client (`octez-client`).

```completium
completium-cli mockup init --protocol PtLimaPtLMwfNinJi9rCfDPWea8dFgTZ1MeJ9f1m2SRic6ayiwW
```

--------------------------------

### Define Example Archetype Contract

Source: https://github.com/completium/archetype-docs/blob/main/blog/2023-01-02-binding.md

An example Archetype contract definition used to demonstrate the TypeScript binding generation. It includes a variable and an entry point with various complex types.

```archetype
archetype binding_example

variable msg : string = "Hello Binding World!"

entry exec(
  l : list<int>,
  r : rational,
  o : or<nat, string>) {
 /* … do something … */
}
```

--------------------------------

### Iterating Asset Collections with `for` in Archetype

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/instructions/control.md

This example demonstrates iterating over the collection of `visitor` assets using the `for` loop. The loop variable `log` represents the identifier (`login`) of the current asset being processed, iterated in the natural order of the identifier.

```Archetype
for log in visitor do
  instr1 /* 'log' is the visitor 'login' typed 'address' */
done
```

--------------------------------

### Creating Completium Contract Context (TSX)

Source: https://github.com/completium/archetype-docs/blob/main/docs/dapps/project/contract.md

Sets up a React context using `constate` to provide a contract instance. It uses `useTezosToolkit` and `useContractAddress` hooks to get necessary dependencies and binds the contract instance to the Tezos toolkit using `set_binder_tezos_toolkit` from `@completium/dapp-ts`.

```tsx
import { set_binder_tezos_toolkit } from '@completium/dapp-ts';
import constate from 'constate';
import { useState } from 'react';

import { FIXME as Contract } from '../bindings/FIXME'; // replace FIXME
import { useContractAddress } from './Settings';
import { useTezosToolkit } from './Taquito';

export const [
  ContractProvider,
  useContract
] = constate(
  () => {
    const tezos = useTezosToolkit()
    const address = useContractAddress()
    const [contract] = useState({
      contract: new Contract(address),
    });
    set_binder_tezos_toolkit(tezos)
    return contract;
  },
  (v) => v.contract
)
```

--------------------------------

### Archetype Contract Example: bind_demo.arl

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/framework.md

Defines a simple Archetype smart contract named `bind_demo`. It contains a mutable natural number variable `total` initialized to 0 and an entry point `increase` that iterates over a list of boolean-natural number pairs, adding the natural number to `total` only if the corresponding boolean is true.

```Archetype
archetype bind_demo

variable total : nat = 0

entry increase(values : list<bool * nat>) {
  for p in values do
    total += p[0] ? p[1] : 0
  done
}
```

--------------------------------

### Modifying Storage in `effect` Section (Archetype)

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/declarations/entrypoint.md

This example shows the `effect` section within an entry point, which contains instructions to modify the contract's storage or generate operations. Here, it demonstrates updating a variable `owner_candidate` using the assignment operator `:=`.

```Archetype
variable owner_candidate : option<address> = none

entry set_owner_candidate(oc : address) {
  called by owner
  effect {
    owner_candidate := some(oc)
  }
}
```

--------------------------------

### Setting Tezos Client Binary Path for Completium CLI

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/network.md

Configures `completium-cli` to use a specific Tezos client binary by providing its absolute file path. Necessary for features like mockup mode.

```completium
completium-cli set binary path tezos-client <PATH>
```

--------------------------------

### Simple Contract Example - Archetype

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

Defines a basic Archetype contract named 'simple' with a single variable 'v' of type nat and an entrypoint 'setvalue' to update it. This contract is used in the documentation examples.

```archetype
archetype simple
variable v  : nat = 0
entry setvalue(p : nat) { v := p }
```

--------------------------------

### Create Completium Project

Source: https://github.com/completium/archetype-docs/blob/main/blog/2023-01-02-binding.md

Completium CLI command to initialize a new Node.js project directory for testing or DApp development.

```completium
$ completium-cli create project myproject
```

--------------------------------

### Building Static Website with Yarn (Bash)

Source: https://github.com/completium/archetype-docs/blob/main/README.md

Generates the static content for the website. This command compiles the source files and outputs the production-ready static assets into the build directory, ready for deployment.

```bash
$ yarn build
```

--------------------------------

### Calling an Archetype contract entrypoint with Completium CLI

Source: https://github.com/completium/archetype-docs/blob/main/docs/introduction.md

This command uses the Completium CLI to call the 'input' entrypoint of the deployed 'hello' contract. It passes a JSON object as the argument, specifying the 'name' parameter with the value 'Archetype'.

```Bash
completium-cli call hello --entry input --arg '{ "name": "Archetype" }'
```

--------------------------------

### Deploying Archetype Contract Binding (TypeScript)

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/binding.md

Demonstrates how to use the generated TypeScript binding's `deploy` method to instantiate an Archetype contract on the network, passing parameters and specifying the originator account.

```ts
import { example } from `./binding/example.ts`

const alice = get_account('alice')

await example.deploy(alice.get_address(), { as : alice })
// display newly deployed contract:
console.log(await example.get_address())
```

--------------------------------

### Decompiled Archetype Code Example

Source: https://github.com/completium/archetype-docs/blob/main/blog/2024-04-26-v1.5.2.md

This snippet shows the Archetype code generated by decompiling the example Michelson contract. It defines the contract `avv` with storage variables `nbVotes` and `storedValue` and entry points `divide`, `double`, and `replace` corresponding to the Michelson code.

```archetype
archetype avv(
  nbVotes : int,
  storedValue : nat
)

entry divide (arg : nat) {
  do_require ((5 < arg), "WrongCondition: params.divisor > 5");
  match storedValue /% arg with
  | some (x76, x77) -> (storedValue := x76)
  | none -> (fail (26i))
  end
}

entry double () {
  storedValue := 2 * storedValue
}

entry replace (arg : nat) {
  storedValue := arg;
  nbVotes := 1i + nbVotes
}
```

--------------------------------

### Example TZIP-21 Metadata for Non-Fungible Token (JSON)

Source: https://github.com/completium/archetype-docs/blob/main/docs/templates/tokenmetadata.md

This JSON object provides an example of the metadata structure for an NFT following the TZIP-21 standard. It includes fields relevant to NFTs such as artifact/display URIs, tags, creators, attributes, and royalties.

```JSON
{
  "symbol": "ARC",
  "name": "MyNFT #1",
  "decimals": 0,
  "description": "a description of NFT",
  "artifactUri": "ipfs://Qmb7sj8KYoUCJ29DT2qbKxHV5ubaDBRRoDwAPPZakpvn4Y",
  "displayUri": "ipfs://Qmb7sj8KYoUCJ29DT2qbKxHV5ubaDBRRoDwAPPZakpvn4Y",
  "thumbnailUri": "ipfs://Qmb7sj8KYoUCJ29DT2qbKxHV5ubaDBRRoDwAPPZakpvn4Y",
  "isTransferable": true,
  "isBooleanAmount": true,
  "shouldPreferSymbol": false,
  "tags": ["NFT"],
  "creators": ["tz1Lc2qBKEWCBeDU8npG6zCeCqpmaegRi6Jg"],
  "attributes": [
    {
      "name": "color",
      "value": "grey"
    }
  ],
	"royalties": {
		"decimals": 3,
		"shares": {
			"tz1Lc2qBKEWCBeDU8npG6zCeCqpmaegRi6Jg": 75
		}
	}
}
```

--------------------------------

### Declaring a transition with 'from', 'to', and 'effect' in Archetype

Source: https://github.com/completium/archetype-docs/blob/main/docs/reference/declarations/entrypoint.md

Illustrates a transition named `accept` that moves from `Shipped` to `Accepted` and includes an effect block (`with effect`) to transfer the contract's balance to the `seller` address.

```Archetype
transition accept() {
  from Shipped
  to   Accepted
  with effect {
    transfer balance to seller
  }
}
```

--------------------------------

### Deploying Website via SSH with Yarn (Bash)

Source: https://github.com/completium/archetype-docs/blob/main/README.md

Deploys the built website using Yarn, specifically configured to use SSH for authentication. This is often used for deploying to platforms like GitHub Pages when SSH keys are set up.

```bash
$ USE_SSH=true yarn deploy
```

--------------------------------

### Deploying Website via HTTPS with Yarn (Bash)

Source: https://github.com/completium/archetype-docs/blob/main/README.md

Deploys the built website using Yarn, specifying the GitHub username for authentication via HTTPS. This is an alternative deployment method when SSH is not used or preferred. Replace <Your GitHub username> with the actual username.

```bash
$ GIT_USER=<Your GitHub username> yarn deploy
```

--------------------------------

### Checking Asset Field with get and Match (Archetype)

Source: https://github.com/completium/archetype-docs/blob/main/src/components/desc/get_field_default_desc.md

Provides an equivalent way to check if the `caller` has a positive balance in the `ledger` asset using the `get` operator and a `match` expression. It attempts to retrieve the asset value and checks the `amount` field if the asset is found (`some av`), otherwise returns `false`.

```Archetype
const pos_balance =
  match ledger.get(caller) with
  | some av -> av.amount > 0
  | none    -> false
  end
```

--------------------------------

### Get Common Sender from Transfer List (Archetype)

Source: https://github.com/completium/archetype-docs/blob/main/src/components/desc/fa2_get_from_address.md

This Archetype function `get_from` takes a list of `transfer_param` records. It checks if the list is non-empty. If so, it takes the sender (`tp_from`) of the first transfer and iterates through the rest, using `do_require` to assert that each subsequent transfer has the same sender. It returns `some(address)` if all transfers share the same sender (or if the list has only one element), and `none` if the list is empty.

```archetype
function get_from(txs : list<transfer_param>) : option<address> {
  match txs with
  | hd::tl -> begin
    const %from = hd.tp_from;
    for tx in tl do
      do_require(%from = tx.tp_from, FA2_NOT_OPERATOR)
    done;
    return some(%from)
  end
  | [] -> return none
  end
}
```

--------------------------------

### Showing Contract Entrypoints by Address or Alias with Completium CLI

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

Command syntax for listing the entrypoints of a contract using its address or alias with the `completium-cli show entries` command.

```completium
completium-cli show entries <CONTRACT_ADDRESS|CONTRACT_ALIAS>
```

--------------------------------

### Calling Entry Point (TypeScript)

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/binding.md

Illustrates how to use the generated asynchronous method corresponding to an entry point (`set`) to interact with the deployed contract, passing arguments and specifying the caller account.

```ts
import { example } from `./binding/example.ts`

// ... deploy ...

await example.set("Hello Documentation!", { as : alice })
```

--------------------------------

### Declaring Archetype Tuple Value

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/binding.md

Example of declaring a constant 't' in Archetype with the type '(nat * string)' and assigning it a tuple value.

```archetype
const t : (nat * string) = (0, "a string");
```

--------------------------------

### Declaring Archetype Map Variable

Source: https://github.com/completium/archetype-docs/blob/main/docs/tests/binding.md

Example of declaring an Archetype variable 'ledger' as a map with 'address' keys and 'int' values, initialized as an empty map.

```archetype
variable ledger : map<address, int> = []
```

--------------------------------

### Defining an Archetype Asset

Source: https://github.com/completium/archetype-docs/blob/main/src/components/desc/getopt_desc.md

Defines a simple asset named 'ledger' with fields for holder address and amount, used as an example for asset access.

```archetype
asset ledger {
  holder : address;
  amount : nat;
}
```

--------------------------------

### Deploying/Originating Contract with Completium CLI

Source: https://github.com/completium/archetype-docs/blob/main/docs/cli/contract.md

Command syntax for deploying an Archetype contract (`.arl`) or originating a Michelson contract (`.tz`) using `completium-cli`, including various options for account, naming, parameters, amount, metadata, and initialization.

```completium
$ completium-cli (deploy <FILE.arl> | originate <FILE.tz>) \
    [--as <ACCOUNT_ALIAS>] \
    [--named <CONTRACT_ALIAS>] \
    [--parameters <PARAM> ] \
    [--amount <AMOUNT>(tz|utz)] \
    [--metadata-storage <PATH_TO_JSON> | --metadata-uri <VALUE_URI>] \
    [--init <MICHELSON_DATA>] \
    [--test-mode] \
    [--force]
```

--------------------------------

### Archetype if instruction with 'and' (pre-v1.3.0)

Source: https://github.com/completium/archetype-docs/blob/main/blog/2022-06-04-shortcut-evaluation.md

An example of the Archetype 'if' instruction using the 'and' operator before version 1.3.0, where both operands ('a' and 'b') were always evaluated (greedy evaluation).

```Archetype
if a and b then
 /* */
end
```