feat: algokit generators support (#40)

* feat: algokit generators support

Author: aorumbayev

.editorconfig

@@ -0,0 +1,10 @@
+root=true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+
+[*.py]
+indent_size = 4

copier.yaml

@@ -1,4 +1,5 @@
 _subdirectory: template_content
+_templates_suffix: ".jinja"
 
 # questions
 # project_name should never get prompted, AlgoKit should always pass it by convention

template_content/.algokit.toml.jinja

@@ -1,5 +1,5 @@
 [algokit]
-min_version = "v1.3.0b1"
+min_version = "v1.4.0"
 
 [deploy]
 {%- if deployment_language == 'python' %}
@@ -16,3 +16,7 @@ environment_secrets = [
 
 [deploy.localnet]
 environment_secrets = []
+
+[generate.smart_contract]
+description = "Adds new smart contract to existing project"
+path = ".algokit/generators/create_contract"

template_content/.algokit/generators/create_contract/copier.yaml

@@ -0,0 +1,10 @@
+_task:
+    - "echo '==== Successfully initialized new smart contract 🚀 ===='"
+
+contract_name:
+    type: str
+    help: Name of your new contract.
+    placeholder: "my-new-contract"
+    default: "my-new-contract"
+
+_templates_suffix: ".j2"

template_content/.algokit/generators/create_contract/smart_contracts/{% raw %}{{ contract_name }}{% endraw %}/contract.py.j2

@@ -0,0 +1,30 @@
+import beaker
+import pyteal as pt
+{% if preset_name == 'starter' %}
+
+app = beaker.Application("{{ contract_name }}")
+{% elif preset_name == 'production' -%}
+from algokit_utils import DELETABLE_TEMPLATE_NAME, UPDATABLE_TEMPLATE_NAME
+
+app = beaker.Application("{{ contract_name }}")
+
+
+@app.update(authorize=beaker.Authorize.only_creator(), bare=True)
+def update() -> pt.Expr:
+    return pt.Assert(
+        pt.Tmpl.Int(UPDATABLE_TEMPLATE_NAME),
+        comment="Check app is updatable",
+    )
+
+
+@app.delete(authorize=beaker.Authorize.only_creator(), bare=True)
+def delete() -> pt.Expr:
+    return pt.Assert(
+        pt.Tmpl.Int(DELETABLE_TEMPLATE_NAME),
+        comment="Check app is deletable",
+    )
+{% endif %}
+
+@app.external
+def hello(name: pt.abi.String, *, output: pt.abi.String) -> pt.Expr:
+    return output.set(pt.Concat(pt.Bytes("Hello, "), name.get()))

template_content/.algokit/generators/create_contract/smart_contracts/{% raw %}{{ contract_name }}{% endraw %}/{% if deployment_language == 'python' %}deploy_config.py.j2{% endif %}.jinja

@@ -0,0 +1,56 @@
+{% raw -%}
+import logging
+
+import algokit_utils
+from algosdk.v2client.algod import AlgodClient
+from algosdk.v2client.indexer import IndexerClient
+
+logger = logging.getLogger(__name__)
+
+
+# define deployment behaviour based on supplied app spec
+def deploy(
+    algod_client: AlgodClient,
+    indexer_client: IndexerClient,
+    app_spec: algokit_utils.ApplicationSpecification,
+    deployer: algokit_utils.Account,
+) -> None:
+    from smart_contracts.artifacts.{{ contract_name }}.client import (
+        {{ contract_name.split('_')|map('capitalize')|join }}Client,
+    )
+
+    app_client = {{ contract_name.split('_')|map('capitalize')|join }}Client(
+        algod_client,
+        creator=deployer,
+        indexer_client=indexer_client,
+    )
+
+
+    {%- if preset_name == 'starter'  %}
+    app_client.deploy(
+        on_schema_break=algokit_utils.OnSchemaBreak.AppendApp,
+        on_update=algokit_utils.OnUpdate.AppendApp,
+    )
+    {%- elif preset_name == 'production' %}
+    is_mainnet = algokit_utils.is_mainnet(algod_client)
+    app_client.deploy(
+        on_schema_break=(
+            algokit_utils.OnSchemaBreak.AppendApp
+            if is_mainnet
+            else algokit_utils.OnSchemaBreak.ReplaceApp
+        ),
+        on_update=algokit_utils.OnUpdate.AppendApp
+        if is_mainnet
+        else algokit_utils.OnUpdate.UpdateApp,
+        allow_delete=not is_mainnet,
+        allow_update=not is_mainnet,
+    )
+    {%- endif %}
+
+    name = "world"
+    response = app_client.hello(name=name)
+    logger.info(
+        f"Called hello on {app_spec.contract.name} ({app_client.app_id}) "
+        f"with name={name}, received: {response.return_value}"
+    )
+{% endraw -%}

template_content/.algokit/generators/create_contract/smart_contracts/{% raw %}{{ contract_name }}{% endraw %}/{% if deployment_language == 'typescript' %}deploy-config.ts.j2{% endif %}.jinja

@@ -0,0 +1,64 @@
+{% raw -%}
+import * as algokit from '@algorandfoundation/algokit-utils'
+import { {{ contract_name.split('_')|map('capitalize')|join }}Client } from '../artifacts/{{ contract_name }}/client'
+
+// Below is a showcase of various deployment options you can use in TypeScript Client
+export async function deploy() {
+  console.log('=== Deploying {{ contract_name.split('_')|map('capitalize')|join }} ===')
+
+  const algod = algokit.getAlgoClient()
+  const indexer = algokit.getAlgoIndexerClient()
+  const deployer = await algokit.getAccount(
+    { config: algokit.getAccountConfigFromEnvironment('DEPLOYER'), fundWith: algokit.algos(3) },
+    algod,
+  )
+  await algokit.ensureFunded(
+    {
+      accountToFund: deployer,
+      minSpendingBalance: algokit.algos(2),
+      minFundingIncrement: algokit.algos(2),
+    },
+    algod,
+  )
+  const isMainNet = await algokit.isMainNet(algod)
+  const appClient = new {{ contract_name.split('_')|map('capitalize')|join }}Client(
+    {
+      resolveBy: 'creatorAndName',
+      findExistingUsing: indexer,
+      sender: deployer,
+      creatorAddress: deployer.addr,
+    },
+    algod,
+  )
+
+  {%- if preset_name == 'starter' %}
+  const app = await appClient.deploy({
+    onSchemaBreak: 'append',
+    onUpdate: 'append',
+  })
+  {% elif preset_name == 'production' %}
+  const app = await appClient.deploy({
+    allowDelete: !isMainNet,
+    allowUpdate: !isMainNet,
+    onSchemaBreak: isMainNet ? 'append' : 'replace',
+    onUpdate: isMainNet ? 'append' : 'update',
+  })
+  {% endif %}
+
+  // If app was just created fund the app account
+  if (['create', 'replace'].includes(app.operationPerformed)) {
+    algokit.transferAlgos(
+      {
+        amount: algokit.algos(1),
+        from: deployer,
+        to: app.appAddress,
+      },
+      algod,
+    )
+  }
+
+  const method = 'hello'
+  const response = await appClient.hello({ name: 'world' })
+  console.log(`Called ${method} on ${app.name} (${app.appId}) with name = world, received: ${response.return}`)
+}
+{% endraw -%}

template_content/smart_contracts/README.md.jinja

@@ -2,11 +2,11 @@
 
 By the default the template creates a single `HelloWorld` contract under {{ contract_name }} folder in the `smart_contracts` directory. To add a new contract:
 
-1. Create a new folder under `smart_contracts` directory and add define your new contract in `contract.py` file.
-2. Each contract has potentially has different creation parameters and deployment steps. Hence, you need to define your deployment logic in {% if deployment_language == 'python' %}`deploy_config.py`{% elif deployment_language == 'typescript' %}`deploy-config.ts`{% endif %}file.
-3. Reference your contract in `config.py` file. This will tell instruct the helper scripts on which exact contracts require building and generation of typed clients.
+1. From the root of the repository execute `algokit generate smart-contract`. This will create a new starter smart contract and deployment configuration file under `{your_contract_name}` subfolder under `smart_contracts` directory.
+2. Each contract potentially has different creation parameters and deployment steps. Hence, you need to define your deployment logic in {% if deployment_language == 'python' %}`deploy_config.py`{% elif deployment_language == 'typescript' %}`deploy-config.ts`{% endif %}file.
+3. `config.py` file will automatically build all contracts under `smart_contracts` directory. If you want to build specific contracts manually, modify the default code provided by the template in `config.py` file.
 {%- if deployment_language == 'typescript' %}
-4. Since you are generating a TypeScript client, you also need to reference your contract in `index.ts` file. This will instruct the TypeScript specific helper scripts on how exactly to deploy your contract.
+4. Since you are generating a TypeScript client, you also need to reference your contract deployment logic in `index.ts` file. However, similar to config.py, by default, `index.ts` will auto import all TypeScript deployment files under `smart_contracts` directory. If you want to manually import specific contracts, modify the default code provided by the template in `index.ts` file.
 {%- endif %}
 
-> Please note, above is just a suggested convention tailored for the base configuration and structure of this template. You are free to modify the structure and naming conventions as you see fit.
+> Please note, above is just a suggested convention tailored for the base configuration and structure of this template. Default code supplied by the template in `config.py` and `index.ts` (if using ts clients) files are tailored for the suggested convention. You are free to modify the structure and naming conventions as you see fit.

template_content/smart_contracts/config.py.jinja

@@ -1,15 +1,13 @@
 import dataclasses
+import importlib
 from collections.abc import Callable
+from pathlib import Path
 
 from algokit_utils import Account, ApplicationSpecification
 from algosdk.v2client.algod import AlgodClient
 from algosdk.v2client.indexer import IndexerClient
 from beaker import Application
 
-from smart_contracts.{{ contract_name }}.contract import app as {{ contract_name }}_app
-{% if deployment_language == 'python' -%}
-from smart_contracts.{{ contract_name }}.deploy_config import deploy as {{ contract_name }}_deploy
-{% endif %}
 
 @dataclasses.dataclass
 class SmartContract:
@@ -19,10 +17,48 @@ class SmartContract:
     ] | None = None
 
 
-{% if deployment_language == 'python' -%}
+def import_contract(folder: Path) -> Application:
+    """Imports the contract from a folder if it exists."""
+    try:
+        contract_module = importlib.import_module(
+            f"{folder.parent.name}.{folder.name}.contract"
+        )
+        return contract_module.app
+    except ImportError as e:
+        raise Exception(f"Contract not found in {folder}") from e
+
+
+def import_deploy_if_exists(
+    folder: Path,
+) -> (
+    Callable[[AlgodClient, IndexerClient, ApplicationSpecification, Account], None]
+    | None
+):
+    """Imports the deploy function from a folder if it exists."""
+    try:
+        deploy_module = importlib.import_module(
+            f"{folder.parent.name}.{folder.name}.deploy_config"
+        )
+        return deploy_module.deploy
+    except ImportError:
+        return None
+
+
+def has_contract_file(directory: Path) -> bool:
+    """Checks whether the directory contains contract.py file."""
+    return (directory / "contract.py").exists()
+
+
 # define contracts to build and/or deploy
-contracts = [SmartContract(app={{ contract_name }}_app, deploy={{ contract_name }}_deploy)]
-{% elif deployment_language == 'typescript' -%}
-# define contracts to build
-contracts = [SmartContract(app={{ contract_name }}_app)]
-{% endif -%}
+base_dir = Path("smart_contracts")
+contracts = [
+    SmartContract(app=import_contract(folder), deploy=import_deploy_if_exists(folder))
+    for folder in base_dir.iterdir()
+    if folder.is_dir() and has_contract_file(folder)
+]
+
+## Comment the above and uncomment the below and define contracts manually if you want to build and specify them
+## manually otherwise the above code will always include all contracts under contract.py file for any subdirectory
+## in the smart_contracts directory. Optionally it will also grab the deploy function from deploy_config.py if it exists.
+
+# contracts = []

template_content/smart_contracts/{% if deployment_language == 'typescript' %}index.ts{% endif %}.jinja

@@ -1,13 +1,37 @@
+import * as fs from 'fs'
+import * as path from 'path'
 import { consoleLogger } from '@algorandfoundation/algokit-utils/types/logging'
 import * as algokit from '@algorandfoundation/algokit-utils'
-import { deploy as {{ contract_name.split('_')|map('capitalize')|join }}Deployer } from './{{ contract_name }}/deploy-config'
-
-const contractDeployers = [{{ contract_name.split('_')|map('capitalize')|join }}Deployer]
 
 algokit.Config.configure({
   logger: consoleLogger,
 })
-;(async () => {
+
+// base directory
+const baseDir = path.resolve(__dirname)
+
+// function to validate and dynamically import a module
+async function importDeployerIfExists(dir: string) {
+  const deployerPath = path.resolve(dir, 'deploy-config')
+  if (fs.existsSync(deployerPath + '.ts') || fs.existsSync(deployerPath + '.js')) {
+    const deployer = await import(deployerPath)
+    return deployer.deploy
+  }
+}
+
+// get a list of all deployers from the subdirectories
+async function getDeployers() {
+  const directories = fs.readdirSync(baseDir, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => path.resolve(baseDir, dirent.name))
+
+  return Promise.all(directories.map(importDeployerIfExists))
+}
+
+// execute all the deployers
+(async () => {
+  const contractDeployers = (await getDeployers()).filter(Boolean)
+
   for (const deployer of contractDeployers) {
     try {
       await deployer()