Prompt:
This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: token.md Path: ../ao-cookbook/src/ja/guides/aos/token.md
Note: This content continues in the next part.

Response:
    Target = msg.Tags.Recipient,
    Tags = { Action = 'Credit-Notice', Sender = msg.From, Quantity = tostring(qty) }
})
```

<!-- If there was insufficient balance for the transfer it sends back a failure message -->

転送のための残高が不足している場合、失敗メッセージを返します。

```lua
ao.send({
    Target = msg.Tags.From,
    Tags = { Action = 'Transfer-Error', ['Message-Id'] = msg.Id, Error = 'Insufficient Balance!' }
})
```

`if not msg.Tags.Cast then`という行は、キャストタグが設定されている場合、メッセージをプッシュしないことを意味します。これはaoプロトコルの一部です。

### **ステップ4: ミントハンドラ**

最後に、新しいトークンをミントするためのハンドラを追加します。

<!-- The line `if not msg.Tags.Cast then` Means were not producing any messages to push if the Cast tag was set. This is part of the ao protocol.

### **Step 4: Mint Handler**

Finally, we will add a Handler to allow the minting of new tokens. -->

```lua
Handlers.add('mint', Handlers.utils.hasMatchingTag('Action', 'Mint'), function(msg, env)
  assert(type(msg.Tags.Quantity) == 'string', 'Quantity is required!')

  if msg.From == env.Process.Id then
    -- Add tokens to the token pool, according to Quantity
    local qty = tonumber(msg.Tags.Quantity)
    Balances[env.Process.Id] = Balances[env.Process.Id] + qty
  else
    ao.send({
      Target = msg.Tags.From,
      Tags = {
        Action = 'Mint-Error',
        ['Message-Id'] = msg.Id,
        Error = 'Only the Process Owner can mint new ' .. Ticker .. ' tokens!'
      }
    })
  end
end)
```

このコードは、数量タグが提供されていることを確認し、指定された数量を残高テーブルに追加します。

## ロードとテスト

`token.lua`ファイルを作成したら、または`.load-blueprint token`を使用したら、テストを開始する準備が整いました。

<!-- This code checks to make sure the Quantity Tag has been provided and then adds the specified quantity to the Balances table.

## Loading and Testing

Once you've created your `token.lua` file, or you've used `.load-blueprint token`, you're now ready to begin testing. -->

#### 1 - aosプロセスを開始

ターミナルで`aos`を実行して、aosプロセスを開始したことを確認してください。

#### 2 - token.luaファイルをロード

ガイドに従った場合、aosプロセスと同じディレクトリに`token.lua`ファイルがあるはずです。aosプロンプトからファイルをロードします。

<!-- #### 1 - Start the aos process

Make sure you've started your aos process by running `aos` in your terminal.

#### 2 - Loading the token.lua file

If you've followd along with the guide, you'll have a `token.lua` file in the same directory as your aos process. From the aos prompt, load in the file. -->

```lua
.load token.lua
```

#### 3 - トークンのテスト

今、aosプロセスIDにメッセージを送信して動作しているかどうか確認できます。ターゲットに`ao.id`を使用すると、自分自身にメッセージを送信していることになります。

<!-- #### 3 - Testing the Token

Now we can send Messages to our aos process id, from the same aos prompt to see if is working. If we use ao.id as the Target we are sending a message to ourselves. -->

```lua
Send({ Target = ao.id, Action = "Info" })
```

これにより、契約で定義された情報が表示されるはずです。最新の受信ボックスメッセージで応答を確認してください。

<!-- This should print the Info defined in the contract. Check the latest inbox message for the response. -->

```lua
Inbox[#Inbox].Tags
```

契約で定義された情報が表示されるはずです。

<!-- This should print the Info defined in the contract. -->

<!-- ::: info
Make sure you numerically are checking the last message. To do so, run `#Inbox` first to see the total number of messages are in the inbox. Then, run the last message number to see the data.
-->

::: info
最後のメッセージを数値で確認することを忘れないでください。そのために、まず`#Inbox`を実行して受信ボックス内のメッセージの合計数を確認します。その後、最後のメッセージ番号を実行してデータを確認します。
:::

**Example:**

If `#Inbox` returns `5`, then run `Inbox[5].Data` to see the data.
:::

#### 4 - 転送

次に、他のウォレットまたはプロセスIDにトークンの残高を転送してみてください。

::: info
別のプロセスIDが必要な場合は、別のターミナルウィンドウで`aos [name]`を実行して新しいプロセスIDを取得できます。同じ`aos [name]`ではないことを確認してください。
:::

<!--
#### 4 - Transfer

Now, try to transfer a balance of tokens to another wallet or process id.

::: info
If you need another process id, you can run `aos [name]` in another terminal window to get a new process id. Make sure it's not the same `aos [name]` as the one you're currently using. -->

**Example:**

If you're using `aos` in one terminal window, you can run `aos test` in another terminal window to get a new process id.
:::

```lua
Send({ Target = ao.id, Tags = { Action = "Transfer", Recipient = 'another wallet or processid', Quantity = '10000' }})
```

<!-- After sending, you'll receive a printed message in the terminal similar to `Debit-Notice` on the sender's side and `Credit-Notice` on the recipient's side. -->

送信後、ターミナルに`Debit-Notice`が送信者側に、`Credit-Notice`が受取人側に表示されるメッセージが印刷されます。

#### 5 - 残高を確認

トークンを転送したので、残高を確認してみましょう。

<!--
#### 5 - Check the Balances

Now that you've transferred some tokens, let's check the balances.
-->

```lua
Send({ Target = ao.id, Tags = { Action = "Balances" }})
```

```lua
Inbox[#Inbox].Data
```

2つのプロセスIDまたはウォレットアドレスが表示され、それぞれが残高を表示します。最初は送信プロセスID、2番目は受取人のプロセスIDである必要があります。

#### 6 - トークンのミント

最後に、いくつかのトークンをミントしようとしてください。

<!-- You will see two process IDs or wallet addresses, each displaying a balance. The first should be your sending process ID, the second should be the recipient's process ID.

#### 6 - Minting Tokens

Finally, attempt to mint some tokens.
-->

```lua
Send({ Target = ao.id, Tags = { Action = "Mint", Quantity = '1000' }})
```

And check the balances again.

```lua
Send({ Target = ao.id, Tags = { Action = "Balances" }})
Inbox[#Inbox].Data
```

<!--
You'll then see the balance of the process ID that minted the tokens has increased.

## Conclusion

That concludes the "Build a Token" guide. Learning out to build custom tokens will unlock a great deal of potential for your projects; whether that be creating a new currency, a token for a game, a governance token, or anything else you can imagine.
-->

その後、トークン


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: token.md Path: ../ao-cookbook/src/ja/guides/aos/token.md

Response:
としてください。

<!-- You will see two process IDs or wallet addresses, each displaying a balance. The first should be your sending process ID, the second should be the recipient's process ID.

#### 6 - Minting Tokens

Finally, attempt to mint some tokens.
-->

```lua
Send({ Target = ao.id, Tags = { Action = "Mint", Quantity = '1000' }})
```

And check the balances again.

```lua
Send({ Target = ao.id, Tags = { Action = "Balances" }})
Inbox[#Inbox].Data
```

<!--
You'll then see the balance of the process ID that minted the tokens has increased.

## Conclusion

That concludes the "Build a Token" guide. Learning out to build custom tokens will unlock a great deal of potential for your projects; whether that be creating a new currency, a token for a game, a governance token, or anything else you can imagine.
-->

その後、トークンをミントしたプロセスIDの残高が増加したことが確認できます。

## 結論

これで「トークンを作成する」ガイドは終了です。カスタムトークンを作成する方法を学ぶことで、プロジェクトに大きな可能性が開かれます。それは新しい通貨を作成すること、ゲーム用のトークンを作成すること、ガバナンストークンを作成すること、または想像できるすべてのことです。


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: load.md Path: ../ao-cookbook/src/ja/guides/aos/load.md

Response:
# .load

この機能を使用すると、ローカルマシン上のソースファイルからLuaコードをロードできます。このシンプルな機能は、aosプロセスで作業するための素晴らしい開発体験を提供します。

ハンドラーを作成する際、多くのコードが必要になることがあります。そのため、vscodeのような豊富な開発環境を活用したいと思うことでしょう。Lua拡張機能をインストールすれば、構文チェックも受けられます。

では、ローカルのLuaソースコードをaoプロセスに公開するにはどうすればよいのでしょうか？ここで`.load`コマンドが役立ちます。

hello.lua

```lua
Handlers.add(
  "ping",
  Handlers.utils.hasMatchingData("ping"),
  Handlers.utils.reply("pong")
)
```

aos shell

```lua
.load hello.lua
```

Easy Peasy! 🐶


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: pingpong.md Path: ../ao-cookbook/src/ja/guides/aos/pingpong.md

Response:
<script setup>
  import {onMounted} from "vue"
  import {renderRepl} from "../../../tools/replRenderer.jsx"

  const codes = {
    "step-3": `Handlers.add(
      "pingpong",
      Handlers.utils.hasMatchingData("ping"),
      Handlers.utils.reply("pong")
      )`,
    "step-5": `Send({ Target = ao.id, Data = "ping" })`,
    "step-6": `Inbox[#Inbox].Data`
  }

  onMounted(() => {
      Object.keys(codes).forEach((key) => {
        renderRepl(key, codes[key])
      })
    }
  )
</script>

# aosでPingpongプロセスを作成する

このチュートリアルでは、aosでシンプルな「ping-pong」プロセスを作成する方法を説明します。このプロセスでは、「ping」というデータを含むメッセージを受信するたびに、自動的に「pong」と返信します。これは、aosにおけるメッセージ処理とプロセス間の相互作用の基本的な例です。

## ステップ1: `aos` CLIを開く

- コマンドラインインターフェースを開き、`aos`と入力してaos環境に入ります。

## ステップ2: エディタにアクセス

- aos CLIで`.editor`と入力してインラインテキストエディタを開きます。ここでping-pongハンドラーコードを記述します。

## ステップ3: Pingpongハンドラーを書く

- エディタに以下のLuaコードを入力してpingpongパターンのハンドラーを追加します：
<!--

# Creating a Pingpong Process in aos

This tutorial will guide you through creating a simple "ping-pong" process in aos. In this process, whenever it receives a message with the data "ping", it will automatically reply with "pong". This is a basic example of message handling and interaction between processes in aos.

## Step 1: Open the `aos` CLI

- Start by opening your command-line interface and typing `aos` to enter the aos environment.

## Step 2: Access the Editor

- Type `.editor` in the aos CLI to open the inline text editor. This is where you'll write your ping-pong handler code.

## Step 3: Write the Pingpong Handler

- In the editor, enter the following Lua code to add a handler for the pingpong pattern:
  -->

  ```lua
  Handlers.add(
    "pingpong",
    Handlers.utils.hasMatchingData("ping"),
    Handlers.utils.reply("pong")
  )
  ```

    <div id="step-3"></div>

- このLuaスクリプトは3つのことを行います：
  1. "pingpong"という名前の新しいハンドラーを追加します。
  2. `Handlers.utils.hasMatchingData("ping")`を使用して、受信したメッセージがデータ"ping"を含むかどうかを確認します。
  3. メッセージが"ping"を含む場合、`Handlers.utils.reply("pong")`が自動的にデータ"pong"を持つメッセージを返します。

<!--
- This lua script does three things:
  1. It adds a new handler named "pingpong".
  2. It uses `Handlers.utils.hasMatchingData("ping")` to check if incoming messages contain the data "ping".
  3. If the message contains "ping", `Handlers.utils.reply("pong")` automatically sends back a message with the data "pong".
-->
<!--
## Step 4: Exit the Editor
-->

## ステップ4: エディタを終了する

- コードを書いたら、`.done`と入力してEnterを押すことでエディタを終了し、スクリプトを実行します。

<!--
- After writing your code, type `.done` and press Enter to exit the editor and run the script.
-->

<!--
## Step 5: Test the Pingpong Process
-->

<!--
- To test the process, send a message with the data "ping" to the process. You can do this by typing the following command in the aos CLI:
-->

## ステップ5: Pingpongプロセスをテストする

- プロセスをテストするために、データ"ping"を含むメッセージをプロセスに送信します。次のコマンドをaos CLIに入力して行います：

  ```lua
  Send({ Target = ao.id, Data = "ping" })
  ```

  <div id="step-5"></div>

- プロセスは、`Inbox`に"pong"を含むメッセージで応答するはずです。

## ステップ6: Inboxを監視する

- `Inbox`を確認して"ping"メッセージと、`Outbox`を確認して"pong"の返信があるかどうかを確認します。
<!--
- The process should respond with a message containing "pong" in the `Inbox`.

## Step 6: Monitor the Inbox

- Check your Inbox to see the "ping" message and your Outbox to confirm the "pong" reply.
  -->

```lua
Inbox[#Inbox].Data
```

<div id="step-6"></div>

## ステップ7: 実験して観察する

- 異なるメッセージを送信して、"ping"メッセージのみが"pong"の応答を引き起こす様子を観察してみてください。

## ステップ8: プロセスを保存する（オプション）

- 将来的にこのプロセスを使用したい場合は、ハンドラーコードをLuaファイルに保存して、aosセッションで簡単に読み込むことができます。

::: info

**追加のヒント:**

- **ハンドラーの効率性**: ハンドラー関数のシンプルさが重要です。効率的で、正しい条件下でのみトリガーされるようにしてください。

:::

## 結論

おめでとうございます！これで、aosで基本的なping-pongプロセスを作成しました。このチュートリアルは、メッセージ処理とaos環境内でのプロセスの相互作用を理解するための基礎を提供します。これらの概念に慣れてきたら、より複雑なプロセスや相互作用に拡張し、aosの可能性を探求することができます。

<!--
## Step 7: Experiment and Observe

- Experiment by sending different messages and observe how only the "ping" messages trigger the "pong" response.

## Step 8: Save Your Process (Optional)

- If you want to use this process in the future, save the handler code in a Lua file for easy loading

into aos sessions.

::: info

**ADDITIONAL TIP:**

- **Handler Efficiency**: The simplicity of the handler function is key. Ensure that it's efficient and only triggers under the correct conditions.

:::

## Conclusion

Congratulations! You have now created a basic ping-pong process in aos. This tutorial provides a foundation for understanding message handling and process interaction within the aos environment. As you become more comfortable with these concepts, you can expand to more complex processes and interactions, exploring the full potential of aos.
-->


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: index.md Path: ../ao-cookbook/src/ja/guides/aos/index.md

Response:
---
prev:
  text: "Tutorials"
  link: "/guides/tutorials/"
next:
  text: "Introduction to aos"
  link: "/guides/aos/intro"
---

# aos

`ao`は、分散コンピュートを可能にするハイパーパラレルコンピュータであり、`aos`はそのコンピュータ上のオペレーティングシステムです。

`aos`を使用すると、プロセスと対話し、非常にシンプルで直感的な方法でプロセスをコーディングできます。必要なのはターミナルとエディターだけです。

`aos`で選ばれた言語は[Lua](../../concepts/lua.md)であり、堅牢で決定論的な動的言語で、非常に楽しく作業できます。

まだ行っていない場合は、15分間で当社の[チュートリアル](../../tutorials/index)を確認してください。

## `aos`の詳細

- [Introduction to aos](intro)
- [Installing](installing)
- [`aos` CLI](cli)
- [Prompt Customization](prompt)
- [A Ping-Pong Server](pingpong)

## 開発者ガイド

- [Editor Setup](editor)
- [Troubleshooting with ao.link](troubleshooting)
- [Understanding the Inbox](inbox-and-handlers)
- [Frequently Asked Questions](faq)

### [**Modules**](modules/index)

- [JSON](modules/json)
- [`ao`](modules/ao)
- [crypto](modules/crypto)
- [Base64](modules/base64)
- [Pretty](modules/pretty)
- [Utils](modules/utils)


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: editor.md Path: ../ao-cookbook/src/ja/guides/aos/editor.md

Response:
# エディタ設定

すべての組み込みのao関数やユーティリティを覚えるのは時には難しいことがあります。開発者の体験を向上させるために、お気に入りのテキストエディタに[Lua Language Server](https://luals.github.io)拡張機能をインストールし、[aoアドオン](https://github.com/martonlederer/ao-definitions)を追加することをお勧めします。これにより、すべての組み込みのaos [モジュール](../aos/modules/index)や[グローバル変数](../aos/intro#globals)をサポートします。

## VS Code

[sumneko.lua](https://marketplace.visualstudio.com/items?itemName=sumneko.lua)拡張機能をインストールします：

1. 拡張機能マーケットプレイスで「Lua」を検索し、sumnekoによるものを見つけます。
2. 拡張機能をダウンロードしてインストールします。
3. `Shift + Command + P` (Mac) / `Ctrl + Shift + P` (Windows/Linux)を押して、VS Codeのコマンドパレットを開き、次のコマンドを実行します：

<!--
# Editor setup

Remembering all the built in ao functions and utilites can sometimes be hard. To enhance your developer experience, it is recommended to install the [Lua Language Server](https://luals.github.io) extension into your favorite text editor and add the [ao addon](https://github.com/martonlederer/ao-definitions). It supports all built in aos [modules](../aos/modules/index) and [globals](../aos/intro#globals).

## VS Code

Install the [sumneko.lua](https://marketplace.visualstudio.com/items?itemName=sumneko.lua) extension:

1. Search for "Lua" by sumneko in the extension marketplace
2. Download and install the extension
3. Open the VS Code command palette with `Shift + Command + P` (Mac) / `Ctrl + Shift + P` (Windows/Linux) and run the following command:
-->

```
> Lua: Open Addon Manager
```

4. アドオンマネージャーで「ao」を検索します。最初の結果に表示されるはずです。クリックして「有効にする」を選択し、オートコンプリートを楽しんでください！

## 他のエディタ

1. あなたのエディタが[言語サーバープロトコル](https://microsoft.github.io/language-server-protocol/implementors/tools/)をサポートしていることを確認します。
2. [luals.github.io](https://luals.github.io/#install)の手順に従ってLua Language Serverをインストールします。
3. 言語サーバーに「ao」アドオンをインストールします。

## BetterIDEa

[BetterIDEa](https://ide.betteridea.dev)は、ao上で開発するためのカスタムウェブベースのIDEです。

組み込みのLua言語サーバーとao定義を提供するため、何もインストールする必要はありません。IDEを開いてコーディングを始めるだけです！

機能には以下が含まれます：

- コード補完
- 高速開発のためのセルベースのノートブックUI
- 簡単なプロセスマネジメント
- MarkdownとLaTeXのセルサポート
- aoプロセスを通じて誰とでもプロジェクトを共有
- [aoパッケージマネージャー](https://apm.betteridea.dev)との密接な統合

IDEのさまざまな機能や統合に関する詳細情報は[ドキュメント](https://docs.betteridea.dev)をお読みください。

<!--
4. In the Addon Manager, search for "ao", it should be the first result. Click "Enable" and enjoy autcomplete!

## Other editors

1. Verify that your editor supports the [language server protocol](https://microsoft.github.io/language-server-protocol/implementors/tools/)
2. Install Lua Language Server by following the instructions at [luals.github.io](https://luals.github.io/#install)
3. Install the "ao" addon to the language server

## BetterIDEa

[BetterIDEa](https://ide.betteridea.dev) is a custom web based IDE for developing on ao.

It offers a built in Lua language server with ao definitions, so you don't need to install anything. Just open the IDE and start coding!

Features include:

- Code completion
- Cell based notebook ui for rapid development
- Easy process management
- Markdown and Latex cell support
- Share projects with anyone through ao processes
- Tight integration with [ao package manager](https://apm.betteridea.dev)

Read detailed information about the various features and integrations of the IDE in the [documentation](https://docs.betteridea.dev).
-->


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: prompt.md Path: ../ao-cookbook/src/ja/guides/aos/prompt.md

Response:
# aosでのプロンプトのカスタマイズ

## ステップ1: aosを開いてエディタを開始する

- aosコマンドラインインターフェイスを起動します。
- `.editor`と入力して、インラインテキストエディタを開きます。

## ステップ2: カスタムプロンプト関数を書く

- エディタで、カスタムプロンプト関数を定義します。例えば：
<!--

# Customizing the Prompt in aos

## Step 1: Open aos and Start the Editor

- Launch the aos command-line interface.
- Enter `.editor` to open the inline text editor.

## Step 2: Write the Custom Prompt Function

- In the editor, define your custom prompt function. For example:
  -->

  ```lua
  function Prompt()
      return "YourName@aos> "
  end
  ```

  Customize `"YourName@aos> "` to your preferred prompt text.

## ステップ3: エディタを終了してコードを実行する

- エディタを終了し、コードを実行するには、`.done`と入力してEnterを押します。
- あなたのaosプロンプトは、今や新しいカスタムフォーマットを表示するはずです。

## ステップ4: 将来の使用のために保存する（オプション）

- 将来的にこのプロンプトを使用したい場合は、スクリプトをLuaファイルに保存します。
- 次回のセッションでは、このスクリプトを読み込んでカスタムプロンプトを適用します。

## プロンプトを最大限に活用する

プロンプトをカスタマイズすることで、多くのユーティリティや創造性が得られます。プロンプト内でできることはいくつかあります：

- 受信トレイにある未処理のメッセージの数を追跡する関数を作成して、どれだけのメッセージがあるかを表示します。

<!-- ## Step 3: Exit and Run Your Code

- To exit the editor and execute your code, type `.done` and then press Enter.
- Your aos prompt should now display the new custom format.

## Step 4: Save for Future Use (Optional)

- If you wish to use this prompt in future aos sessions, save your script in a Lua file.
- In subsequent sessions, load this script to apply your custom prompt.

## Maximizing Your Prompt

There's a great deal of utility and creativity that can come from customizing your prompt. Several things you can do within your prompt are:

- Tracking the number of unhandled messages you have in your inbox by creating a function that shows how many messages you have.
-->

```lua
  --Example:
  function Prompt()
    return "YourName Inbox: [" .. #Inbox .. "] > "
  end
```

<!--
- Tracking the number of members are within your process ID's chatroom.
- Tracking the balance of a specified token that your process ID holds.

## Conclusion

Now that you understand how to maximize the utility within your Prompt, you've now gained a crucial step to streamlining your ao development experience.
-->

- プロセスIDのチャットルーム内のメンバーの数を追跡します。
- プロセスIDが保持する特定のトークンの残高を追跡します。

## 結論

プロンプト内でのユーティリティを最大限に活用する方法を理解したので、ao開発体験を効率化するための重要なステップを手に入れました。


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: cli.md Path: ../ao-cookbook/src/ja/guides/aos/cli.md

Response:
# CLI

aosに渡すコマンドライン引数は以下の操作を行うためのものです:

- [name] - 新しいプロセスを作成するか、ウォレット用の既存のプロセスを読み込みます
- --load [file] - ファイルを読み込みます。このコマンドを1つまたは複数追加できます
- --cron [interval] - プロセスを作成する際のみ使用します
- --wallet [walletfile] - 特定のウォレットを使用します

## aosを使用した複数プロセスの管理

<!-- # CLI

There are some command-line arguments you pass to our aos to do the following:

- [name] - create a new process or loads an existing process for your wallet
- --load [file] - load a file, you can add one or many of this command
- --cron [interval] - only used when creating a process
- --wallet [walletfile] - use a specific wallet

## Managing multiple processes with aos
-->

```sh
aos
```

<!-- Starts or connects to a process with the name `default` -->

`default`という名前のプロセスを開始するか、接続します。

```sh
aos chatroom
```

`chatroom`という名前のプロセスを開始するか、接続します。

<!-- Starts or connects to a process with the name of `chatroom` -->

```sh
aos treasureRoom
```

<!-- Starts or connects to a process with the name of `treasureRoom` -->

`treasureRoom`という名前のプロセスを開始するか、接続します。

## Load flag

```sh
aos treasureRoom --load greeting.lua --load treasure.lua --load puzzle.lua
```

loadフラグを使用すると、プロセスに複数のソースファイルを読み込むことができます。

## CRONフラグ

プロセスをスケジュールに基づいて反応させる場合は、aoにその旨を伝える必要があります。これはプロセスを生成する際に行います。

<!--
With the load flag I can load many source files to my process

## CRON Flag

If you want to setup your process to react on a schedule we need to tell ao, we do that when we spawn the process.
-->

```sh
aos chatroom --cron 2-minutes
```

## タグフラグ

タグフラグを使用すると、カスタムタグ（例えば、静的環境変数として使用するため）でプロセスを開始できます。

上記のコマンドは、プロセスを生成するトランザクションに追加のタグを追加します：

<!--
## Tag flags

With the tag flags, you can start a process with some custom tags (for e.g. using them as static environment variables):
-->

```sh
aos chatroom --tag-name Chat-Theme --tag-value Dark --tag-name Chat-Name --tag-value Mychat
```

<!-- The command above will add the extra tags to the transaction that spawns your process: -->

上記のコマンドは、プロセスを生成するトランザクションに追加のタグを追加します：

```ts
// process data item tags
[
  ...
  { name: "Chat-Theme", value: "Dark" },
  { name: "Chat-Name", value: "Mychat" }
  ...
]
```


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: intro.md Path: ../ao-cookbook/src/ja/guides/aos/intro.md

Response:
# はじめに

aosは、プロセスや契約を構築するための異なるアプローチを提供します。aoコンピュータは、計算がどこでも実行できる分散型コンピュータネットワークであり、aosはユニークなインタラクティブシェルを持っています。あなたは、aosを個人的なオペレーティングシステム、aoプロセスを構築するための開発環境、そしてボットアーミーとして利用できます。

基本的なコマンドをいくつか見ていきましょう。

## 変数

コンソールを通じて任意の変数の内容を表示したい場合は、単に変数名を入力してください。

```lua
Name
```

## インボックス

`Inbox`は、あなたのプロセスが受信したメッセージのコレクションです。

```lua
Inbox[1]
```

メッセージのカウントを取得したい場合は、`#`を`Inbox`の前に追加してください。

```lua
#Inbox
```

インボックスに何件のメッセージがあるかを確認するプロセスは非常に一般的なパターンです。これを簡単にするために、インボックス内のメッセージ数を返し、それをプロンプトに表示する関数を作成できます。

`.editor`または`.load file`を使用して、この関数をプロセスにロードしてください。

```lua
function Prompt()
  return "Inbox: " .. #Inbox .. " > "
end
```

**The Expected Results:**

```lua
undefined
Inbox: 2 >
```

あなたのプロンプトは、インボックス内のメッセージ数を含むように変更されました。

## グローバル

aosプロセスには、開発を少し直感的にするためのいくつかのグローバル変数があります。

| Name                   | Description                                                                                | Type         |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ |
| Inbox                  | This is a lua Table that stores all the messages that are received and not handlers by any handlers.                                                                              | Table(Array) |
| Send(Message)          | This is a global function that is available in the interactive environment that allows you to send messages to Processes                                                          | function     |
| Spawn(Module, Message) | This is a global function that is available in the aos interactive environment that allows you to spawn processes                                                                 |
| Name                   | a string that is set on init that describes the name of your process                                                                                | string       |
| Owner                  | a string that is set on the init of the process that documents the owner of the process, warning if you change this value, it can brick you ability to interact with your process | string       |
| Handlers               | a lua Table that contains helper functions that allows you to create handlers that execute functionality based on the pattern matching function on inbound messages               | table        |
| Dump                   | a function that takes any lua Table and generates a print friendly output of the data                                                                                | function     |
| Utils                  | a functional utility library with functions like map, reduce, filter                                                                                | module       |
| ao                     | this is a core function library for sending messages and spawing processes                                                                                | module       |

## モジュール

aosには、すでに利用可能な一般的なLuaモジュールがいくつか組み込まれており、これらのモジュールは`require`関数で参照できます。

| Name    | Description                                                                |
| ------- | -------------------------------------------------------------------------- |
| json    | a json module that allows you to encode and decode json documents          |
| ao      | contains ao specific functions like send and spawn                         |
| .base64 | a base64 module that allows you to encode and decode base64 text           |
| .pretty | a pretty print module using the function tprint to output formatted syntax |
| .utils  | an utility function library                                                |


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: inbox-and-handlers.md Path: ../ao-cookbook/src/ja/guides/aos/inbox-and-handlers.md

Response:
# Inboxの理解

aosでは、プロセスはハンドラーを介してメッセージに応じて実行されます。未処理のメッセージはプロセスのInboxにルーティングされます。

## ハンドラーとは？

ハンドラーは、プロセス内でメッセージを受信して評価する関数です。メッセージをパラメーターとして受け取り、それに基づいて動作します。

<!--
# Understanding the Inbox

In aos, processes are executed in response to messages via handlers. Unhandled messages are routed to the process's Inbox.

## What are Handlers?

A handler is a function that receives and evaluates messages within your process. It acts upon messages by taking them as parameters.
-->

```lua
function main(Message, ao)
  ...dostuff
  return {
    Output = ...,
    Messages = {},
    Spawns = {}
  }

end
```

`main`関数は、Luaのテーブルを返し、`Output`、`Messages`、`Spawns`または`Error`を提供します。aosを使用すると、ハンドラーを使用してプロセスに機能を追加できます。ハンドラーは3つのパラメーターを取ります：

1. ハンドラーの名前
2. マッチャー関数
3. ハンドル関数

<!--
And the `main` function returns a lua Table providing `Output, Messages, and Spawns` or an `Error`. With aos you can add functionality to your process by using a Handler. The Handler takes three parameters:

1. Name of the Handler
2. Matcher function
3. Handle function
-->

```lua
Handlers.add("name",
  function (Msg)
    -- Does this message match (return true or false)
    return Msg.Action == "Register"
  end,
  function (Msg)
    print("Registered User.")
    table.insert(Members, Msg.From)
    ao.send({Target = Msg.From, Data = "Registered."})
  end
)
```

## Inboxについては？

Inboxは、まだ処理されていないメッセージのためのストレージエリアです。受信アイテムの処理を待つ「保持ゾーン」と考えてください。メッセージが処理されると、もはや「受信」扱いではなくなり、Inboxを離れます。

> 例: Inboxはボイスメールのようなものです。未対応の電話がボイスメールに転送されて後で対応されるのと同様に、プロセスがすぐに処理しないメッセージはInboxに送られます。このようにして、未処理のメッセージは、処理する準備が整うまで保存されます。

## 概要

最初は、すべてのメッセージがInboxに届くように見えるかもしれませんが、処理された後に消えると混乱を招くことがあります。ボイスメールのアナロジーを考えると、応答した電話がボイスメールに行かないのと同じように、処理したメッセージはInboxに表示されないということが明らかになります。これにより、Inboxとハンドラーの両方の役割が示されます。

<!--
## What about Inboxes?

An inbox is a storage area for messages that have not yet been processed. Think of it as a holding zone for incoming, or "inbound," items awaiting handling. Once a message is processed, it's no longer considered "inbound" and thus leaves the inbox.

> Example: Consider the inbox like your voicemail. Just as an unanswered phone call is directed to voicemail for you to address later, messages that your Process doesn't immediately handle are sent to the inbox. This way, unhandled messages are stored until you're ready to process them.

## Summary

Initially, it might seem like all messages are meant to land in your Inbox, which can be puzzling if they disappear after being handled. The analogy of a voicemail should clarify this: much like calls you answer don't go to voicemail, messages you handle won't appear in your Inbox. This illustrates the roles of both the Inbox and Handlers. -->


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: faq.md Path: ../ao-cookbook/src/ja/guides/aos/faq.md

Response:
# FAQ

## Ownership

  プロセスの所有権を理解する

aosコンソールで新しいプロセスを開始すると、そのプロセスの所有権はあなたのウォレットアドレスに設定されます。**aos**は、プロセスの所有権を定義するために**Owner**グローバル変数を使用します。所有権を移転したり、誰も所有できないようにプロセスをロックしたい場合は、単に**Owner**変数を別のウォレットアドレスに変更するか、**nil**に設定します。

## JSON

  データをJSONとしてエンコードする

他のプロセスや外部サービスにデータを送信する際、受取人のためにデータをエンコードする手段としてJSONを使用することができます。Luaのjsonモジュールを使用すると、値を含む純粋なLuaテーブルを**エンコード**および**デコード**できます。

```lua
Send({Target = Router, Data = require('json').encode({hello = "world"})})
```

## Send vs ao.send

  Sendとao.sendの使い分け

両方の関数はプロセスにメッセージを送信しますが、ao.sendはメッセージを返すため、ログを記録したりトラブルシューティングを行いたい場合に便利です。**Send**関数は、コンソールでのアクセスを容易にするために使用されることを意図しています。**Handlers**内では**ao.send**を使用することが推奨されますが、どちらも**aos**内では互換性があります。


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: chatroom.md Path: ../ao-cookbook/src/ja/guides/aos/blueprints/chatroom.md

Response:
# チャットルームブループリント

チャットルームブループリントは、`ao` でチャットルームを迅速に構築するのに役立つ事前設計されたテンプレートです。始めるのに最適な方法であり、ニーズに合わせてカスタマイズできます。

## チャットルームブループリントの内容

- **メンバー**: `Members` 配列は、チャットルームに登録したユーザーを保存するために使用されます。

- **登録ハンドラー**: `register` ハンドラーは、プロセスがチャットルームに参加できるようにします。プロセスが `Action = "Register"` タグを持つメッセージを送信すると、ハンドラーはプロセスを `Members` 配列に追加し、登録を確認するメッセージをプロセスに送信します。

- **ブロードキャストハンドラー**: `broadcast` ハンドラーは、プロセスがチャットルームのすべてのメンバーにメッセージを送信できるようにします。プロセスが `Action = "Broadcast"` タグを持つメッセージを送信すると、ハンドラーはチャットルームのすべてのメンバーにメッセージを送信します。

### 使用方法:

1. お好みのテキストエディタを開きます。
2. ターミナルを開きます。
3. `aos` プロセスを開始します。
4. `.load-blueprint chatroom` と入力します。

### ブループリントが読み込まれたことを確認する:

`Handlers.list` と入力して、新しく読み込まれたハンドラーを確認します。

## チャットルームブループリントの内容:

<!-- # Chatroom Blueprint

The Chatroom Blueprint is a predesigned template that helps you quickly build a chatroom in `ao`. It is a great way to get started and can be customized to fit your needs.

## Unpacking the Chatroom Blueprint

- **Members**: The `Members` array is used to store the users who have registered to the chatroom.

- **Register Handler**: The `register` handler allows processes to join the chatroom. When a process sends a message with the tag `Action = "Register"`, the handler will add the process to the `Members` array and send a message back to the process confirming the registration.

- **Broadcast Handler**: The `broadcast` handler allows processes to send messages to all the members of the chatroom. When a process sends a message with the tag `Action = "Broadcast"`, the handler will send the message to all the members of the chatroom.

### How To Use:

1. Open your preferred text editor.
2. Open the Terminal.
3. Start your `aos` process.
4. Type in `.load-blueprint chatroom`

### Verify the Blueprint is Loaded:

Type in `Handlers.list` to see the newly loaded handlers.

## What's in the Chatroom Blueprint: -->

```lua
Members = Members or {}

Handlers.add(
  "register",
  Handlers.utils.hasMatchingTag("Action", "Register"),
  function (msg)
    table.insert(Members, msg.From)
    Handlers.utils.reply("registered")(msg)
  end
)

Handlers.add(
  "broadcast",
  Handlers.utils.hasMatchingTag("Action", "Broadcast"),
  function (msg)
    for _, recipient in ipairs(Members) do
      ao.send({Target = recipient, Data = msg.Data})
    end
    Handlers.utils.reply("Broadcasted.")(msg)
  end
)
```


Prompt:
This is a Markdown documentation from the AO documentation repository. Filename: token.md Path: ../ao-cookbook/src/ja/guides/aos/blueprints/token.md
Note: This content continues in the next part.

Response:
# トークンブループリント

トークンブループリントは、`ao`でトークンを迅速に構築するための事前設計されたテンプレートです。これは、始めるのに最適な方法であり、ニーズに合わせてカスタマイズできます。

## トークンブループリントの内容

- **バランス**: `Balances`配列は、参加者のトークンバランスを保存するために使用されます。

- **情報ハンドラー**: `info`ハンドラーは、プロセスがトークンのパラメーター（名前、ティッカー、ロゴ、単位など）を取得できるようにします。

- **バランスハンドラー**: `balance`ハンドラーは、プロセスが参加者のトークンバランスを取得できるようにします。

- **バランス一覧ハンドラー**: `balances`ハンドラーは、プロセスがすべての参加者のトークンバランスを取得できるようにします。

- **転送ハンドラー**: `transfer`ハンドラーは、プロセスが他の参加者にトークンを送信できるようにします。

- **ミントハンドラー**: `mint`ハンドラーは、プロセスが新しいトークンをミントできるようにします。

- **総供給ハンドラー**: `totalSupply`ハンドラーは、プロセスがトークンの総供給量を取得できるようにします。

- **バーナーハンドラー**: `burn`ハンドラーは、プロセスがトークンを焼却できるようにします。

### 使用方法:

1. 好みのテキストエディタを開きます。
2. ターミナルを開きます。
3. `aos`プロセスを開始します。
4. `.load-blueprint token`と入力します。

### ブループリントがロードされたか確認する:

`Handlers.list`と入力して、新しくロードされたハンドラーを確認します。

## トークンブループリントの内容:

<!-- # Token Blueprint

The Token Blueprint is a predesigned template that helps you quickly build a token in `ao`. It is a great way to get started and can be customized to fit your needs.

## Unpacking the Token Blueprint

- **Balances**: The `Balances` array is used to store the token balances of the participants.

- **Info Handler**: The `info` handler allows processes to retrieve the token parameters, like Name, Ticker, Logo, and Denomination.

- **Balance Handler**: The `balance` handler allows processes to retrieve the token balance of a participant.

- **Balances Handler**: The `balances` handler allows processes to retrieve the token balances of all participants.

- **Transfer Handler**: The `transfer` handler allows processes to send tokens to another participant.

- **Mint Handler**: The `mint` handler allows processes to mint new tokens.

- **Total Supply Handler**: The `totalSupply` handler allows processes to retrieve the total supply of the token.

- **Burn Handler**: The `burn` handler allows processes to burn tokens.

### How To Use:

1. Open your preferred text editor.
2. Open the Terminal.
3. Start your `aos` process.
4. Type in `.load-blueprint token`

### Verify the Blueprint is Loaded:

Type in `Handlers.list` to see the newly loaded handlers.

## What's in the Token Blueprint: -->

```lua
local bint = require('.bint')(256)
--[[
  This module implements the ao Standard Token Specification.

  Terms:
    Sender: the wallet or Process that sent the Message

  It will first initialize the internal state, and then attach handlers,
    according to the ao Standard Token Spec API:

    - Info(): return the token parameters, like Name, Ticker, Logo, and Denomination

    - Balance(Target?: string): return the token balance of the Target. If Target is not provided, the Sender
        is assumed to be the Target

    - Balances(): return the token balance of all participants

    - Transfer(Target: string, Quantity: number): if the Sender has a sufficient balance, send the specified Quantity
        to the Target. It will also issue a Credit-Notice to the Target and a Debit-Notice to the Sender

    - Mint(Quantity: number): if the Sender matches the Process Owner, then mint the desired Quantity of tokens, adding
        them the Processes' balance
]]
--
local json = require('json')

--[[
  utils helper functions to remove the bint complexity.
]]
--

local utils = {
  add = function(a, b)
    return tostring(bint(a) + bint(b))
  end,
  subtract = function(a, b)
    return tostring(bint(a) - bint(b))
  end,
  toBalanceValue = function(a)
    return tostring(bint(a))
  end,
  toNumber = function(a)
    return bint.tonumber(a)
  end
}

--[[
     Initialize State

     ao.id is equal to the Process.Id
   ]]
--
Variant = "0.0.3"

-- token should be idempotent and not change previous state updates
Denomination = Denomination or 12
Balances = Balances or { [ao.id] = utils.toBalanceValue(10000 * 10 ^ Denomination) }
TotalSupply = TotalSupply or utils.toBalanceValue(10000 * 10 ^ Denomination)
Name = Name or 'Points Coin'
Ticker = Ticker or 'PNTS'
Logo = Logo or 'SBCCXwwecBlDqRLUjb8dYABExTJXLieawf7m2aBJ-KY'

--[[
     Add handlers for each incoming Action defined by the ao Standard Token Specification
   ]]
--

--[[
     Info
   ]]
--
Handlers.add('info', "Info", function(msg)
  msg.reply({
    Name = Name,
    Ticker = Ticker,
    Logo = Logo,
    Denomination = tostring(Denomination)
  })
end)

--[[
     Balance
   ]]
--
Handlers.add('balance', "Balance", function(msg)
  local bal = '0'

  -- If not Recipient is provided, then return the Senders balance
  if (msg.Tags.Recipient) then
    if (Balances[msg.Tags.Recipient]) then
      bal = Balances[msg.Tags.Recipient]
    end
  elseif msg.Tags.Target and Balances[msg.Tags.Target] then
    bal = Balances[msg.Tags.Target]
  elseif Balances[msg.From] then
    bal = Balances[msg.From]
  end

  msg.reply({
    Balance = bal,
    Ticker = Ticker,
    Account = msg.Tags.Recipient or msg.From,
    Data = bal
  })
end)

--[[
     Balances
   ]]
--
Handlers.add('balances', "Balances",
  function(msg) msg.reply({ Data = json.encode(Balances) }) end)

--[[
     Transfer
   ]]
--
Handlers.add('transfer', "Transfer", function(msg)
  assert(type(msg.Recipient) == 'string', 'Recipient is required!')
  assert(type(msg.Quantity) == 'string', 'Quantity is required!')
  assert(bint.__lt(0, bint(msg.Quantity)), 'Quantity must be greater than 0')

  if not Balances[msg.From] then Balances[msg.From] = "0" end
  if not Balances[msg.Recipient] then Balances[msg.Recipient] = "0" end

  if bint(msg.Quantity) <= bint(Balances[msg.From]) then
    Balances[msg.From] = utils.subtract(Balances[msg.From], msg.Quantity)
    Balances[msg.Recipient] = utils.add(Balances[msg.Recipient], msg.Quantity)

    --[[
         Only send the notifications to the Sender and Recipient
         if the Cast tag is not set on the Transfer message
       ]]
    --
    if not msg.Cast then
      -- Debit-Notice message template, that is sent to the Sender of the transfer
      local debitNotice = {
        Action = 'Debit-Notice',
        Recipient = msg.Recipient,
        Quantity = msg.Quantity,
        Data = Colors.gray ..
            "You transferred " ..
            Colors.blue .. msg.Quantity .. Colors.gray .. " to " .. Colors.green .. msg.Recipient .. Colors.reset
      }
      -- Credit-Notice message template, that is sent to the Recipient of the transfer
      local creditNotice = {
        Target = msg.Recipient,
        Action = 'Credit-Notice',
        Sender = msg.From,
        Quantity = msg.Quantity,
        Data = Colors.gray ..
            "You received " ..
            Colors.blue .. msg.Quantity .. Colors.gray .. "


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: token.md Path: ../ao-cookbook/src/ja/guides/aos/blueprints/token.md

Response:
 msg.Quantity)

    --[[
         Only send the notifications to the Sender and Recipient
         if the Cast tag is not set on the Transfer message
       ]]
    --
    if not msg.Cast then
      -- Debit-Notice message template, that is sent to the Sender of the transfer
      local debitNotice = {
        Action = 'Debit-Notice',
        Recipient = msg.Recipient,
        Quantity = msg.Quantity,
        Data = Colors.gray ..
            "You transferred " ..
            Colors.blue .. msg.Quantity .. Colors.gray .. " to " .. Colors.green .. msg.Recipient .. Colors.reset
      }
      -- Credit-Notice message template, that is sent to the Recipient of the transfer
      local creditNotice = {
        Target = msg.Recipient,
        Action = 'Credit-Notice',
        Sender = msg.From,
        Quantity = msg.Quantity,
        Data = Colors.gray ..
            "You received " ..
            Colors.blue .. msg.Quantity .. Colors.gray .. " from " .. Colors.green .. msg.From .. Colors.reset
      }

      -- Add forwarded tags to the credit and debit notice messages
      for tagName, tagValue in pairs(msg) do
        -- Tags beginning with "X-" are forwarded
        if string.sub(tagName, 1, 2) == "X-" then
          debitNotice[tagName] = tagValue
          creditNotice[tagName] = tagValue
        end
      end

      -- Send Debit-Notice and Credit-Notice
      msg.reply(debitNotice)
      Send(creditNotice)
    end
  else
    msg.reply({
      Action = 'Transfer-Error',
      ['Message-Id'] = msg.Id,
      Error = 'Insufficient Balance!'
    })
  end
end)

--[[
    Mint
   ]]
--
Handlers.add('mint', "Mint", function(msg)
  assert(type(msg.Quantity) == 'string', 'Quantity is required!')
  assert(bint(0) < bint(msg.Quantity), 'Quantity must be greater than zero!')

  if not Balances[ao.id] then Balances[ao.id] = "0" end

  if msg.From == ao.id then
    -- Add tokens to the token pool, according to Quantity
    Balances[msg.From] = utils.add(Balances[msg.From], msg.Quantity)
    TotalSupply = utils.add(TotalSupply, msg.Quantity)
    msg.reply({
      Data = Colors.gray .. "Successfully minted " .. Colors.blue .. msg.Quantity .. Colors.reset
    })
  else
    msg.reply({
      Action = 'Mint-Error',
      ['Message-Id'] = msg.Id,
      Error = 'Only the Process Id can mint new ' .. Ticker .. ' tokens!'
    })
  end
end)

--[[
     Total Supply
   ]]
--
Handlers.add('totalSupply', "Total-Supply", function(msg)
  assert(msg.From ~= ao.id, 'Cannot call Total-Supply from the same process!')

  msg.reply({
    Action = 'Total-Supply',
    Data = TotalSupply,
    Ticker = Ticker
  })
end)

--[[
 Burn
]] --
Handlers.add('burn', 'Burn', function(msg)
  assert(type(msg.Quantity) == 'string', 'Quantity is required!')
  assert(bint(msg.Quantity) <= bint(Balances[msg.From]), 'Quantity must be less than or equal to the current balance!')

  Balances[msg.From] = utils.subtract(Balances[msg.From], msg.Quantity)
  TotalSupply = utils.subtract(TotalSupply, msg.Quantity)

  msg.reply({
    Data = Colors.gray .. "Successfully burned " .. Colors.blue .. msg.Quantity .. Colors.reset
  })
end)
```


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: index.md Path: ../ao-cookbook/src/ja/guides/aos/blueprints/index.md

Response:
---
prev:
  text: "Build a Token"
  link: "../token"
next:
  text: "Token Blueprint"
  link: "./token"
---

# Blueprints

Blueprintsは、`ao`で迅速に構築するのに役立つ事前設計されたテンプレートです。これらは、始めるための優れた方法であり、ニーズに合わせてカスタマイズできます。

## 利用可能なブループリント

- [チャットルーム](chatroom)
- [CRED Utils](cred-utils)
- [ステーキング](staking)
- [トークン](token)
- [投票](voting)


Prompt:
This is a Markdown documentation from the AO documentation repository. Filename: cred-utils.md Path: ../ao-cookbook/src/ja/guides/aos/blueprints/cred-utils.md
Note: This content continues in the next part.

Response:
# CRED ユーティリティブループリント

CRED ユーティリティブループリントは、`ao` テストネットで CRED 残高を迅速に確認するのに役立つ事前設計されたテンプレートです。

## CRED ユーティリティブループリントの内容

### `CRED` メタテーブル

- **CRED.balance**: `CRED.balance` を評価すると、プロセスの CRED の最後の既知の残高が表示されます。
  以前に CRED 残高を取得したことがない場合、自動的に取得されます。
  最近 CRED が変わったと思われる場合は、まず `CRED.update` を実行することを検討してください。

- **CRED.process**: `CRED.process` を評価すると、CRED トークン発行者のプロセス ID が表示されます。

- **CRED.send**: `CRED.send(targetProcessId, amount)` を関数のように呼び出すと、`ao` プロセスから別の `ao` プロセスに CRED を転送します。

  - `targetProcessId`: **string**: 受信者の 43 文字のプロセス ID。
  - `amount`: **integer**: 送信する CRED 単位の数量。1 CRED === 1000 CRED 単位。

- **CRED.update**: `CRED.update` を評価すると、CRED 発行者プロセスにメッセージを送信して最新の CRED 残高を取得します。
  `UpdateCredBalance` ハンドラー（下記参照）が応答メッセージを受け取ります。

### ハンドラー定義

- **クレジットハンドラー**: `CRED_Credit` ハンドラーは、CRED 発行者プロセス（および `aos`）が CRED 残高の増加を自動的に通知できるようにします。

- **デビットハンドラー**: `CRED_Debit` ハンドラーは、CRED 発行者プロセス（および `aos`）が CRED 残高の減少を自動的に通知できるようにします。

- **残高更新ハンドラー**: `UpdateCredBalance` ハンドラーは、任意の `CRED.update` リクエストへの応答を受け取ります。

## ブループリントの使用方法

1. ターミナルを開きます。
2. `aos` プロセスを開始します。
3. `.load-blueprint credUtils` と入力します。
4. `CRED.balance` と入力します。

## CRED ユーティリティブループリントの内容:

最新バージョンの `aos` に付属するブループリントについては、`aos` の [GitHub ソースコード](https://github.com/permaweb/aos/blob/main/blueprints/credUtils.lua) を参照してください。

<!-- # CRED Utils Blueprint

The CRED Utils Blueprint is a predesigned template that helps you quickly check your CRED balance in `ao` legacynet.

## Unpacking the CRED Utils Blueprint

### The `CRED` Metatable

- **CRED.balance**: Evaluating `CRED.balance` will print your process's last known balance of your CRED.
  If you have never fetched your CRED balance before, it will be fetched automatically.
  If you think your CRED has recently changed, consider running `CRED.update` first.

- **CRED.process**: Evaluating `CRED.process` will print the process id of the CRED token issuer.

- **CRED.send**: Invoking `CRED.send(targetProcessId, amount)` like a function will transfer CRED from your `ao` process
  to another `ao` process.

  - `targetProcessId`: **string**: the 43-character process id of the recipient.
  - `amount`: **integer**: The quantity of CRED units to send. 1 CRED === 1000 CRED units.

- **CRED.update**: Evaluating `CRED.update` will fetch your latest CRED balance by sending a message to the CRED
  issuer process. The `UpdateCredBalance` handler (see below) will ingest the response message.

### Handler Definitions

- **Credit Handler**: The `CRED_Credit` handler allows the CRED issuer process (and `aos`) to automatically notify you when your
  CRED balance increase.

- **Debit Handler**: The `CRED_Debit` handler allows the CRED issuer process (and `aos`) to automatically notify you when your
  CRED balance decreases.

- **Update Balance Handler**: The `UpdateCredBalance` handler ingests the response to any `CRED.update` requests.

## How To Use the Blueprint

1. Open the Terminal.
2. Start your `aos` process.
3. Type in `.load-blueprint credUtils`
4. Type in `CRED.balance`

## What's in the CRED Utils Blueprint:

See the `aos` [source code on GitHub](https://github.com/permaweb/aos/blob/main/blueprints/credUtils.lua)
for the blueprint shipped in the latest version of `aos`. -->

```lua
CRED_PROCESS = "Sa0iBLPNyJQrwpTTG-tWLQU-1QeUAJA73DdxGGiKoJc"

_CRED = { balance = "Your CRED balance has not been checked yet. Updating now." }

local credMeta = {
    __index = function(t, key)
        -- sends CRED balance request
        if key == "update" then
            Send({ Target = CRED_PROCESS, Action = "Balance", Tags = { Target = ao.id } })
            return "Balance update requested."
            -- prints local CRED balance, requests it if not set
        elseif key == "balance" then
            if _CRED.balance == "Your CRED balance has not been checked yet. Updating now." then
                Send({ Target = CRED_PROCESS, Action = "Balance", Tags = { Target = ao.id } })
            end
            return _CRED.balance
            -- prints CRED process ID
        elseif key == "process" then
            return CRED_PROCESS
            -- tranfers CRED
        elseif key == "send" then
            return function(target, amount)
                -- ensures amount is string
                amount = tostring(amount)
                print("sending " .. amount .. "CRED to " .. target)
                Send({ Target = CRED_PROCESS, Action = "Transfer", Recipient = target, Quantity = amount })
            end
        else
            return nil
        end
    end
}

CRED = setmetatable({}, credMeta)

-- Function to evaluate if a message is a balance update
local function isCredBalanceMessage(msg)
    if msg.From == CRED_PROCESS and msg.Tags.Balance then
        return true
    else
        return false
    end
end

-- Function to evaluate if a message is a Debit Notice
local function isDebitNotice(msg)
    if msg.From == CRED_PROCESS and msg.Tags.Action == "Debit-Notice" then
        return true
    else
        return false
    end
end

-- Function to evaluate if a message is a Credit Notice
local function isCreditNotice(msg)
    if msg.From == CRED_PROCESS and msg.Tags.Action == "Credit-Notice" then
        return true
    else
        return false
    end
end

local function formatBalance(balance)
    -- Ensure balance is treated as a string
    balance = tostring(balance)
    -- Check if balance length is more than 3 to avoid unnecessary formatting
    if #balance > 3 then
        -- Insert dot before the last three digits
        balance = balance:sub(1, -4) .. "." .. balance:sub(-3)
    end
    return balance
end

-- Handles Balance messages
Handlers.add(
    "UpdateCredBalance",
    isCredBalanceMessage,
    function(msg)
        local balance = nil
        if msg.Tags.Balance then
            balance = msg.Tags.Balance
        end
        -- Format the balance if it's not set
        if balance then
            -- Format the balance by inserting a dot after the first three digits from the right
            local formattedBalance = formatBalance(balance)
            _CRED.balance = formattedBalance
            print("CRED Balance updated: " .. _CRED.balance)
        else
            print("An error occurred while updating CRED balance")
        end
    end
)

-- Handles


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: cred-utils.md Path: ../ao-cookbook/src/ja/guides/aos/blueprints/cred-utils.md

Response:
 if balance length is more than 3 to avoid unnecessary formatting
    if #balance > 3 then
        -- Insert dot before the last three digits
        balance = balance:sub(1, -4) .. "." .. balance:sub(-3)
    end
    return balance
end

-- Handles Balance messages
Handlers.add(
    "UpdateCredBalance",
    isCredBalanceMessage,
    function(msg)
        local balance = nil
        if msg.Tags.Balance then
            balance = msg.Tags.Balance
        end
        -- Format the balance if it's not set
        if balance then
            -- Format the balance by inserting a dot after the first three digits from the right
            local formattedBalance = formatBalance(balance)
            _CRED.balance = formattedBalance
            print("CRED Balance updated: " .. _CRED.balance)
        else
            print("An error occurred while updating CRED balance")
        end
    end
)

-- Handles Debit notices
Handlers.add(
    "CRED_Debit",
    isDebitNotice,
    function(msg)
        print(msg.Data)
    end
)

-- Handles Credit notices
Handlers.add(
    "CRED_Credit",
    isCreditNotice,
    function(msg)
        print(msg.Data)
    end
)
```


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: voting.md Path: ../ao-cookbook/src/ja/guides/aos/blueprints/voting.md

Response:
# 投票ブループリント

投票ブループリントは、`ao`で迅速に投票システムを構築するための事前設計されたテンプレートです。これは、始めるのに最適な方法であり、ニーズに合わせてカスタマイズできます。

## 前提条件

投票ブループリントを使用するには、まず[トークンブループリント](./token.md)をロードする必要があります。

## 投票ブループリントの内容

- **バランス**: `Balances`配列は、参加者のトークンバランスを保存するために使用されます。

- **投票**: `Votes`配列は、参加者の投票を保存するために使用されます。

- **投票アクションハンドラー**: `vote`ハンドラーは、プロセスが投票できるようにします。プロセスが`Action = "Vote"`というタグのメッセージを送信すると、ハンドラーは投票を`Votes`配列に追加し、投票が確認されたことを示すメッセージをプロセスに返します。

- **最終化ハンドラー**: `finalize`ハンドラーは、プロセスが投票プロセスを最終化できるようにします。プロセスが`Action = "Finalize"`というタグのメッセージを送信すると、ハンドラーは投票を処理し、投票プロセスを最終化します。

### 使用方法:

1. 好みのテキストエディタを開きます。
2. ターミナルを開きます。
3. `aos`プロセスを開始します。
4. `.load-blueprint voting`と入力します。

### ブループリントがロードされたか確認する:

`Handlers.list`と入力して、新しくロードされたハンドラーを確認します。

## 投票ブループリントの内容:

<!-- # Voting Blueprint

The Voting Blueprint is a predesigned template that helps you quickly build a voting system in `ao`. It is a great way to get started and can be customized to fit your needs.

## Prerequisites

The Staking Blueprint requires the [Token Blueprint](./token.md) to be loaded, first.

## Unpacking the Voting Blueprint

- **Balances**: The `Balances` array is used to store the token balances of the participants.

- **Votes**: The `Votes` array is used to store the votes of the participants.

- **Vote Action Handler**: The `vote` handler allows processes to vote. When a process sends a message with the tag `Action = "Vote"`, the handler will add the vote to the `Votes` array and send a message back to the process confirming the vote.

- **Finalization Handler**: The `finalize` handler allows processes to finalize the voting process. When a process sends a message with the tag `Action = "Finalize"`, the handler will process the votes and finalize the voting process.

### How To Use:

1. Open your preferred text editor.
2. Open the Terminal.
3. Start your `aos` process.
4. Type in `.load-blueprint voting`

### Verify the Blueprint is Loaded:

Type in `Handlers.list` to see the newly loaded handlers.

## What's in the Voting Blueprint: -->

```lua
Balances = Balances or {}
Votes = Votes or {}

-- Vote Action Handler
Handlers.vote = function(msg)
  local quantity = Stakers[msg.From].amount
  local target = msg.Tags.Target
  local side = msg.Tags.Side
  local deadline = tonumber(msg['Block-Height']) + tonumber(msg.Tags.Deadline)
  assert(quantity > 0, "No staked tokens to vote")
  Votes[target] = Votes[target] or { yay = 0, nay = 0, deadline = deadline }
  Votes[target][side] = Votes[target][side] + quantity
end

-- Finalization Handler
local finalizationHandler = function(msg)
  local currentHeight = tonumber(msg['Block-Height'])
  -- Process voting
  for target, voteInfo in pairs(Votes) do
      if currentHeight >= voteInfo.deadline then
          if voteInfo.yay > voteInfo.nay then
              print("Handle Vote")
          end
          -- Clear the vote record after processing
          Votes[target] = nil
      end
  end
end

-- wrap function to continue handler flow
local function continue(fn)
  return function (msg)
    local result = fn(msg)
    if (result) == -1 then
      return 1
    end
    return result
  end
end

Handlers.add("vote",
  continue(Handlers.utils.hasMatchingTag("Action", "Vote")), Handlers.vote)
-- Finalization handler should be called for every message
Handlers.add("finalize", function (msg) return -1 end, finalizationHandler)
```


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: staking.md Path: ../ao-cookbook/src/ja/guides/aos/blueprints/staking.md

Response:
# ステーキングブループリント

ステーキングブループリントは、`ao`でステーキングシステムを迅速に構築するための事前設計されたテンプレートです。これは、始めるのに最適な方法であり、ニーズに合わせてカスタマイズできます。

## 前提条件

ステーキングブループリントを使用するには、最初に[トークンブループリント](./token.md)をロードする必要があります。

## ステーキングブループリントの内容

- **ステーカー**: `Stakers`配列は、参加者のステークされたトークンを保存するために使用されます。

- **アンステーキング**: `Unstaking`配列は、参加者のアンステーキングリクエストを保存するために使用されます。

- **ステークアクションハンドラー**: `stake`ハンドラーは、プロセスがトークンをステークできるようにします。プロセスがタグ`Action = "Stake"`のメッセージを送信すると、ハンドラーはステークされたトークンを`Stakers`配列に追加し、ステーキングを確認するメッセージをプロセスに返します。

- **アンステークアクションハンドラー**: `unstake`ハンドラーは、プロセスがトークンをアンステークできるようにします。プロセスがタグ`Action = "Unstake"`のメッセージを送信すると、ハンドラーはアンステーキングリクエストを`Unstaking`配列に追加し、アンステーキングを確認するメッセージをプロセスに返します。

- **最終化ハンドラー**: `finalize`ハンドラーは、プロセスがステーキングプロセスを最終化できるようにします。プロセスがタグ`Action = "Finalize"`のメッセージを送信すると、ハンドラーはアンステーキングリクエストを処理し、ステーキングプロセスを最終化します。

### 使用方法:

1. 好みのテキストエディタを開きます。
2. ターミナルを開きます。
3. `aos`プロセスを開始します。
4. `.load-blueprint staking`と入力します。

### ブループリントがロードされたか確認する:

`Handlers.list`と入力して、新しくロードされたハンドラーを確認します。

## ステーキングブループリントの内容:

<!-- # Staking Blueprint

The Staking Blueprint is a predesigned template that helps you quickly build a staking system in `ao`. It is a great way to get started and can be customized to fit your needs.

## Prerequisites

The Staking Blueprint requires the [Token Blueprint](./token.md) to be loaded, first.

## Unpacking the Staking Blueprint

- **Stakers**: The `Stakers` array is used to store the staked tokens of the participants.

- **Unstaking**: The `Unstaking` array is used to store the unstaking requests of the participants.

- **Stake Action Handler**: The `stake` handler allows processes to stake tokens. When a process sends a message with the tag `Action = "Stake"`, the handler will add the staked tokens to the `Stakers` array and send a message back to the process confirming the staking.

- **Unstake Action Handler**: The `unstake` handler allows processes to unstake tokens. When a process sends a message with the tag `Action = "Unstake"`, the handler will add the unstaking request to the `Unstaking` array and send a message back to the process confirming the unstaking.

- **Finalization Handler**: The `finalize` handler allows processes to finalize the staking process. When a process sends a message with the tag `Action = "Finalize"`, the handler will process the unstaking requests and finalize the staking process.

### How To Use:

1. Open your preferred text editor.
2. Open the Terminal.
3. Start your `aos` process.
4. Type in `.load-blueprint staking`

### Verify the Blueprint is Loaded:

Type in `Handlers.list` to see the newly loaded handlers.

## What's in the Staking Blueprint: -->

```lua
Stakers = Stakers or {}
Unstaking = Unstaking or {}

-- Stake Action Handler
Handlers.stake = function(msg)
  local quantity = tonumber(msg.Tags.Quantity)
  local delay = tonumber(msg.Tags.UnstakeDelay)
  local height = tonumber(msg['Block-Height'])
  assert(Balances[msg.From] and Balances[msg.From] >= quantity, "Insufficient balance to stake")
  Balances[msg.From] = Balances[msg.From] - quantity
  Stakers[msg.From] = Stakers[msg.From] or {}
  Stakers[msg.From].amount = (Stakers[msg.From].amount or 0) + quantity
  Stakers[msg.From].unstake_at = height + delay
end

-- Unstake Action Handler
Handlers.unstake = function(msg)
  local quantity = tonumber(msg.Tags.Quantity)
  local stakerInfo = Stakers[msg.From]
  assert(stakerInfo and stakerInfo.amount >= quantity, "Insufficient staked amount")
  stakerInfo.amount = stakerInfo.amount - quantity
  Unstaking[msg.From] = {
      amount = quantity,
      release_at = stakerInfo.unstake_at
  }
end

-- Finalization Handler
local finalizationHandler = function(msg)
  local currentHeight = tonumber(msg['Block-Height'])
  -- Process unstaking
  for address, unstakeInfo in pairs(Unstaking) do
      if currentHeight >= unstakeInfo.release_at then
          Balances[address] = (Balances[address] or 0) + unstakeInfo.amount
          Unstaking[address] = nil
      end
  end

end

-- wrap function to continue handler flow
local function continue(fn)
  return function (msg)
    local result = fn(msg)
    if (result) == -1 then
      return 1
    end
    return result
  end
end

-- Registering Handlers
Handlers.add("stake",
  continue(Handlers.utils.hasMatchingTag("Action", "Stake")), Handlers.stake)
Handlers.add("unstake",
  continue(Handlers.utils.hasMatchingTag("Action", "Unstake")), Handlers.unstake)
-- Finalization handler should be called for every message
Handlers.add("finalize", function (msg) return -1 end, finalizationHandler)
```


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: json.md Path: ../ao-cookbook/src/ja/guides/aos/modules/json.md

Response:
# JSON

JSONモジュールは、JavaScript Object Notationを使用してオブジェクトのエンコードとデコードを可能にします。

### Example usage

```lua
local json = require("json")

json.encode({
  a_string = "This is a string",
  nums = { 1, 2, 3 }
})
```

<!-- ## Module functions

### `encode()`

This function returns a string representation of a Lua object in JSON.

- **Parameters:**
  - `val`: `{any}` The object to format as JSON
- **Returns:** JSON string representation of the provided object -->

## Module functions

### `encode()`

この関数は、LuaオブジェクトのJSON文字列表現を返します。

- **Parameters:**
  - `val`: `{any}` JSONとしてフォーマットするオブジェクト
- **Returns:** 提供されたオブジェクトのJSON文字列表現

#### Example

```lua
--[[
  prints:
  "[{"name":"John Doe","age":23},{"name":"Bruce Wayne",age:34}]"
]]--
print(json.encode({
  { name = "John Doe", age = 23 },
  { name = "Bruce Wayne", age = 34 }
}))

-- prints "false"
print(json.encode(false))
```

<!-- ### `decode()`

The function takes a JSON string and turns it into a Lua object.

- **Parameters:**
  - `val`: `{any}` The JSON string to decode
- **Returns:** Lua object corresponding to the JSON string (throws an error for invalid JSON strings) -->

### `decode()`

この関数は、JSON文字列を受け取り、それをLuaオブジェクトに変換します。

- **Parameters:**
  - `val`: `{any}` デコードするJSON文字列
- **Returns:** JSON文字列に対応するLuaオブジェクト（無効なJSON文字列の場合はエラーをスローします）

#### Example

```lua
--[[
  creates the following table:
  { hello = "world" }
]]--
json.decode('{ "hello": "world" }')

-- creates a boolean with true value
json.decode("true")
```


Prompt:
This is a Markdown documentation from the AO documentation repository. Filename: utils.md Path: ../ao-cookbook/src/ja/guides/aos/modules/utils.md
Note: This content continues in the next part.

Response:
# Utils

汎用のテーブル操作と検証のためのユーティリティライブラリです。カリー形式と従来のプログラミングの両方をサポートしています。

> **Note**: 次の関数に提供される入力が期待されるタイプと一致していることを確認することが重要です。

<!-- # Utils

A utility library for generic table manipulation and validation. It supports both curry-styled and traditional programming.

> **Note**: It is important to verify that the inputs provided to the following functions match the expected types. -->

### Example usage

```lua
local utils = require(".utils")

local totalSupply = utils.reduce(
  function (acc, v) return acc + v end,
  0,
  { 2, 4, 9 }
)

print(totalSupply) -- prints 15
```

## Module functions

### `concat()`

この関数は配列 `b` を配列 `a` に連結します。

- **Parameters:**
  - `a`: `{table}` 基本配列
  - `b`: `{table}` 基本配列に連結する配列
- **Returns:** `a` と `b` の統合された配列

<!-- ## Module functions

### `concat()`

This function concatenates array `b` to array `a`.

- **Parameters:**
  - `a`: `{table}` The base array
  - `b`: `{table}` The array to concat to the base array
- **Returns:** An unified array of `a` and `b` -->

#### Examples

```lua
-- returns { 1, 2, 3, 4, 5, 6 }
concat({ 1, 2, 3 })({ 4, 5, 6 })

-- returns { "hello", "world", "and", "you" }
concat({ "hello", "world" }, { "and", "you" })
```

<!--
### `reduce()`

This function executes the provided reducer function for all array elements, finally providing one (unified) result.

- **Parameters:**
  - `fn`: `{function}` The reducer function. It receives the previous result, the current element's value and key in this order
  - `initial`: `{any}` An optional initial value
  - `t`: `{table}` The array to reduce
- **Returns:** A single result from running the reducer across all table elements -->

### `reduce()`

この関数は、すべての配列要素に対して提供されたリデューサ関数を実行し、最終的に1つの（統合された）結果を提供します。

- **Parameters:**
  - `fn`: `{function}` リデューサ関数。前の結果、現在の要素の値、およびキーをこの順序で受け取ります。
  - `initial`: `{any}` オプションの初期値
  - `t`: `{table}` 簡略化する配列
- **Returns:** すべてのテーブル要素に対してリデューサを実行した結果としての単一の結果

#### Examples

```lua
local sum = utils.reduce(
  function (acc, v) return acc + v end,
  0,
  { 1, 2, 3 }
)

print(sum) -- prints 6
```

```lua
local sum = utils
  .reduce(function (acc, v) return acc + v end)(0)({ 5, 4, 3 })

print(sum) -- prints 12
```

<!--
### `map()`

This function creates a new array filled with the results of calling the provided map function on each element in the provided array.

- **Parameters:**
  - `fn`: `{function}` The map function. It receives the current array element and key
  - `data`: `{table}` The array to map
- **Returns:** A new array composed of the results of the map function -->

### `map()`

この関数は、提供された配列内の各要素に対して提供されたマップ関数を呼び出した結果で満たされた新しい配列を作成します。

- **Parameters:**
  - `fn`: `{function}` マップ関数。現在の配列要素とキーを受け取ります。
  - `data`: `{table}` マッピングする配列
- **Returns:** マップ関数の結果で構成された新しい配列

#### Examples

```lua
-- returns { "Odd", "Even", "Odd" }
utils.map(
  function (val, key)
    return (val % 2 == 0 and "Even") or "Odd"
  end,
  { 3, 4, 7 }
)
```

```lua
-- returns { 4, 8, 12 }
utils.map(function (val, key) return val * 2 end)({ 2, 4, 6 })
```

<!--
### `filter()`

This function creates a new array from a portion of the original, only keeping the elements that passed a provided filter function's test.

- **Parameters:**
  - `fn`: `{function}` The filter function. It receives the current array element and should return a boolean, deciding whether the element should be kept (`true`) or filtered out (`false`)
  - `data`: `{table}` The array to filter
- **Returns:** The new filtered array -->

### `filter()`

この関数は、元の配列の一部から新しい配列を作成し、提供されたフィルタ関数のテストに合格した要素のみを保持します。

- **Parameters:**
  - `fn`: `{function}` フィルタ関数。現在の配列要素を受け取り、要素を保持するか（`true`）フィルタリングするか（`false`）を決定するためにブール値を返す必要があります。
  - `data`: `{table}` フィルタリングする配列
- **Returns:** 新しいフィルタリングされた配列

#### Examples

```lua
-- keeps even numbers
utils.filter(
  function (val) return val % 2 == 0 end,
  { 3, 4, 7 }
)
```

```lua
-- keeps only numbers
utils.filter(
  function (val) return type(val) == "number" end,
  { "hello", "world", 13, 44 }
)
```

<!--
### `find()`

This function returns the first element that matches in a provided function.

- **Parameters:**
  - `fn`: `{function}` The find function that receives the current element and returns `true` if it matches, `false` if it doesn't
  - `t`: `{table}` The array to find an element in
- **Returns:** The found element or `nil` if no element matched -->

### `find()`

この関数は、提供された関数で一致する最初の要素を返します。

- **Parameters:**
  - `fn`: `{function}` 現在の要素を受け取り、一致する場合は`true`、一致しない場合は`false`を返すfind関数。
  - `t`: `{table}` 要素を検索する配列
- **Returns:** 見つかった要素、または一致する要素がない場合は`nil`

#### Examples

```lua
local users = {
  { name = "John", age = 50 },
  { name = "Victor", age = 37 },
  { name = "Maria", age = 33 }
}

-- returns the user "John"
utils.find(
  function (val) return user.name == "John" end,
  users
)
```

```lua
-- returns the user "Maria"
utils.find(function (val) return user.age == 33 end)(users)
```

<!--
### `reverse()`

Transforms an array into reverse order.

- **Parameters:**
  - `data`: `{table}` The array to reverse
- **Returns:** The original array in reverse order -->

### `reverse()`

配列を逆順に変換します。

- **Parameters:**
  - `data`: `{table}` 逆順にする配列
- **Returns:** 元の配列を逆順にしたもの

#### Example

```lua
-- is: { 3, 2, 1 }
utils.reverse({ 1, 2, 3 })
```

<!--
### `includes()`

Determinates whether a value


Prompt: This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: utils.md Path: ../ao-cookbook/src/ja/guides/aos/modules/utils.md

Response:
 the user "John"
utils.find(
  function (val) return user.name == "John" end,
  users
)
```

```lua
-- returns the user "Maria"
utils.find(function (val) return user.age == 33 end)(users)
```

<!--
### `reverse()`

Transforms an array into reverse order.

- **Parameters:**
  - `data`: `{table}` The array to reverse
- **Returns:** The original array in reverse order -->

### `reverse()`

配列を逆順に変換します。

- **Parameters:**
  - `data`: `{table}` 逆順にする配列
- **Returns:** 元の配列を逆順にしたもの

#### Example

```lua
-- is: { 3, 2, 1 }
utils.reverse({ 1, 2, 3 })
```

<!--
### `includes()`

Determinates whether a value is part of an array.

- **Parameters:**
  - `val`: `{any}` The element to check for
  - `t`: `{table}` The array to check in
- **Returns:** A boolean indicating whether or not the provided value is part of the array -->

### `includes()`

配列に値が含まれているかどうかを判定します。

- **Parameters:**
  - `val`: `{any}` 確認する要素
  - `t`: `{table}` 確認する配列
- **Returns:** 提供された値が配列に含まれているかどうかを示すブール値

#### Examples

```lua
-- this is true
utils.includes("John", { "Victor", "John", "Maria" })
```

```lua
-- this is false
utils.includes(4)({ 3, 5, 7 })
```

<!--
### `keys()`

Returns the keys of a table.

- **Parameters:**
  - `table`: `{table}` The table to get the keys for
- **Returns:** An array of keys -->

### `keys()`

テーブルのキーを返します。

- **Parameters:**
  - `table`: `{table}` キーを取得するテーブル
- **Returns:** キーの配列

#### Example

```lua
-- returns { "hello", "name" }
utils.keys({ hello = "world", name = "John" })
```

<!--
### `values()`

Returns the values of a table.

- **Parameters:**
  - `table`: `{table}` The table to get the values for
- **Returns:** An array of values -->

### `values()`

テーブルの値を返します。

- **Parameters:**
  - `table`: `{table}` 値を取得するテーブル
- **Returns:** 値の配列

#### Example

```lua
-- returns { "world", "John" }
utils.values({ hello = "world", name = "John" })
```

<!--
### `propEq()`

Checks if a specified property of a table equals with the provided value.

- **Parameters:**
  - `propName`: `{string}` The name of the property to compare
  - `value`: `{any}` The value to compare to
  - `object`: `{table}` The object to select the property from
- **Returns:** A boolean indicating whether the property value equals with the provided value or not -->

### `propEq()`

テーブルの指定されたプロパティが提供された値と等しいかどうかをチェックします。

- **Parameters:**
  - `propName`: `{string}` 比較するプロパティの名前
  - `value`: `{any}` 比較する値
  - `object`: `{table}` プロパティを選択するオブジェクト
- **Returns:** 提供された値とプロパティの値が等しいかどうかを示すブール値

#### Examples

```lua
local user = { name = "John", age = 50 }

-- returns true
utils.propEq("age", 50, user)
```

```lua
local user = { name = "Maria", age = 33 }

-- returns false
utils.propEq("age", 45, user)
```

<!--
### `prop()`

Returns the property value that belongs to the property name provided from an object.

- **Parameters:**
  - `propName`: `{string}` The name of the property to get
  - `object`: `{table}` The object to select the property value from
- **Returns:** The property value or `nil` if it was not found -->

### `prop()`

指定されたプロパティ名に属するプロパティの値をオブジェクトから返します。

- **Parameters:**
  - `propName`: `{string}` 取得するプロパティの名前
  - `object`: `{table}` プロパティ値を選択するオブジェクト
- **Returns:** プロパティの値、または見つからなかった場合は `nil`

#### Examples

```lua
local user = { name = "Maria", age = 33 }

-- returns "Maria"
utils.prop("name", user)
```

```lua
local user = { name = "John", age = 50 }

-- returns 50
utils.prop("age")(user)
```

<!--
### `compose()`

This function allows you to chain multiple array mutations together and execute them in reverse order on the provided array.

- **Parameters:**
  - `...`: `{function[]}` The array mutations
  - `v`: `{table}` The object to execute the provided functions on
- **Returns:** The result from the provided mutations -->

### `compose()`

この関数は、複数の配列の変異を連鎖させ、提供された配列に対して逆の順序で実行することを可能にします。

- **Parameters:**
  - `...`: `{function[]}` 配列の変異
  - `v`: `{table}` 提供された関数を実行するオブジェクト
- **Returns:** 提供された変異からの結果

#### Examples

```lua
-- returns 12
utils.compose(
  utils.reduce(function (acc, val) return acc + val end, 0),
  utils.map(function (val) return val * 2 end)
)({ 1, 2, 3 })
```


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: ao.md Path: ../ao-cookbook/src/ja/guides/aos/modules/ao.md

Response:
<!-- # ao

Built in global library for sending messages, spawning processes, etc.

### Example usage

The global `ao` object is accessible anywhere in your process: -->

# ao

グローバルライブラリは、メッセージの送信、プロセスの生成などに使用されます。

### 使用例

グローバル `ao` オブジェクトは、プロセス内のどこからでもアクセス可能です：

```lua
-- sends a message to another process ("Transfer" action)
ao.send({
  Target = "usjm4PCxUd5mtaon7zc97-dt-3qf67yPyqgzLnLqk5A",
  Action = "Transfer",
  Recipient = "XjvCPN31XCLPkBo9bUeB7vAK0VC6-eY52-CS-6Iho8F",
  Quantity = tostring(1045)
})
```

## モジュール変数

- `ao.id`: `{string}` プロセスの Arweave ID を保持します。
- `ao.authorities`: `{table}` 任意の信頼できる呼び出し元の配列です。
- `ao._module`: `{string}` 各呼び出し時に実行されるプロセスの WASM ベースモジュールです。
- `ao._ref`: `{number}` 一回の呼び出しインスタンスで送信されたメッセージのカウンターです。
- `ao._version`: `{string}` ao グローバルライブラリのバージョンです。
- `ao.env`: `{table}` 初期化メッセージからのプロセス環境です。

### `ao.env`

`ao.env` グローバル変数は、プロセスの初期化メッセージに関する情報を保持します。以下のスキーマに従います：

<!-- ## Module variables

- `ao.id`: `{string}` Holds the Arweave ID of your process
- `ao.authorities`: `{table}` An array of optionally trusted callers
- `ao._module`: `{string}` The WASM base module of the process that is executed on each call
- `ao._ref`: `{number}` The counter of the messages sent out in one call instance
- `ao._version`: `{string}` The ao global library version
- `ao.env`: `{table}` The process environment from the initializing message

### `ao.env`

The `ao.env` global variable holds informationg about the initializing message of the process. It follows the schema below:
-->

```json
{
  "type": "object",
  "properties": {
    "Process": {
      "type": "object",
      "properties": {
        "Id": {
          "type": "string",
          "example": "A1b2C3d4E5f6G7h8I9j0K1L2M3N4O5P6Q7R8S9T0"
        },
        "Owner": {
          "type": "string",
          "example": "Xy9PqW3vR5sT8uB1nM6dK0gF2hL4jC7iE9rV3wX5"
        },
        "TagArray": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "name": {
                "type": "string",
                "example": "App-Name"
              },
              "value": {
                "type": "string",
                "example": "aos"
              }
            }
          },
          "example": [{ "name": "App-Name", "value": "aos" }]
        },
        "Tags": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "patternProperties": {
            "": {
              "type": "string"
            }
          },
          "example": {
            "App-Name": "aos"
          }
        }
      }
    }
  }
}
```

<!--
## Module functions

### `log()`

Appends the provided value/message to the `Results.Output` table which can later be read using the [`aoconnect`](/guides/aoconnect/aoconnect.html) library. Useful for debugging as well as returning an output value to a caller.

- **Parameters:**
  - `txt`: `{any}` The value/message to be appended to the output table
- **Returns:** `{void}` -->

## モジュール関数

### `log()`

提供された値/メッセージを `Results.Output` テーブルに追加します。これは後で [`aoconnect`](/guides/aoconnect/aoconnect.html) ライブラリを使用して読み取ることができます。デバッグや呼び出し元への出力値の返却に便利です。

- **パラメータ:**
  - `txt`: `{any}` 出力テーブルに追加される値/メッセージ
- **戻り値:** `{void}`

#### Examples

```lua
...
ao.log("Breakpoint reached")
...
ao.log({
  Message = "Transferred " .. quantity .. " tokens to " .. target,
  Quantity = quantity,
  Recipient = target
})
```

### `send()`

<!--
Sends a message to another process by inserting the provided message item into the process' outbox along with the _ao specs compliant_ message tags.

- **Parameters:**
  - `msg`: `{table}` The message to be sent
- **Returns:** The sent message item with the applied tags and `DataItem` fields.

> **Note:** Each field of the `msg` table will be appended as a `DataItem` tag, except the following: `"Target"`, `"Data"`, `"Anchor"`, `"Tags"`. These fields are interpreted as root level `DataItem` fields. -->

他のプロセスにメッセージを送信し、提供されたメッセージアイテムをプロセスのアウトボックスに挿入します。この際、_ao スペックに準拠した_ メッセージタグも付加されます。

- **パラメータ:**
  - `msg`: `{table}` 送信されるメッセージ
- **戻り値:** 適用されたタグと `DataItem` フィールドを持つ送信メッセージアイテム。

> **注:** `msg` テーブルの各フィールドは `DataItem` タグとして追加されますが、次のフィールドは例外です: `"Target"`, `"Data"`, `"Anchor"`, `"Tags"`。これらのフィールドはルートレベルの `DataItem` フィールドとして解釈されます。

#### Example

```lua
-- sends a message to "XjvCPN31XCLPkBo9bUeB7vAK0VC6-eY52-CS-6Iho8F"
-- with the tag { "name": "Action", "value": "Ping" }
ao.send({
  Target = "XjvCPN31XCLPkBo9bUeB7vAK0VC6-eY52-CS-6Iho8F",
  Action = "Ping"
})
```

### `spawn()`

<!--
Allows spawning a new process, from within another process.

- **Parameters:**
  - `module`: `{string}` Arweave transaction ID of the module used by the new process
  - `msg`: `{table}` The message that initializes the process, with the format described [above](#send)
- **Returns:** The initializing message item -->

別のプロセスから新しいプロセスを生成することを可能にします。

- **パラメータ:**
  - `module`: `{string}` 新しいプロセスで使用されるモジュールの Arweave トランザクション ID
  - `msg`: `{table}` プロセスを初期化するメッセージ。形式は [上記](#send) の説明に従います。
- **戻り値:** 初期化メッセージアイテム

#### Example

```lua
ao.spawn("n0BFH80b73mi9VAWUzyuG9gEC3LI2zU2BFxum0N8A9s", {
  ["Custom-Tag"]: "Custom-Value"
})
```


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: index.md Path: ../ao-cookbook/src/ja/guides/aos/modules/index.md

Response:
---
prev:
  text: "Staking Blueprint"
  link: "../blueprints/staking"
next:
  text: "JSON"
  link: "./json"
---

# モジュール

aosのすべての組み込みモジュールに関するドキュメントです。

## 利用可能なモジュール

- [JSON](json)
- [ao](ao)
- [crypto](crypto)
- [Base64](base64)
- [pretty](pretty)
- [Utils](utils)


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: pretty.md Path: ../ao-cookbook/src/ja/guides/aos/modules/pretty.md

Response:
# Pretty

このモジュールは、フォーマットされた人間に優しく、読みやすい構文を印刷することを可能にします。

## モジュール関数

### `tprint()`

提供されたテーブルの構造のフォーマットされた文字列を返します。

- **パラメータ:**
  - `tbl`: `{table}` フォーマットするテーブル
  - `indent`: `{number}` 各レベルのテーブルのオプションのインデント
- **戻り値:** フォーマットされたテーブル構造の文字列

#### Examples

```lua
local pretty = require(".pretty")

local formatted = pretty.tprint({
  name = "John Doe",
  age = 22,
  friends = { "Maria", "Victor" }
}, 2)

-- prints the formatted table structure
print(formatted)
```


Prompt: This is a Markdown documentation from the AO documentation repository. Filename: base64.md Path: ../ao-cookbook/src/ja/guides/aos/modules/base64.md

Response:
# Base64

<!--
A small `base64` module to encode or decode base64 text.

> **Note:** It is recommended to enable caching for large chunks of texts for up to x2 optimization. -->

小さな `base64` モジュールで、base64 テキストをエンコードまたはデコードします。

> **注意:** 大きなテキストチャンクに対してキャッシングを有効にすることをお勧めします。最大で x2 の最適化が可能です。

### Example usage

```lua
local base64 = require(".base64")

local str = "This will be encoded"

-- is: "VGhpcyB3aWxsIGJlIGVuY29kZWQ="
local encoded = base64.encode(str)

-- is: "This will be encoded"
local decoded = base64.decode(encoded)

assert(decoded == str)
```

## Module functions

### `encode()`

<!--
This function encodes the provided string using the default encoder table. The encoder can be customized and a cache is available for larger chunks of data.

- **Parameters:**
  - `str`: `{string}` The string to encode
  - `encoder`: `{table}` Optional custom encoding table
  - `usecache`: `{boolean}` Optional cache for large strings (turned off by default)
- **Returns:** Base64 encoded string -->

この関数は、提供された文字列をデフォルトのエンコーダーテーブルを使用してエンコードします。エンコーダーはカスタマイズ可能で、より大きなデータチャンクに対してキャッシュが利用可能です。

- **パラメーター:**
  - `str`: `{string}` エンコードする文字列
  - `encoder`: `{table}` オプションのカスタムエンコーディングテーブル
  - `usecache`: `{boolean}` 大きな文字列用のオプションのキャッシュ（デフォルトではオフ）
- **戻り値:** Base64 エンコードされた文字列

#### Examples

```lua
-- prints: "SGVsbG8gd29ybGQ="
print(base64.encode("Hello world"))

-- customize encoder and allow caching
base64.encode(
  "Hello world",
  base64.makeencoder(nil, "-"),
  true
)
```

### `decode()`

<!-- This function decodes the provided base64 encoded string using the default decoder table. The decoder can be customized and a cache is also available here.

- **Parameters:**
  - `str`: `{string}` The base64 encoded string to decode
  - `decoder`: `{table}` Optional custom decoding table
  - `usecache`: `{boolean}` Optional cache for large strings (turned off by default)
- **Returns:** Decoded string -->

この関数は、提供された Base64 エンコードされた文字列をデフォルトのデコーダーテーブルを使用してデコードします。デコーダーはカスタマイズ可能で、ここでもキャッシュが利用可能です。

- **パラメーター:**
  - `str`: `{string}` デコードする Base64 エンコードされた文字列
  - `decoder`: `{table}` オプションのカスタムデコーディングテーブル
  - `usecache`: `{boolean}` 大きな文字列用のオプションのキャッシュ（デフォルトではオフ）
- **戻り値:** デコードされた文字列

#### Examples

```lua
-- prints: "Hello world"
print(base64.decode("SGVsbG8gd29ybGQ="))

-- customize decoder and allow caching
base64.decode(
  "SGVsbG8gd29ybGQ=",
  base64.makedecoder(nil, "-"),
  true
)
```

### `makeencoder()`

<!--
Allows creating a new encoder table to customize the [`encode()`](#encode) function's result.

- **Parameters:**
  - `s62`: `{string}` Optional custom char for 62 (`+` by default)
  - `s63`: `{string}` Optional custom char for 63 (`/` by default)
  - `spad`: `{string}` Optional custom padding char (`=` by default)
- **Returns:** Custom encoder table -->

新しいエンコーダーテーブルを作成し、[`encode()`](#encode) 関数の結果をカスタマイズします。

- **パラメーター:**
  - `s62`: `{string}` オプションのカスタム文字 (デフォルトは `+`)
  - `s63`: `{string}` オプションのカスタム文字 (デフォルトは `/`)
  - `spad`: `{string}` オプションのカスタムパディング文字 (デフォルトは `=`)
- **戻り値:** カスタムエンコーダーテーブル

#### Examples

```lua
-- create custom encoder
local encoder = base64.makeencoder(nil, nil, "~")

-- prints "SGVsbG8gd29ybGQ~" instead of "SGVsbG8gd29ybGQ="
print(base64.encode("Hello world", encoder))
```

### `makedecoder()`

<!--
Allows creating a new decoder table to be able to decode [custom-encoded](#makeencoder) base64 strings.

- **Parameters:**
  - `s62`: `{string}` Optional custom char for 62 (`+` by default)
  - `s63`: `{string}` Optional custom char for 63 (`/` by default)
  - `spad`: `{string}` Optional custom padding char (`=` by default)
- **Returns:** Custom decoder table -->

カスタムエンコードされた [custom-encoded](#makeencoder) base64 文字列をデコードできる新しいデコーダーテーブルを作成します。

- **パラメーター:**
  - `s62`: `{string}` オプションのカスタム文字 (デフォルトは `+`)
  - `s63`: `{string}` オプションのカスタム文字 (デフォルトは `/`)
  - `spad`: `{string}` オプションのカスタムパディング文字 (デフォルトは `=`)
- **戻り値:** カスタムデコーダーテーブル

#### Examples

```lua
local encoder = base64.makeencoder(nil, nil, "~")
local decoder = base64.makedecoder(nil, nil, "~")

-- "SGVsbG8gd29ybGQ~"
local encoded = base64.encode("Hello world", encoder)

-- prints "Hello world"
print(base64.decode(encoded, decoder))
```


Prompt:
This is a Markdown documentation from the AO documentation repository. Filename: crypto.md Path: ../ao-cookbook/src/ja/guides/aos/modules/crypto.md
Note: This content continues in the next part.

Response:
# crypto

## 概要

`crypto` モジュールは、純粋な Lua で実装されたハッシュ、暗号化、復号化などの暗号化プリミティブのセットを提供します。データをハッシュ、暗号化、復号化するためのいくつかの機能を提供し、安全な通信とデータストレージの開発を簡素化します。このドキュメントでは、モジュールの機能、インストール、および使用方法について説明します。

<!-- # crypto

## Overview

The `crypto` module provides a set of cryptographic primitives like digests, ciphers and other cryptographic algorithms in pure Lua. It offers several functionalities to hash, encrypt and decrypt data, simplifying the development of secure communication and data storage. This document will guide you through the module's functionalities, installation, and usage.
-->

## Usage

```lua
local crypto = require(".crypto");
```

## プリミティブ

1. ダイジェスト (sha1, sha2, sha3, keccak, blake2b など)
2. サイファー (AES, ISSAC, Morus, NORX など)
3. ランダム数生成器 (ISAAC)
4. MAC (HMAC)
5. KDF (PBKDF2)
6. ユーティリティ (Array, Stream, Queue など)

---

# ダイジェスト

## MD2

与えられたメッセージの MD2 ダイジェストを計算します。

- **パラメータ:**

  - `stream` (Stream): ストリーム形式のメッセージ

- **戻り値:** 異なる形式でダイジェストを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式のダイジェスト。
  - `asHex()`: 16進形式の文字列としてのダイジェスト。
  - `asString()`: 文字列形式のダイジェスト。

<!--
## Primitives

1. Digests (sha1, sha2, sha3, keccak, blake2b, etc.)
2. Ciphers (AES, ISSAC, Morus, NORX, etc.)
3. Random Number Generators (ISAAC)
4. MACs (HMAC)
5. KDFs (PBKDF2)
6. Utilities (Array, Stream, Queue, etc.)

---

# Digests

## MD2

Calculates the MD2 digest of a given message.

- **Parameters:**

  - `stream` (Stream): The message in form of stream

- **Returns:** A table containing functions to get digest in different formats.
  - `asBytes()`: The digest as byte table.
  - `asHex()`: The digest as string in hexadecimal format.
  - `asString()`: The digest as string format.
-->

Example:

```lua
local str = crypto.utils.stream.fromString("ao")

return crypto.digest.md2(str).asHex() -- 0d4e80edd07bee6c7965b21b25a9b1ea
```

## MD4

与えられたメッセージの MD4 ダイジェストを計算します。

- **パラメータ:**

  - `stream` (Stream): ストリーム形式のメッセージ

- **戻り値:** 異なる形式でダイジェストを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式のダイジェスト。
  - `asHex()`: 16進形式の文字列としてのダイジェスト。
  - `asString()`: 文字列形式のダイジェスト。

<!--
Calculates the MD4 digest of a given message.

- **Parameters:**

  - `stream` (Stream): The message in form of stream

- **Returns:** A table containing functions to get digest in different formats.
  - `asBytes()`: The digest as byte table.
  - `asHex()`: The digest as string in hexadecimal format.
  - `asString()`: The digest as string format.
-->

Example:

```lua
local str = crypto.utils.stream.fromString("ao")

return crypto.digest.md4(str).asHex() -- e068dfe3d8cb95311b58be566db66954
```

## MD5

与えられたメッセージの MD5 ダイジェストを計算します。

- **パラメータ:**

  - `stream` (Stream): ストリーム形式のメッセージ

- **戻り値:** 異なる形式でダイジェストを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式のダイジェスト。
  - `asHex()`: 16進形式の文字列としてのダイジェスト。
  - `asString()`: 文字列形式のダイジェスト。

<!-- ## MD5

Calculates the MD5 digest of a given message.

- **Parameters:**

  - `stream` (Stream): The message in form of stream

- **Returns:** A table containing functions to get digest in different formats.
  - `asBytes()`: The digest as byte table.
  - `asHex()`: The digest as string in hexadecimal format.
  - `asString()`: The digest as string format.
-->

Example:

```lua
local str = crypto.utils.stream.fromString("ao")

return crypto.digest.md5(str).asHex() -- adac5e63f80f8629e9573527b25891d3
```

## SHA1

与えられたメッセージの SHA1 ダイジェストを計算します。

- **パラメータ:**

  - `stream` (Stream): ストリーム形式のメッセージ

- **戻り値:** 異なる形式でダイジェストを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式のダイジェスト。
  - `asHex()`: 16進形式の文字列としてのダイジェスト。
  - `asString()`: 文字列形式のダイジェスト。

<!-- ## SHA1

Calculates the SHA1 digest of a given message.

- **Parameters:**

  - `stream` (Stream): The message in form of stream

- **Returns:** A table containing functions to get digest in different formats.
  - `asBytes()`: The digest as byte table.
  - `asHex()`: The digest as string in hexadecimal format.
  - `asString()`: The digest as string format.
-->

Example:

```lua
local str = crypto.utils.stream.fromString("ao")

return crypto.digest.sha1(str).asHex() -- c29dd6c83b67a1d6d3b28588a1f068b68689aa1d
```

## SHA2_256

与えられたメッセージの SHA2-256 ダイジェストを計算します。

- **パラメータ:**
  - `stream` (Stream): ストリーム形式のメッセージ
- **戻り値:** 異なる形式でダイジェストを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式のダイジェスト。
  - `asHex()`: 16進形式の文字列としてのダイジェスト。
  - `asString()`: 文字列形式のダイジェスト。

<!-- ## SHA2_256

Calculates the SHA2-256 digest of a given message.

- **Parameters:**
  - `stream` (Stream): The message in form of stream
- **Returns:** A table containing functions to get digest in different formats.
  - `asBytes()`: The digest as byte table.
  - `asHex()`: The digest as string in hexadecimal format.
  - `asString()`: The digest as string format.
-->

Example:

```lua
local str = crypto.utils.stream.fromString("ao")

return crypto.digest.sha2_256(str).asHex() -- ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
```

## SHA2_512

与えられたメッセージの SHA2-512 ダイジェストを計算します。

- **パラメータ:**
  - `msg`


Prompt:
This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: crypto.md Path: ../ao-cookbook/src/ja/guides/aos/modules/crypto.md
Note: This content continues in the next part.

Response:
<!-- ## SHA2_256

Calculates the SHA2-256 digest of a given message.

- **Parameters:**
  - `stream` (Stream): The message in form of stream
- **Returns:** A table containing functions to get digest in different formats.
  - `asBytes()`: The digest as byte table.
  - `asHex()`: The digest as string in hexadecimal format.
  - `asString()`: The digest as string format.
-->

Example:

```lua
local str = crypto.utils.stream.fromString("ao")

return crypto.digest.sha2_256(str).asHex() -- ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
```

## SHA2_512

与えられたメッセージの SHA2-512 ダイジェストを計算します。

- **パラメータ:**
  - `msg` (string): ダイジェストを計算するメッセージ
- **戻り値:** 異なる形式でダイジェストを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式のダイジェスト。
  - `asHex()`: 16進形式の文字列としてのダイジェスト。
  - `asString()`: 文字列形式のダイジェスト。

Example:

```lua
local str = "ao"

return crypto.digest.sha2_512(str).asHex() -- 6f36a696b17ce5a71efa700e8a7e47994f3e134a5e5f387b3e7c2c912abe94f94ee823f9b9dcae59af99e2e34c8b4fb0bd592260c6720ee49e5deaac2065c4b1
```

## SHA3

以下の関数が含まれています。

1. `sha3_256`
2. `sha3_512`
3. `keccak256`
4. `keccak512`

各関数は、与えられたメッセージのそれぞれのダイジェストを計算します。

- **パラメータ:**

  - `msg` (string): ダイジェストを計算するメッセージ

- **戻り値:** 異なる形式でダイジェストを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式のダイジェスト。
  - `asHex()`: 16進形式の文字列としてのダイジェスト。
  - `asString()`: 文字列形式のダイジェスト。

<!--
## SHA3

It contains the following functions:

1. `sha3_256`
2. `sha3_512`
3. `keccak256`
4. `keccak512`

Each function calculates the respective digest of a given message.

- **Parameters:**

  - `msg` (string): The message to calculate the digest

- **Returns:** A table containing functions to get digest in different formats.
  - `asBytes()`: The digest as byte table.
  - `asHex()`: The digest as string in hexadecimal format.
  - `asString()`: The digest as string format. -->

Example:

```lua

local str = "ao"

crypto.digest.sha3_256(str).asHex()  -- 1bbe785577db997a394d5b4555eec9159cb51f235aec07514872d2d436c6e985
crypto.digest.sha3_512(str).asHex()  -- 0c29f053400cb1764ce2ec555f598f497e6fcd1d304ce0125faa03bb724f63f213538f41103072ff62ddee701b52c73e621ed4d2254a3e5e9a803d83435b704d
crypto.digest.keccak256(str).asHex() -- 76da52eec05b749b99d6e62bb52333c1569fe75284e6c82f3de12a4618be00d6
crypto.digest.keccak512(str).asHex() -- 046fbfad009a12cef9ff00c2aac361d004347b2991c1fa80fba5582251b8e0be8def0283f45f020d4b04ff03ead9f6e7c43cc3920810c05b33b4873b99affdea

```

## Blake2b

与えられたメッセージのBlake2bダイジェストを計算します。

- **パラメータ:**

  - `data` (string): ハッシュ化するデータ。
  - `outlen` (number): 出力ハッシュの長さ（オプション） **デフォルトは64**。
  - `key` (string): ハッシュ化に使用するキー（オプション） **デフォルトは""**。

- **戻り値:** 異なる形式でダイジェストを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式のダイジェスト。
  - `asHex()`: 16進形式の文字列としてのダイジェスト。
  - `asString()`: 文字列形式のダイジェスト。

<!--
## Blake2b

Calculates the Blake2b digest of a given message.

- **Parameters:**

  - `data` (string): The data to be hashed.
  - `outlen` (number): The length of the output hash (optional) **default is 64**.
  - `key` (string): The key to be used for hashing (optional) **default is ""**.

- **Returns:** A table containing functions to get digest in different formats.
  - `asBytes()`: The digest as byte table.
  - `asHex()`: The digest as string in hexadecimal format.
  - `asString()`: The digest as string format. -->

Example:

```lua
local str = "ao"

crypto.digest.blake2b(str).asHex() -- 576701fd79a126f2c414ef94adf1117c88943700f312679d018c29c378b2c807a3412b4e8d51e191c48fb5f5f54bf1bca29a714dda166797b3baf9ead862ae1d
crypto.digest.blake2b(str, 32).asHex() -- 7050811afc947ba7190bb3c0a7b79b4fba304a0de61d529c8a35bdcbbb5544f4
crypto.digest.blake2b(str, 32, "secret_key").asHex() -- 203c101980fdf6cf24d78879f2e3db86d73d91f7d60960b642022cd6f87408f8
```

---

# Ciphers

## AES

高度暗号化標準（AES）は、機密情報を暗号化するために使用される対称ブロック暗号です。暗号化と復号化の2つの機能があります。

### Encrypt

AESアルゴリズムを使用して、与えられたメッセージを暗号化します。

- **パラメータ:**

  - `data` (string): 暗号化するデータ。
  - `key` (string): 暗号化に使用するキー。
  - `iv` (string) オプション: 暗号化に使用する初期化ベクトル。 **デフォルトは""**
  - `mode` (string) オプション: 暗号化に使用する操作モード。 **デフォルトは"CBC"**。 使用可能なモードは `CBC`, `ECB`, `CFB`, `OFB`, `CTR` です。
  - `keyLength` (number) オプション: 暗号化に使用するキーの長さ。 **デフォルトは128**。

- **戻り値:** 異なる形式で暗号化されたデータを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式の暗号化データ。
  - `asHex()`: 16進形式の文字列としての暗号化データ。
  - `asString()`: 文字列


Prompt:
This is a Markdown documentation from the AO documentation repository. This is a continuation from the previous part. Filename: crypto.md Path: ../ao-cookbook/src/ja/guides/aos/modules/crypto.md
Note: This content continues in the next part.

Response:
�プション: 暗号化に使用する操作モード。 **デフォルトは"CBC"**。 使用可能なモードは `CBC`, `ECB`, `CFB`, `OFB`, `CTR` です。
  - `keyLength` (number) オプション: 暗号化に使用するキーの長さ。 **デフォルトは128**。

- **戻り値:** 異なる形式で暗号化されたデータを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式の暗号化データ。
  - `asHex()`: 16進形式の文字列としての暗号化データ。
  - `asString()`: 文字列形式の暗号化データ。

## Decrypt

AESアルゴリズムを使用して、与えられたメッセージを復号化します。

- **パラメータ:**

  - `cipher` (string): ヘックスエンコードされた暗号化データ。
  - `key` (string): 復号化に使用するキー。
  - `iv` (string) オプション: 復号化に使用する初期化ベクトル。 **デフォルトは""**
  - `mode` (string) オプション: 復号化に使用する操作モード。 **デフォルトは"CBC"**。 使用可能なモードは `CBC`, `ECB`, `CFB`, `OFB`, `CTR` です。
  - `keyLength` (number) オプション: 復号化に使用するキーの長さ。 **デフォルトは128**。

- **戻り値:** 異なる形式で復号化されたデータを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式の復号化データ。
  - `asHex()`: 16進形式の文字列としての復号化データ。
  - `asString()`: 文字列形式の復号化データ。

<!--
# Ciphers

## AES

The Advanced Encryption Standard (AES) is a symmetric block cipher used to encrypt sensitive information. It has two functions encrypt and decrypt.

### Encrypt

Encrypts a given message using the AES algorithm.

- **Parameters:**

  - `data` (string): The data to be encrypted.
  - `key` (string): The key to be used for encryption.
  - `iv` (string) optional: The initialization vector to be used for encryption. **default is ""**
  - `mode` (string) optional: The mode of operation to be used for encryption. **default is "CBC"**. Available modes are `CBC`, `ECB`, `CFB`, `OFB`, `CTR`.
  - `keyLength` (number) optional: The length of the key to use for encryption. **default is 128**.

- **Returns:** A table containing functions to get encrypted data in different formats.
  - `asBytes()`: The encrypted data as byte table.
  - `asHex()`: The encrypted data as string in hexadecimal format.
  - `asString()`: The encrypted data as string format.

## Decrypt

Decrypts a given message using the AES algorithm.

- **Parameters:**

  - `cipher` (string): Hex Encoded encrypted data.
  - `key` (string): The key to be used for decryption.
  - `iv` (string) optional: The initialization vector to be used for decryption. **default is ""**
  - `mode` (string) optional: The mode of operation to be used for decryption. **default is "CBC"**. Available modes are `CBC`, `ECB`, `CFB`, `OFB`, `CTR`.
  - `keyLength` (number) optional: The length of the key to use for decryption. **default is 128**.

- **Returns:** A table containing functions to get decrypted data in different formats.
  - `asBytes()`: The decrypted data as byte table.
  - `asHex()`: The decrypted data as string in hexadecimal format.
  - `asString()`: The decrypted data as string format. -->

Example:

```lua
local str = "ao"

local iv = "super_secret_shh"
local key_128 = "super_secret_shh"

local encrypted = crypto.cipher.aes.encrypt("ao", key, iv).asHex() -- A3B9E6E1FBD9D46930E5F76807C84B8E
local decrypted = crypto.cipher.aes.decrypt(encrypted, key, iv).asHex() -- 616F0000000000000000000000000000

crypto.utils.hex.hexToString(decrypted) -- ao

```

## ISSAC Cipher

ISAACは、暗号的に安全な擬似乱数生成器（CSPRNG）であり、ストリーム暗号です。以下の機能があります。

1. `seedIsaac`: 指定されたシードでISAAC暗号をシードします。
2. `getRandomChar`: ISAAC暗号を使用してランダムな文字を生成します。
3. `random`: ISAAC暗号を使用して指定された範囲内のランダムな数値を生成します。
4. `getRandom`: ISAAC暗号を使用してランダムな数値を生成します。
5. `encrypt`: ISAAC暗号を使用して与えられたメッセージを暗号化します。
6. `decrypt`: ISAAC暗号を使用して与えられたメッセージを復号化します。

### Encrypt

ISAAC暗号を使用して、与えられたメッセージを暗号化します。

- **パラメータ:**
  - `msg` (string): 暗号化するメッセージ。
  - `key` (string): 暗号化に使用するキー。
- **戻り値:** 異なる形式で暗号化されたデータを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式の暗号化データ。
  - `asHex()`: 16進形式の文字列としての暗号化データ。
  - `asString()`: 文字列形式の暗号化データ。

### Decrypt

ISAAC暗号を使用して、与えられたメッセージを復号化します。

- **パラメータ:**
  - `cipher` (string): ヘックスエンコードされた暗号化データ。
  - `key` (string): 復号化に使用するキー。
- **戻り値:** 異なる形式で復号化されたデータを取得するための関数を含むテーブル。
  - `asBytes()`: バイトテーブル形式の復号化データ。
  - `asHex()`: 16進形式の文字列としての復号化データ。
  - `asString()`: 文字列形式の復号化データ。

<!--
## ISSAC Cipher

ISAAC is a cryptographically secure pseudo-random number generator (CSPRNG) and stream cipher. It has the following functions

1. `seedIsaac`: Seeds the ISAAC cipher with a given seed.
2. `getRandomChar`: Generates a random character using the ISAAC cipher.
3. `random`: Generates a random number between a given range using the ISAAC cipher.
4. `getRandom`: Generates a random number using the ISAAC cipher.
5. `encrypt`: Encrypts a given message using the ISAAC cipher.
6. `decrypt`: Decrypts a given message using the ISAAC cipher.

### Encrypt

Encrypts a given message using the ISAAC cipher.

- **Parameters:**
  - `msg` (string): The message to be encrypted.
  - `key` (string): The key to be used for encryption.
- **Returns:** A table containing functions to get encrypted data in different formats.
  - `asBytes()`: The encrypted data as byte table.
  - `asHex()`: The encrypted data as string in hexadecimal format.
  - `asString()`: The encrypted data as string format.

### Decrypt

Decrypts a given message using the ISAAC cipher.

- **Parameters:**
  - `cipher` (string): Hex Encoded encrypted data.
  - `key` (string): Key to be used for decryption.
- **Returns:** A table containing functions to get decrypted data in different formats.