kr wip

src/pages/kr/amman/cli-commands.md

@@ -0,0 +1,47 @@
+---
+title: CLI 명령어
+metaTitle: CLI 명령어 | Amman
+description: Metaplex Amman 로컬 검증자 도구 키트의 CLI 명령어.
+---
+
+```sh
+amman [명령어]
+
+명령어:
+  amman start    solana-test-validator와 구성된 경우 amman relay 및/또는
+                 mock storage를 시작합니다
+  amman stop     relay와 storage를 중지하고 실행 중인 solana
+                 test validator를 종료합니다
+  amman logs     'solana logs'를 시작하고 prettifier를 통해 파이프합니다
+  amman airdrop  제공된 Sol을 지불자에게 에어드롭합니다
+  amman label    amman에 계정이나 트랜잭션용 레이블을 추가합니다
+  amman account  PublicKey나 레이블에 대한 계정 정보를 검색하거나
+                 모든 레이블된 계정을 보여줍니다
+  amman run      모든 주소 레이블을 확장한 후 제공된 명령을 실행합니다
+
+옵션:
+  --help     도움말 보기                                                [boolean]
+  --version  버전 번호 보기                                           [boolean]
+```
+
+## 명령어 실행
+
+```sh
+npx amman start <config.js>
+```
+
+`config.js`가 제공되지 않으면 _amman_은 현재 디렉터리에서 `.ammanrc.js` 파일을 찾습니다.
+이것도 찾지 못하면 기본 구성을 사용합니다.
+
+package.json 스크립트에 Amman을 추가했다면 선택한 패키지 설치 프로그램에서 Amman을 실행할 수 있습니다.
+
+```sh
+// npm
+npm run amman:start
+
+// yarn
+yarn amman:start
+
+// pnpm
+pnpm run amman:start
+```

src/pages/kr/amman/configuration.md

@@ -0,0 +1,126 @@
+---
+title: 구성
+metaTitle: 구성 | Amman
+description: Amman 로컬 검증자 도구 키트 구성하기.
+---
+
+실행할 때 Amman은 프로젝트 루트에서 구성 파일 `.ammanrc.js`를 찾습니다. 이 파일이 없으면 Amman은 기본 구성으로 로드됩니다.
+
+구성은 아래 속성 중 하나와 함께 'validator'를 내보내는 JavaScript 모듈이어야 합니다:
+
+- **killRunningValidators**: true이면 시스템에서 현재 실행 중인 모든 solana-test-validators를 종료합니다.
+- **programs**: 테스트 검증자에 로드되어야 하는 bpf 프로그램
+- **accountsCluster**: 원격 계정을 복제할 기본 클러스터
+- **accounts**: 테스트 검증자에 로드할 원격 계정 배열
+- **jsonRpcUrl**: 테스트 검증자가 JSON RPC 요청을 수신할 URL
+- **websocketUrl**: RPC 웹소켓용
+- **ledgerDir**: solana 테스트 검증자가 원장을 쓰는 위치
+- **resetLedger**: true이면 시작 시 원장이 제네시스로 재설정됩니다.
+- **verifyFees**: true이면 트랜잭션 수수료를 청구할 때까지 검증자가 완전히 시작된 것으로 간주되지 않습니다.
+
+## 구성 예제
+
+### 기본값이 있는 검증자/릴레이/스토리지 구성
+
+다음은 추가된 프로그램과 `relay` 및 `storage` 구성을 제외하고 모든 값이 기본값으로 설정된 구성 예제입니다.
+
+_amman-explorer relay_는 _CI_ 환경에서 실행되지 않는 한 검증자와 함께 자동으로 시작되며, 알려진 _relay port_에서 릴레이가 이미 실행 중인 경우 먼저 종료됩니다.
+
+_mock storage_는 `storage` 구성이 제공된 경우에만 시작됩니다. 알려진 _storage port_에서 스토리지 서버가 이미 실행 중인 경우 먼저 종료됩니다.
+
+```js
+import { LOCALHOST, tmpLedgerDir } from '@metaplex-foundation/amman'
+
+module.exports = {
+  validator: {
+    killRunningValidators: true,
+    programs: [
+      {
+        label: 'Token Metadata Program',
+        programId: programIds.metadata,
+        deployPath: localDeployPath('mpl_token_metadata'),
+      },
+    ],
+    jsonRpcUrl: LOCALHOST,
+    websocketUrl: '',
+    commitment: 'confirmed',
+    ledgerDir: tmpLedgerDir(),
+    resetLedger: true,
+    verifyFees: false,
+    detached: process.env.CI != null,
+  },
+  relay: {
+    enabled: process.env.CI == null,
+    killRunningRelay: true,
+  },
+  storage: {
+    enabled: process.env.CI == null,
+    storageId: 'mock-storage',
+    clearOnStart: true,
+  },
+}
+```
+
+### 원격 계정 및 프로그램이 있는 구성
+
+Amman은 선택한 클러스터에서 로컬 사용 및 테스트를 위해 계정과 프로그램을 모두 가져올 수 있습니다.
+
+```js
+module.exports = {
+  validator: {
+    // 기본적으로 Amman은 accountsCluster에서 계정 데이터를 가져옵니다 (계정별로 재정의 가능)
+    accountsCluster: 'https://api.metaplex.solana.com',
+    accounts: [
+      {
+        label: 'Token Metadata Program',
+        accountId: 'metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s',
+        // executable을 true로 표시하면 Amman이 실행 가능한 데이터 계정도 자동으로 가져옵니다
+        executable: true,
+      },
+      {
+        label: 'Random other account',
+        accountId: '4VLgNs1jXgdciSidxcaLKfrR9WjATkj6vmTm5yCwNwui',
+        // 기본적으로 executable은 false이며 구성에 포함될 필요가 없습니다
+        // executable: false,
+
+        // 여기에 클러스터를 제공하면 accountsCluster 필드를 재정의합니다
+        cluster: 'https://metaplex.devnet.rpcpool.com',
+      },
+    ],
+  },
+}
+```
+
+### 테스트 검증자 기능 비활성화
+
+_devnet_과 같은 다른 클러스터의 경우 일부 기능이 비활성화됩니다. 기본적으로 로컬에서 실행되는 solana-test-validator는 어떤 기능도 비활성화하지 않으므로 제공된 클러스터와 다르게 작동합니다.
+
+특정 클러스터에 대해 실행될 방식에 더 가까운 시나리오에서 테스트를 실행하려면 _matchFeatures_ 구성 속성을 통해 해당 기능을 일치시킬 수 있습니다:
+
+```js
+module.exports = {
+  validator: {
+    ...
+    // 아래는 `mainnet-beta` 클러스터에 대해 비활성화된 모든 기능을 비활성화합니다
+    matchFeatures: 'mainnet-beta',
+  }
+}
+```
+
+기능 세트를 명시적으로 비활성화하려면 _deactivateFeatures_ 속성을 통해 그렇게 할 수 있습니다:
+
+```js
+module.exports = {
+  validator: {
+    ...
+   deactivateFeatures: ['21AWDosvp3pBamFW91KB35pNoaoZVTM7ess8nr2nt53B'],
+  }
+}
+```
+
+**참고**: 위의 속성 중 하나만 설정할 수 있습니다
+
+#### 리소스
+
+- [test validator runtime features](https://docs.solana.com/developing/test-validator#appendix-ii-runtime-features)
+- [runtime new features](https://docs.solana.com/developing/programming-model/runtime#new-features)

src/pages/kr/amman/getting-started.md

@@ -0,0 +1,37 @@
+---
+title: 시작하기
+metaTitle: 시작하기 | Amman
+description: Metaplex Amman 로컬 검증자 도구 키트의 설치 및 설정.
+---
+
+## 전제 조건
+
+Amman을 실행하기 전에 시스템에 몇 가지를 설치해야 합니다.
+
+- [Rust](https://www.rust-lang.org/tools/install)
+- [Solana CLI](https://docs.solanalabs.com/cli/install)
+- [NodeJs](https://nodejs.org/en/download)
+
+## 설치
+
+새 프로젝트를 시작했거나 기존 프로젝트를 열었다면 패키지 매니저를 통해 Amman을 설치할 수 있습니다.
+
+```js
+npm i @metaplex-foundation/amman
+```
+
+## 스크립트에 추가 (선택사항)
+
+사용 편의를 위해 package.json 스크립트에 Amman 실행을 추가할 수 있습니다.
+
+{% dialect-switcher title="package.json" %}
+{% dialect title="JavaScript" id="js" %}
+
+```js
+"scripts": {
+    ...
+    "amman:start": "npx amman start"
+  },
+```
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/amman/index.md

@@ -0,0 +1,15 @@
+---
+title: 개요
+metaTitle: 개요 | Amman
+description: Amman 로컬 검증자에 대한 고수준 개요를 제공합니다.
+---
+
+로컬에서 실행되는 검증자에서 Solana SDK 라이브러리와 앱을 테스트하는 데 도움이 되는 **A** **m** odern **man** datory 도구벨트입니다. {% .lead %}
+
+{% quick-links %}
+
+{% quick-link title="시작하기" icon="InboxArrowDown" href="/kr/amman/getting-started" description="원하는 언어나 라이브러리를 선택하고 필수 프로그램을 시작하세요." /%}
+
+{% quick-link title="구성" icon="CodeBracketSquare" href="/kr/amman/pre-made-configs" description="시도하고 수정할 수 있는 미리 만들어진 구성 세트입니다." /%}
+
+{% /quick-links %}

src/pages/kr/amman/pre-made-configs.md

@@ -0,0 +1,206 @@
+---
+title: 미리 만들어진 구성
+metaTitle: 미리 만들어진 구성 | Amman
+description: Metaplex Amman 로컬 검증자 도구 키트의 미리 만들어진 구성 세트.
+---
+
+다음은 다양한 Metaplex 프로그램과 함께 작업하기 위한 Amman 구성의 몇 가지 기본 예제입니다. 필요에 맞게 이러한 파일을 수정해야 할 수 있습니다.
+
+## Bubblegum
+
+이 설정은 Metaplex Bubblegum을 테스트하고 작업하도록 설계되었습니다.
+
+```json
+const { LOCALHOST, tmpLedgerDir } = require("@metaplex-foundation/amman");
+
+module.exports = {
+  validator: {
+    killRunningValidators: true,
+    accountsCluster: "https://api.devnet.solana.com",
+    accounts: [
+       {
+        label: "Bubblegum",
+        accountId: "BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY",
+        executable: true,
+      },
+      {
+        label: "Token Metadata Program",
+        accountId: "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s",
+        executable: true,
+      },
+      {
+        label: "Token Auth Rules",
+        accountId: "auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3rboVmgg",
+        executable: true,
+      },
+      {
+        label: "Spl ATA Program",
+        accountId: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+        executable: true,
+      },
+      {
+        label: "SPL Token Program",
+        accountId: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+        executable: true,
+      },
+      {
+        label: "SPL Account Compression",
+        accountId: "cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK",
+        executable: true
+      },
+      {
+        label: "SPL Noop Program",
+        accountId: "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV",
+        executable: true
+      },
+
+    ],
+    jsonRpcUrl: LOCALHOST,
+    websocketUrl: "",
+    commitment: "confirmed",
+    ledgerDir: tmpLedgerDir(),
+    resetLedger: true,
+    verifyFees: false,
+    detached: process.env.CI != null,
+  },
+  relay: {
+    enabled: process.env.CI == null,
+    killRunningRelay: true,
+  },
+  storage: {
+    enabled: process.env.CI == null,
+    storageId: "mock-storage",
+    clearOnStart: true,
+  },
+};
+```
+
+## Candy Machine
+
+이 설정은 Metaplex Candy Machine을 테스트하고 작업하도록 설계되었습니다.
+
+```json
+const { LOCALHOST, tmpLedgerDir } = require("@metaplex-foundation/amman");
+
+module.exports = {
+  validator: {
+    killRunningValidators: true,
+    accountsCluster: "https://api.devnet.solana.com	",
+    accounts: [
+       {
+        label: "Candy Machine v3",
+        accountId: "CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR",
+        executable: true,
+      },
+      {
+        label: "Candy Guard",
+        accountId: "Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g",
+        executable: true,
+      },
+      {
+        label: "Token Metadata Program",
+        accountId: "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s",
+        executable: true,
+      },
+      {
+        label: "Token Auth Rules",
+        accountId: "auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3rboVmgg",
+        executable: true,
+      },
+      {
+        label: "Spl ATA Program",
+        accountId: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+        executable: true,
+      },
+      {
+        label: "SPL Token Program",
+        accountId: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+        executable: true,
+      },
+    ],
+    jsonRpcUrl: LOCALHOST,
+    websocketUrl: "",
+    commitment: "confirmed",
+    ledgerDir: tmpLedgerDir(),
+    resetLedger: true,
+    verifyFees: false,
+    detached: process.env.CI != null,
+  },
+  relay: {
+    enabled: process.env.CI == null,
+    killRunningRelay: true,
+  },
+  storage: {
+    enabled: process.env.CI == null,
+    storageId: "mock-storage",
+    clearOnStart: true,
+  },
+};
+```
+
+## Core Candy Machine
+
+이 설정은 Metaplex Core Candy Machine을 테스트하고 작업하도록 설계되었습니다. 위의 Candy Machine 예제와 비교하여 다른 Candy Machine 프로그램 ID와 Candy Guard 프로그램 ID가 사용되고 MPL-Core 프로그램이 추가됩니다.
+
+```json
+const { LOCALHOST, tmpLedgerDir } = require("@metaplex-foundation/amman");
+
+module.exports = {
+  validator: {
+    killRunningValidators: true,
+    accountsCluster: "https://api.devnet.solana.com",
+    accounts: [
+       {
+        label: "Core Candy Machine",
+        accountId: "CMACYFENjoBMHzapRXyo1JZkVS6EtaDDzkjMrmQLvr4J",
+        executable: true,
+      },
+      {
+        label: "Core Candy Guard",
+        accountId: "CMAGAKJ67e9hRZgfC5SFTbZH8MgEmtqazKXjmkaJjWTJ",
+        executable: true,
+      },
+      {
+        label: "mpl-core",
+        accountId: "CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d",
+        executable: true,
+      },      
+      {
+        label: "Token Metadata Program",
+        accountId: "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s",
+        executable: true,
+      },
+      {
+        label: "Token Auth Rules",
+        accountId: "auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3rboVmgg",
+        executable: true,
+      },
+      {
+        label: "Spl ATA Program",
+        accountId: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+        executable: true,
+      },
+      {
+        label: "SPL Token Program",
+        accountId: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+        executable: true,
+      },
+    ],
+    jsonRpcUrl: LOCALHOST,
+    websocketUrl: "",
+    commitment: "confirmed",
+    ledgerDir: tmpLedgerDir(),
+    resetLedger: true,
+    verifyFees: false,
+    detached: process.env.CI != null,
+  },
+  relay: {
+    enabled: process.env.CI == null,
+    killRunningRelay: true,
+  },
+  storage: {
+    enabled: process.env.CI == null,
+    storageId: "mock-storage",
+    clearOnStart: true,
+  },
+};

src/pages/kr/aura/blockchains/eclipse.md

@@ -0,0 +1,13 @@
+---
+title: Eclipse SVM의 Aura
+metaTitle: Eclipse SVM의 Aura | Aura
+description: Eclipse SVM 블록체인의 Metaplex Aura에 대해 알아보세요.
+---
+
+{% callout title="Aura 엔드포인트" %}
+
+**다음 노드에서 Eclipse SVM의 Aura를 테스트할 수 있습니다:**
+- **Devnet**: https://aura-eclipse-devnet.metaplex.com 
+- **Mainnet**: https://aura-eclipse-mainnet.metaplex.com 
+
+{% /callout %}

src/pages/kr/aura/blockchains/solana.md

@@ -0,0 +1,13 @@
+---
+title: Solana의 Aura
+metaTitle: Solana의 Aura | Aura
+description: Solana 블록체인의 Metaplex Aura에 대해 알아보세요.
+---
+
+{% callout title="Aura 엔드포인트" %}
+
+**다음 노드에서 Solana의 Aura를 테스트할 수 있습니다:**
+- **Devnet**: https://aura-devnet.metaplex.com
+- **Mainnet**: https://aura-mainnet.metaplex.com
+
+{% /callout %}

src/pages/kr/aura/faq.md

@@ -0,0 +1,18 @@
+---
+title: FAQ
+metaTitle: FAQ | Aura
+description: Aura에 대한 자주 묻는 질문
+---
+
+## Aura 게이트웨이에 어떻게 액세스할 수 있나요?
+
+Aura 게이트웨이는 특정 오류와 성능 문제를 해결하기 위해 현재 비활성화되어 기술 검토를 받고 있습니다.
+
+## Aura는 어떤 프로토콜을 지원하나요?
+
+Aura는 최신 DAS 메서드와 함께 다음 프로토콜을 지원합니다:
+- MPL Token Metadata (NFT/pNFT)
+- MPL Core (Core Assets/Core Collections)
+- MPL Bubblegum (cNFTs)
+- Fungible SPL Tokens
+- SPL Token22

src/pages/kr/aura/index.md

@@ -0,0 +1,17 @@
+---
+title: 개요
+metaTitle: 개요 | Aura
+description: 디지털 자산을 위한 통합 네트워크인 Aura의 고수준 개요.
+---
+
+Metaplex Aura는 Solana와 Solana Virtual Machine (SVM)을 확장하는 오픈소스 데이터 네트워크 구현입니다.
+
+분산형 애플리케이션은 블록체인 데이터의 현재 상태를 읽고 표시하는 것이 어렵고, 비용이 많이 들며, 느릴 수 있기 때문에 중앙화된 대안과 경쟁하기 어렵습니다. Aura는 자산 데이터를 성능적으로 인덱싱하고 실시간 데이터 가용성을 제공하는 분산형 Aura 노드 네트워크로 SVM과 MPL을 보완함으로써 이러한 문제를 해결합니다.
+
+## Solana 데이터 읽기
+
+사용자와 개발자는 Solana 네트워크의 분산형 읽기 액세스를 통해 이익을 얻을 수 있으며, 압축된 상태에서도 단일 실패 지점에 의존하지 않고 디지털 자산과 미디어 콘텐츠에 항상 액세스할 수 있도록 보장합니다.
+
+## 참조 페이지
+
+- [Solana 및 SVM 데이터 읽기](/kr/aura/reading-solana-and-svm-data): Aura 네트워크는 [Metaplex Digital Asset Standard (DAS) API](/kr/das-api)를 사용하여 쿼리할 수 있는 자산 데이터의 데이터 가용성과 분산형 인덱싱을 제공합니다.

src/pages/kr/aura/reading-solana-and-svm-data.md

@@ -0,0 +1,17 @@
+---
+title: Solana 및 SVM 데이터 읽기
+metaTitle: Solana 및 SVM 데이터 읽기 | Aura
+description: Metaplex Aura로 Solana 및 SVM 데이터를 읽는 방법을 알아보세요.
+---
+
+Metaplex Aura 데이터 네트워크는 개발자에게 Solana 및 Eclipse와 같은 다른 SVM 기반 체인에 대한 온체인 상태의 성능적이고 안정적이며 정확한 읽기 액세스를 제공합니다.
+
+인덱서와 RPC 제공업체는 데이터 일관성과 성능을 유지하는 데 상당한 어려움을 겪는 경우가 많습니다. 이는 여러 문제로 인한 것입니다:
+
+- **데이터 일관성**: Solana 노드는 종종 동기화가 해제되고 Geyser 플러그인은 특히 노드 재동기화 중에 업데이트를 건너뛸 수 있습니다. 이는 인덱서가 제공하는 데이터의 불일치로 이어질 수 있습니다.
+- **증가하는 스토리지 비용**: 데이터 볼륨이 계속 증가함에 따라 인덱스를 유지하고 관리하는 데 더 많은 스토리지가 필요하고 관련 비용이 증가합니다.
+- **사용자 경험**: 단편화된 데이터 가용성은 제공업체 종속으로 이어질 수 있으며, 사용자가 다양한 프로토콜에서 모든 디지털 자산에 액세스하기 위해 여러 RPC 제공업체에 의존하도록 강제합니다.
+
+## 개발 진행 상황
+
+Aura와 그 기능의 개발 진행 상황은 github 저장소 [https://github.com/metaplex-foundation/aura/](https://github.com/metaplex-foundation/aura/)에서 확인할 수 있습니다.

src/pages/kr/bubblegum-v2/burn-cnfts.md

@@ -0,0 +1,66 @@
+---
+title: 압축된 NFT 소각
+metaTitle: 압축된 NFT 소각 | Bubblegum V2
+description: Bubblegum에서 압축된 NFT를 소각하는 방법을 알아보세요.
+---
+
+**burnV2** 명령어는 압축된 NFT를 소각하여 Bubblegum 트리에서 영구적으로 제거하는 데 사용할 수 있습니다. 이 작업을 승인하려면 현재 소유자나 위임 권한(있는 경우) 중 하나가 트랜잭션에 서명해야 합니다. 명령어는 다음 매개변수를 받아들입니다:
+
+- **리프 소유자**, **리프 위임자**, 또는 **영구 소각 위임자**: 압축된 NFT의 현재 소유자, 위임 권한(있는 경우), 또는 컬렉션의 영구 소각 위임자. 자산이 컬렉션의 일부인 경우 `coreCollection` 매개변수를 전달해야 합니다. 이 중 하나가 트랜잭션에 서명해야 합니다.
+
+이 명령어는 Bubblegum 트리의 리프를 교체하므로 소각하기 전에 압축된 NFT의 무결성을 확인하기 위해 추가 매개변수를 제공해야 합니다. 이러한 매개변수는 리프를 변경하는 모든 명령어에 공통이므로 [다음 FAQ](/kr/bubblegum-v2/faq#replace-leaf-instruction-arguments)에 문서화되어 있습니다. 다행히 Metaplex DAS API를 사용하여 이러한 매개변수를 자동으로 가져오는 도우미 메서드를 사용할 수 있습니다.
+
+{% callout title="트랜잭션 크기" type="note" %}
+트랜잭션 크기 오류가 발생하면 `getAssetWithProof`와 함께 `{ truncateCanopy: true }`를 사용하는 것을 고려하세요. 자세한 내용은 [FAQ](/kr/bubblegum-v2/faq#replace-leaf-instruction-arguments)를 참조하세요.
+{% /callout %}
+
+{% callout title="컬렉션" type="note" %}
+cNFT가 컬렉션의 일부인 경우 `coreCollection` 매개변수를 전달해야 합니다.
+{% /callout %}
+
+{% dialect-switcher title="압축된 NFT 소각" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import { getAssetWithProof, burnV2 } from '@metaplex-foundation/mpl-bubblegum';
+
+const assetWithProof = await getAssetWithProof(umi, assetId, {truncateCanopy: true});
+await burnV2(umi, {
+  ...assetWithProof,
+  leafOwner: currentLeafOwner,
+}).sendAndConfirm(umi)
+```
+
+{% totem-accordion title="위임자 사용" %}
+
+```ts
+import { getAssetWithProof, burnV2 } from '@metaplex-foundation/mpl-bubblegum'
+
+const assetWithProof = await getAssetWithProof(umi, assetId, {truncateCanopy: true});
+await burnV2(umi, {
+  ...assetWithProof,
+  leafDelegate: currentLeafDelegate,
+}).sendAndConfirm(umi)
+```
+
+{% /totem-accordion %}
+
+{% totem-accordion title="영구 소각 위임자 사용" %}
+
+```ts
+import { getAssetWithProof, burnV2 } from '@metaplex-foundation/mpl-bubblegum'
+
+const assetWithProof = await getAssetWithProof(umi, assetId, {truncateCanopy: true});
+await burnV2(umi, {
+  ...assetWithProof,
+  authority: permanentBurnDelegate, // 영구 소각 위임자의 서명자
+  coreCollection: collection.publicKey,
+}).sendAndConfirm(umi)
+```
+
+{% /totem-accordion %}
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/bubblegum-v2/collections.md

@@ -0,0 +1,87 @@
+---
+title: 컬렉션 확인
+metaTitle: 컬렉션 확인 | Bubblegum V2
+description: Bubblegum에서 컬렉션을 설정, 확인 및 확인 해제하는 방법을 알아보세요.
+---
+
+cNFT는 민팅 시 또는 나중에 MPL-Core 컬렉션에 추가될 수 있습니다. {% .lead %}
+
+NFT와 관련된 컬렉션의 개념에 익숙하지 않다면, 이는 다른 NFT를 함께 그룹화하는 데 사용할 수 있는 특별한 비압축 NFT입니다. 따라서 **컬렉션**의 데이터는 전체 컬렉션의 이름과 브랜딩을 설명하는 데 사용됩니다. Bubblegum V2부터는 리프 소유자의 상호 작용 없이 위임자가 cNFT를 동결하고 해동할 수 있도록 하는 등 컬렉션 수준에서 추가 기능을 허용합니다. [MPL-Core 컬렉션에 대한 자세한 내용은 여기에서 읽을 수 있습니다](/kr/core/collections).
+
+[여기에 문서화된](/kr/bubblegum-v2/mint-cnfts#minting-to-a-collection) **MintV2** 명령어를 사용하여 압축된 NFT를 컬렉션에 직접 민팅하는 것이 가능합니다. 그렇긴 하지만 컬렉션 없이 cNFT를 이미 민팅했다면 해당 cNFT에 컬렉션을 설정하는 방법을 살펴보겠습니다. "verified" 부울이 있는 Metaplex Token Metadata 컬렉션을 사용하는 Bubblegum v1과 달리 Bubblegum V2는 해당 부울이 없는 MPL-Core 컬렉션을 사용합니다.
+
+MPL-Core 컬렉션은 [`BubblegumV2` 플러그인](/kr/core/plugins/bubblegum)을 포함해야 합니다.
+
+다음 섹션은 단일 단계 트랜잭션에서 cNFT에서 컬렉션을 설정하고 제거하는 방법을 보여줍니다. `coreCollection`과 `newCoreCollection` 매개변수를 추가할 때 단일 명령어에서 두 작업을 모두 수행하는 것도 가능합니다. 두 컬렉션 권한이 동일한 지갑이 아닌 경우 둘 다 서명해야 합니다.
+
+## 압축된 NFT의 컬렉션 설정
+**setCollectionV2** 명령어는 cNFT의 컬렉션을 설정하는 데 사용할 수 있습니다. cNFT에서 컬렉션을 제거하거나 cNFT의 컬렉션을 변경하는 데도 사용할 수 있습니다.
+
+{% dialect-switcher title="압축된 NFT의 컬렉션 설정" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import {
+  getAssetWithProof,
+  setCollectionV2,
+  MetadataArgsV2Args
+} from '@metaplex-foundation/mpl-bubblegum';
+import {
+  unwrapOption,
+  none,
+} from '@metaplex-foundation/umi';
+
+const assetWithProof = await getAssetWithProof(umi, assetId, {truncateCanopy: true});
+
+const collection = unwrapOption(assetWithProof.metadata.collection)
+
+const metadata: MetadataArgsV2Args = {
+  ...assetWithProof.metadata,
+  collection: collection?.key ?? null,
+};
+
+const signature = await setCollectionV2(umi, {
+  ...assetWithProof,
+  newCollectionAuthority: newCollectionUpdateAuthority,
+  metadata,
+  newCoreCollection: newCoreCollection.publicKey,
+}).sendAndConfirm(umi);
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 압축된 NFT의 컬렉션 제거
+**setCollectionV2** 명령어는 cNFT에서 컬렉션을 제거하는 데도 사용할 수 있습니다.
+
+{% dialect-switcher title="압축된 NFT의 컬렉션 제거" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import {
+  getAssetWithProof,
+  setCollectionV2,
+  MetadataArgsV2Args
+} from '@metaplex-foundation/mpl-bubblegum'
+import {
+  unwrapOption,
+  none,
+} from '@metaplex-foundation/umi';
+
+const assetWithProof = await getAssetWithProof(umi, assetId, {truncateCanopy: true});
+
+const collection = unwrapOption(assetWithProof.metadata.collection)
+
+const signature = await setCollectionV2(umi, {
+  ...assetWithProof,
+  authority: collectionAuthoritySigner,
+  coreCollection: collection!.key
+}).sendAndConfirm(umi);
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/bubblegum-v2/concurrent-merkle-trees.md

@@ -0,0 +1,329 @@
+---
+title: 동시 머클 트리
+metaTitle: 동시 머클 트리 | Bubblegum V2
+description: 동시 머클 트리와 Bubblegum에서 사용되는 방식에 대해 자세히 알아보세요.
+---
+
+## 소개
+
+머클 트리는 각 리프 노드가 일부 데이터를 나타내는 해시로 레이블이 지정된 트리 데이터 구조입니다. 인접한 리프들이 함께 해싱되고, 결과 해시가 해당 리프들의 부모인 노드의 레이블이 됩니다. 같은 레벨의 노드들이 다시 함께 해싱되고, 결과 해시가 해당 노드들의 부모인 노드의 레이블이 됩니다. 이 과정은 루트 노드에 대해 단일 해시가 생성될 때까지 계속됩니다. 이 단일 해시는 전체 트리의 데이터 무결성을 암호학적으로 나타내며 머클 루트라고 합니다.
+
+대부분의 머클 트리는 이진 트리이지만 반드시 그럴 필요는 없습니다. Bubblegum 압축된 NFT(cNFT)에 사용되는 머클 트리는 다이어그램에 표시된 것처럼 이진 트리입니다.
+
+{% diagram %}
+
+{% node %}
+{% node #root label="머클 루트" /%}
+{% node label="해시(노드 1, 노드 2)" /%}
+{% /node %}
+
+{% node parent="root" y=100 x=-220 %}
+{% node #i-node-1 label="노드 1" /%}
+{% node label="해시(노드 3, 노드 4)" /%}
+{% /node %}
+
+{% node parent="root" y=100 x=220 %}
+{% node #i-node-2 label="노드 2" /%}
+{% node label="해시(노드 5, 노드 6)" /%}
+{% /node %}
+
+{% node parent="i-node-1" y=100 x=-110 %}
+{% node #i-node-3 label="노드 3" /%}
+{% node label="해시(리프 1, 리프 2)" /%}
+{% /node %}
+
+{% node parent="i-node-1" y=100 x=110 %}
+{% node #i-node-4 label="노드 4" /%}
+{% node label="해시(리프 3, 리프 4)" /%}
+{% /node %}
+
+{% node parent="i-node-2" y=100 x=-110 %}
+{% node #i-node-5 label="노드 5" /%}
+{% node label="해시(리프 5, 리프 6)" /%}
+{% /node %}
+
+{% node parent="i-node-2" y=100 x=110 %}
+{% node #i-node-6 label="노드 6" /%}
+{% node label="해시(리프 7, 리프 8)" /%}
+{% /node %}
+
+{% node parent="i-node-3" y="100" x="-40" %}
+{% node #leaf-1 label="리프 1" /%}
+{% node label="해시(cNFT 1)" /%}
+{% /node %}
+
+{% node parent="i-node-3" y="100" x="70" %}
+{% node #leaf-2 label="리프 2" /%}
+{% node label="해시(cNFT 2)" /%}
+{% /node %}
+
+{% node parent="i-node-4" y="100" x="-40" %}
+{% node #leaf-3 label="리프 3" /%}
+{% node label="해시(cNFT 3)" /%}
+{% /node %}
+
+{% node parent="i-node-4" y="100" x="70" %}
+{% node #leaf-4 label="리프 4" /%}
+{% node label="해시(cNFT 4)" /%}
+{% /node %}
+
+{% node parent="i-node-5" y="100" x="-40" %}
+{% node #leaf-5 label="리프 5" /%}
+{% node label="해시(cNFT 5)" /%}
+{% /node %}
+
+{% node parent="i-node-5" y="100" x="70" %}
+{% node #leaf-6 label="리프 6" /%}
+{% node label="해시(cNFT 6)" /%}
+{% /node %}
+
+{% node parent="i-node-6" y="100" x="-40" %}
+{% node #leaf-7 label="리프 7" /%}
+{% node label="해시(cNFT 7)" /%}
+{% /node %}
+
+{% node parent="i-node-6" y="100" x="70" %}
+{% node #leaf-8 label="리프 8" /%}
+{% node label="해시(cNFT 8)" /%}
+{% /node %}
+
+{% edge from="i-node-1" to="root" fromPosition="top" toPosition="bottom" /%}
+{% edge from="i-node-2" to="root" fromPosition="top" toPosition="bottom" /%}
+
+{% edge from="i-node-3" to="i-node-1" fromPosition="top" toPosition="bottom" /%}
+{% edge from="i-node-4" to="i-node-1" fromPosition="top" toPosition="bottom" /%}
+{% edge from="i-node-6" to="i-node-2" fromPosition="top" toPosition="bottom" /%}
+{% edge from="i-node-5" to="i-node-2" fromPosition="top" toPosition="bottom" /%}
+
+{% edge from="leaf-1" to="i-node-3" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-2" to="i-node-3" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-4" to="i-node-4" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-3" to="i-node-4" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-5" to="i-node-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-6" to="i-node-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-7" to="i-node-6" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-8" to="i-node-6" fromPosition="top" toPosition="bottom" /%}
+
+{% /diagram %}
+
+블록체인에 데이터 상태를 저장하는 것에 대해 이야기할 때, 이 머클 루트를 저장하면 루트를 생성하기 위해 이전에 해싱된 모든 것의 데이터 무결성을 나타내는 단일 값을 효과적으로 저장할 수 있습니다. 트리의 어떤 리프 값이 변경되면 기존 머클 루트는 무효가 되고 다시 계산되어야 합니다.
+
+Bubblegum 압축된 NFT의 경우 리프 노드 해시는 [리프 스키마](https://github.com/metaplex-foundation/mpl-bubblegum/blob/main/programs/bubblegum-v2/program/src/state/leaf_schema.rs#L40)의 해시입니다. 리프 스키마는 리프 ID, 소유자/위임자 정보, cNFT의 [크리에이터](https://github.com/metaplex-foundation/mpl-bubblegum/blob/main/programs/bubblegum-v2/program/src/state/metaplex_adapter.rs#L103)를 나타내는 [`creator_hash`](https://github.com/metaplex-foundation/mpl-bubblegum/blob/main/programs/bubblegum-v2/program/src/lib.rs#L433), 그리고 일반적으로 압축된 NFT의 [메타데이터](https://github.com/metaplex-foundation/mpl-bubblegum/blob/main/programs/bubblegum-v2/program/src/state/metaplex_adapter.rs#L81)를 나타내는 [`data_hash`](https://github.com/metaplex-foundation/mpl-bubblegum/blob/main/programs/bubblegum-v2/program/src/lib.rs#L450)(크리에이터 배열을 다시 포함)을 포함합니다. 따라서 단일 압축된 NFT를 암호학적으로 확인하는 데 필요한 모든 정보가 해싱된 리프 스키마에 저장됩니다.
+
+## 리프 경로
+
+이전 섹션에서 배운 것처럼, 머클 트리에서는 리프 노드만이 최종 사용자 데이터를 나타냅니다. 해시로 이어지는 내부 노드들은 모두 머클 루트를 위한 중간 값일 뿐입니다. 리프 노드의 **경로**를 언급할 때, 리프 노드 해시 자체와 머클 루트로 직접 이어지는 내부 노드들을 의미합니다. 예를 들어, 리프 2의 경로가 아래 다이어그램에 강조 표시되어 있습니다.
+
+{% diagram %}
+
+{% node %}
+{% node #root label="머클 루트" theme="blue" /%}
+{% node label="해시(노드 1, 노드 2)" theme="blue" /%}
+{% /node %}
+
+{% node parent="root" y=100 x=-220 %}
+{% node #i-node-1 label="노드 1" theme="blue" /%}
+{% node label="해시(노드 3, 노드 4)" theme="blue" /%}
+{% /node %}
+
+{% node parent="root" y=100 x=220 %}
+{% node #i-node-2 label="노드 2" /%}
+{% node label="해시(노드 5, 노드 6)" /%}
+{% /node %}
+
+{% node parent="i-node-1" y=100 x=-110 %}
+{% node #i-node-3 label="노드 3" theme="blue" /%}
+{% node label="해시(리프 1, 리프 2)" theme="blue" /%}
+{% /node %}
+
+{% node parent="i-node-1" y=100 x=110 %}
+{% node #i-node-4 label="노드 4" /%}
+{% node label="해시(리프 3, 리프 4)" /%}
+{% /node %}
+
+{% node parent="i-node-2" y=100 x=-110 %}
+{% node #i-node-5 label="노드 5" /%}
+{% node label="해시(리프 5, 리프 6)" /%}
+{% /node %}
+
+{% node parent="i-node-2" y=100 x=110 %}
+{% node #i-node-6 label="노드 6" /%}
+{% node label="해시(리프 7, 리프 8)" /%}
+{% /node %}
+
+{% node parent="i-node-3" y="100" x="-40" %}
+{% node #leaf-1 label="리프 1" /%}
+{% node label="해시(cNFT 1)" /%}
+{% /node %}
+
+{% node parent="i-node-3" y="100" x="70" %}
+{% node #leaf-2 label="리프 2" theme="blue" /%}
+{% node label="해시(cNFT 2)" theme="blue" /%}
+{% /node %}
+
+{% node parent="i-node-4" y="100" x="-40" %}
+{% node #leaf-3 label="리프 3" /%}
+{% node label="해시(cNFT 3)" /%}
+{% /node %}
+
+{% node parent="i-node-4" y="100" x="70" %}
+{% node #leaf-4 label="리프 4" /%}
+{% node label="해시(cNFT 4)" /%}
+{% /node %}
+
+{% node parent="i-node-5" y="100" x="-40" %}
+{% node #leaf-5 label="리프 5" /%}
+{% node label="해시(cNFT 5)" /%}
+{% /node %}
+
+{% node parent="i-node-5" y="100" x="70" %}
+{% node #leaf-6 label="리프 6" /%}
+{% node label="해시(cNFT 6)" /%}
+{% /node %}
+
+{% node parent="i-node-6" y="100" x="-40" %}
+{% node #leaf-7 label="리프 7" /%}
+{% node label="해시(cNFT 7)" /%}
+{% /node %}
+
+{% node parent="i-node-6" y="100" x="70" %}
+{% node #leaf-8 label="리프 8" /%}
+{% node label="해시(cNFT 8)" /%}
+{% /node %}
+
+{% edge from="i-node-1" to="root" fromPosition="top" toPosition="bottom" theme="blue" animated=true /%}
+{% edge from="i-node-2" to="root" fromPosition="top" toPosition="bottom" /%}
+
+{% edge from="i-node-3" to="i-node-1" fromPosition="top" toPosition="bottom" theme="blue" animated=true /%}
+{% edge from="i-node-4" to="i-node-1" fromPosition="top" toPosition="bottom" /%}
+{% edge from="i-node-6" to="i-node-2" fromPosition="top" toPosition="bottom" /%}
+{% edge from="i-node-5" to="i-node-2" fromPosition="top" toPosition="bottom" /%}
+
+{% edge from="leaf-1" to="i-node-3" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-2" to="i-node-3" fromPosition="top" toPosition="bottom" theme="blue" animated=true /%}
+{% edge from="leaf-4" to="i-node-4" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-3" to="i-node-4" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-5" to="i-node-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-6" to="i-node-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-7" to="i-node-6" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-8" to="i-node-6" fromPosition="top" toPosition="bottom" /%}
+
+{% /diagram %}
+
+## 리프 증명
+
+압축된 NFT가 머클 트리에 존재하는지 증명하려면 모든 리프 노드를 다시 해싱할 필요가 없습니다. 아래 다이어그램에서 볼 수 있듯이 머클 루트를 계산할 때까지 함께 해싱할 특정 값들만 있으면 됩니다. 이러한 값들을 리프의 **증명**이라고 합니다. 구체적으로, 리프 노드의 증명은 인접한 리프 노드의 해시와 머클 루트를 계산하는 데 사용할 수 있는 인접한 내부 노드 해시들입니다. 리프 2의 증명이 아래 다이어그램에 강조 표시되어 있습니다.
+
+{% diagram %}
+
+{% node %}
+{% node #root label="머클 루트" /%}
+{% node label="해시(노드 1, 노드 2)" /%}
+{% /node %}
+
+{% node parent="root" y=100 x=-220 %}
+{% node #i-node-1 label="노드 1" /%}
+{% node label="해시(노드 3, 노드 4)" /%}
+{% /node %}
+
+{% node parent="root" y=100 x=220 %}
+{% node #i-node-2 label="노드 2" theme="mint" /%}
+{% node label="해시(노드 5, 노드 6)" theme="mint" /%}
+{% /node %}
+
+{% node parent="i-node-1" y=100 x=-110 %}
+{% node #i-node-3 label="노드 3" /%}
+{% node label="해시(리프 1, 리프 2)" /%}
+{% /node %}
+
+{% node parent="i-node-1" y=100 x=110 %}
+{% node #i-node-4 label="노드 4" theme="mint" /%}
+{% node label="해시(리프 3, 리프 4)" theme="mint" /%}
+{% /node %}
+
+{% node parent="i-node-2" y=100 x=-110 %}
+{% node #i-node-5 label="노드 5" /%}
+{% node label="해시(리프 5, 리프 6)" /%}
+{% /node %}
+
+{% node parent="i-node-2" y=100 x=110 %}
+{% node #i-node-6 label="노드 6" /%}
+{% node label="해시(리프 7, 리프 8)" /%}
+{% /node %}
+
+{% node parent="i-node-3" y="100" x="-40" %}
+{% node #leaf-1 label="리프 1" theme="mint" /%}
+{% node label="해시(cNFT 1)" theme="mint" /%}
+{% /node %}
+
+{% node parent="i-node-3" y="100" x="70" %}
+{% node #leaf-2 label="리프 2" theme="blue" /%}
+{% node label="해시(cNFT 2)" theme="blue" /%}
+{% /node %}
+
+{% node parent="i-node-4" y="100" x="-40" %}
+{% node #leaf-3 label="리프 3" /%}
+{% node label="해시(cNFT 3)" /%}
+{% /node %}
+
+{% node parent="i-node-4" y="100" x="70" %}
+{% node #leaf-4 label="리프 4" /%}
+{% node label="해시(cNFT 4)" /%}
+{% /node %}
+
+{% node parent="i-node-5" y="100" x="-40" %}
+{% node #leaf-5 label="리프 5" /%}
+{% node label="해시(cNFT 5)" /%}
+{% /node %}
+
+{% node parent="i-node-5" y="100" x="70" %}
+{% node #leaf-6 label="리프 6" /%}
+{% node label="해시(cNFT 6)" /%}
+{% /node %}
+
+{% node parent="i-node-6" y="100" x="-40" %}
+{% node #leaf-7 label="리프 7" /%}
+{% node label="해시(cNFT 7)" /%}
+{% /node %}
+
+{% node parent="i-node-6" y="100" x="70" %}
+{% node #leaf-8 label="리프 8" /%}
+{% node label="해시(cNFT 8)" /%}
+{% /node %}
+
+{% edge from="i-node-1" to="root" fromPosition="top" toPosition="bottom" /%}
+{% edge from="i-node-2" to="root" fromPosition="top" toPosition="bottom" /%}
+
+{% edge from="i-node-3" to="i-node-1" fromPosition="top" toPosition="bottom" /%}
+{% edge from="i-node-4" to="i-node-1" fromPosition="top" toPosition="bottom" /%}
+{% edge from="i-node-6" to="i-node-2" fromPosition="top" toPosition="bottom" /%}
+{% edge from="i-node-5" to="i-node-2" fromPosition="top" toPosition="bottom" /%}
+
+{% edge from="leaf-1" to="i-node-3" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-2" to="i-node-3" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-4" to="i-node-4" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-3" to="i-node-4" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-5" to="i-node-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-6" to="i-node-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-7" to="i-node-6" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-8" to="i-node-6" fromPosition="top" toPosition="bottom" /%}
+
+{% /diagram %}
+
+## 리프 검증
+
+리프 노드와 그 증명을 사용하여 머클 루트를 계산하는 과정은 다음과 같습니다:
+1. 원시 리프 스키마로 시작하여 해싱합니다.
+2. 1단계의 값을 형제 리프 노드의 해시와 해싱하여 리프 경로의 다음 값을 생성합니다.
+3. 2단계의 경로 값을 증명의 다음 값인 다음 형제 내부 노드와 해싱합니다.
+4. 머클 루트를 계산할 때까지 형제 내부 노드 값들과 값을 해싱하는 이 과정을 트리 위쪽으로 계속합니다.
+
+우리가 계산한 머클 루트가 해당 트리에 대해 주어진 머클 루트와 일치하면 정확한 리프 노드가 머클 트리에 존재한다는 것을 알 수 있습니다. 또한 리프 노드가 업데이트될 때마다(즉, cNFT가 새 소유자에게 전송될 때) 새로운 머클 루트를 계산하고 온체인에서 업데이트해야 합니다.
+
+## 동시성
+
+cNFT에 사용되는 온체인 머클 트리는 동일한 블록에서 여러 쓰기를 처리할 수 있어야 합니다. 트리에 새로운 cNFT를 민팅하고, cNFT를 전송하고, cNFT를 위임하고, cNFT를 소각하는 등의 여러 트랜잭션이 있을 수 있기 때문입니다. 문제는 온체인 트리에 대한 첫 번째 쓰기가 동일한 블록 내의 다른 쓰기를 위해 전송된 증명을 무효화한다는 것입니다.
+
+이에 대한 해결책은 [spl-account-compression](https://spl.solana.com/account-compression)에서 사용하는 머클 트리가 하나의 머클 루트만 저장하는 것이 아니라 이전 루트들과 이전에 수정된 리프들의 경로에 대한 [`ChangeLog`](https://github.com/solana-labs/solana-program-library/blob/master/libraries/concurrent-merkle-tree/src/changelog.rs#L9)도 저장한다는 것입니다. 새 트랜잭션이 보낸 루트와 증명이 이전 업데이트로 무효화되었더라도 프로그램이 증명을 빨리 감습니다. 사용 가능한 `ChangeLog` 수는 트리를 생성할 때 사용되는 [최대 버퍼 크기](/kr/bubblegum-v2/create-trees#creating-a-bubblegum-tree)에 의해 설정됩니다.
+
+또한 머클 트리의 가장 오른쪽 증명이 온체인에 저장됩니다. 이를 통해 증명을 보낼 필요 없이 트리에 추가할 수 있습니다. 이것이 바로 Bubblegum이 증명 없이 새로운 cNFT를 민팅할 수 있는 방법입니다.

src/pages/kr/bubblegum-v2/create-trees.md

@@ -0,0 +1,181 @@
+---
+title: Bubblegum 트리 생성
+metaTitle: Bubblegum 트리 생성 | Bubblegum V2
+description: 압축된 NFT를 보관할 수 있는 새로운 머클 트리를 생성하고 가져오는 방법을 알아보세요.
+---
+
+## 소개
+
+압축된 NFT의 데이터는 트랜잭션 내에 저장되고 온체인 계정에 저장되지 않지만, 여전히 머클 트리와 그 구성을 추적하기 위한 일부 온체인 계정이 필요합니다. 따라서 압축된 NFT를 민팅하기 시작하기 전에 두 개의 계정을 생성해야 합니다:
+
+- **머클 트리 계정**. 이 계정은 모든 유형의 데이터의 진위를 확인하는 데 사용할 수 있는 일반적인 머클 트리를 보관합니다. [SPL Account Compression Program](https://spl.solana.com/account-compression)에서 포크된 [MPL Account Compression Program](https://github.com/metaplex-foundation/mpl-account-compression)이 소유합니다. 우리의 경우, 압축된 NFT의 진위를 확인하는 데 사용할 것입니다.
+- **TreeConfigV2 계정**. 이 두 번째 계정은 머클 트리 계정의 주소에서 파생된 PDA입니다. 압축된 NFT에 특정한 머클 트리의 추가 구성(예: 트리 제작자, 민팅된 cNFT 수 등)을 저장할 수 있습니다.
+
+이 두 계정으로 압축된 NFT를 민팅하기 시작하는 데 필요한 모든 것이 있습니다. 연관된 트리 구성 계정이 있는 머클 트리 계정을 **Bubblegum 트리**라고 부르겠습니다.
+
+{% diagram height="h-64 md:h-[200px]" %}
+
+{% node %}
+{% node #merkle-tree label="머클 트리 계정" theme="blue" /%}
+{% node label="소유자: Account Compression Program" theme="dimmed" /%}
+{% /node %}
+
+{% node #tree-config-pda parent="merkle-tree" x="300" label="PDA" theme="crimson" /%}
+
+{% node parent="tree-config-pda" y="60" %}
+{% node #tree-config label="트리 구성 계정" theme="crimson" /%}
+{% node label="소유자: Bubblegum Program" theme="dimmed" /%}
+{% /node %}
+
+{% edge from="merkle-tree" to="tree-config-pda" /%}
+{% edge from="tree-config-pda" to="tree-config" /%}
+
+{% /diagram %}
+
+## Bubblegum 트리 생성
+
+이제 Bubblegum 트리를 만들기 위해 이 두 계정을 모두 생성하는 방법을 살펴보겠습니다. 다행히 우리 라이브러리는 모든 것을 처리하는 **트리 생성** 작업을 제공하여 이 과정을 쉽게 만들어줍니다. 이 작업은 Bubblegum 트리를 우리의 요구에 맞게 사용자 정의할 수 있는 다양한 매개변수(대부분 선택사항)를 받아들입니다. 가장 중요한 것들은 다음과 같습니다:
+
+- **머클 트리**: 머클 트리 계정을 생성하는 데 사용될 새로 생성된 서명자입니다. 그러면 머클 트리 계정이 이 주소에서 액세스 가능해집니다.
+- **트리 제작자**: Bubblegum 트리를 관리하고 압축된 NFT를 민팅할 수 있는 계정의 주소입니다.
+- **최대 깊이**와 **최대 버퍼 크기**: **최대 깊이** 매개변수는 머클 트리가 보관할 수 있는 최대 리프 수(따라서 압축된 NFT 수)를 계산하는 데 사용됩니다. 이 최대값은 `2^maxDepth`로 계산됩니다. **최대 버퍼 크기** 매개변수는 머클 트리의 최소 동시성 제한을 나타냅니다. 다시 말해, 트리에서 병렬로 발생할 수 있는 변경 수를 정의합니다. 이 두 매개변수는 임의로 선택할 수 없으며 아래 표에 표시된 대로 미리 정의된 값 집합에서 선택해야 합니다.
+
+다음은 Solana 생태계 내 호환성을 위한 권장 트리 설정입니다.
+
+| cNFT 수 | 트리 깊이 | 캐노피 깊이 | 동시성 버퍼 | 트리 비용 | cNFT당 비용 |
+| --------------- | ---------- | ------------ | ------------------ | --------- | ------------- |
+| 16,384          | 14         | 8            | 64                 | 0.3358    | 0.00002550    |
+| 65,536          | 16         | 10           | 64                 | 0.7069    | 0.00001579    |
+| 262,144         | 18         | 12           | 64                 | 2.1042    | 0.00001303    |
+| 1,048,576       | 20         | 13           | 1024               | 8.5012    | 0.00001311    |
+| 16,777,216      | 24         | 15           | 2048               | 26.1201   | 0.00000656    |
+| 67,108,864      | 26         | 17           | 2048               | 70.8213   | 0.00000606    |
+| 1,073,741,824   | 30         | 17           | 2048               | 72.6468   | 0.00000507    |
+
+트리의 최대 깊이는 다음과 같습니다:
+
+  {% totem %}
+  {% totem-accordion title="최대 깊이 / 최대 버퍼 크기 테이블" %}
+
+  | 최대 깊이 | 최대 버퍼 크기 | 최대 cNFT 수 |
+  | --------- | --------------- | ------------------- |
+  | 3         | 8               | 8                   |
+  | 5         | 8               | 32                  |
+  | 14        | 64              | 16,384              |
+  | 14        | 256             | 16,384              |
+  | 14        | 1,024           | 16,384              |
+  | 14        | 2,048           | 16,384              |
+  | 15        | 64              | 32,768              |
+  | 16        | 64              | 65,536              |
+  | 17        | 64              | 131,072             |
+  | 18        | 64              | 262,144             |
+  | 19        | 64              | 524,288             |
+  | 20        | 64              | 1,048,576           |
+  | 20        | 256             | 1,048,576           |
+  | 20        | 1,024           | 1,048,576           |
+  | 20        | 2,048           | 1,048,576           |
+  | 24        | 64              | 16,777,216          |
+  | 24        | 256             | 16,777,216          |
+  | 24        | 512             | 16,777,216          |
+  | 24        | 1,024           | 16,777,216          |
+  | 24        | 2,048           | 16,777,216          |
+  | 26        | 512             | 67,108,864          |
+  | 26        | 1,024           | 67,108,864          |
+  | 26        | 2,048           | 67,108,864          |
+  | 30        | 512             | 1,073,741,824       |
+  | 30        | 1,024           | 1,073,741,824       |
+  | 30        | 2,048           | 1,073,741,824       |
+
+  {% /totem-accordion %}
+  {% /totem %}
+
+- **공개**: Bubblegum 트리가 공개되어야 하는지 여부입니다. 공개된 경우 누구나 그것으로부터 압축된 NFT를 민팅할 수 있습니다. 그렇지 않으면 트리 제작자 또는 트리 위임자([cNFT 위임](/kr/bubblegum-v2/delegate-cnfts)에서 논의)만이 압축된 NFT를 민팅할 수 있습니다.
+
+다음은 우리 라이브러리를 사용하여 Bubblegum 트리를 생성하는 방법입니다:
+
+{% dialect-switcher title="Bubblegum 트리 생성" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import { generateSigner } from '@metaplex-foundation/umi'
+import { createTreeV2 } from '@metaplex-foundation/mpl-bubblegum'
+
+const merkleTree = generateSigner(umi)
+const builder = await createTreeV2(umi, {
+        merkleTree,
+        maxBufferSize: 64,
+        maxDepth: 14,
+      })
+
+await builder.sendAndConfirm(umi)
+```
+
+기본적으로 트리 제작자는 Umi 신원으로 설정되고 공개 매개변수는 `false`로 설정됩니다. 하지만 아래 예제에서 보는 것처럼 이러한 매개변수를 사용자 정의할 수 있습니다.
+
+```ts
+const customTreeCreator = generateSigner(umi)
+const builder = await createTreeV2(umi, {
+  // ...
+  treeCreator: customTreeCreator,
+  public: true,
+})
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## Bubblegum 트리 가져오기
+
+**Bubblegum 트리**는 두 개의 온체인 계정으로 구성되므로 그 중 하나를 가져오는 방법을 살펴보겠습니다.
+
+### 머클 트리 가져오기
+
+머클 트리 계정에는 다음과 같은 트리에 대한 다양한 정보가 포함됩니다:
+
+- **최대 깊이**, **최대 버퍼 크기**, 트리의 **권한** 및 트리가 생성된 **생성 슬롯**을 저장하는 **트리 헤더**.
+- **변경 로그**(또는 루트), **시퀀스 번호** 등과 같은 트리의 저수준 정보를 저장하는 **트리** 자체. 이 문서의 [전용 페이지](/kr/bubblegum-v2/concurrent-merkle-trees)에서 동시 머클 트리에 대해 더 자세히 이야기합니다.
+- [머클 트리 캐노피](/kr/bubblegum-v2/merkle-tree-canopy) 페이지에서 논의된 **캐노피**.
+
+다음은 우리 라이브러리를 사용하여 모든 데이터를 가져오는 방법입니다:
+
+{% dialect-switcher title="머클 트리 가져오기" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import {
+  fetchMerkleTree,
+} from "@metaplex-foundation/mpl-account-compression";
+
+const merkleTreeAccount = await fetchMerkleTree(umi, merkleTree)
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+### 트리 구성 가져오기
+
+트리 구성 계정에는 압축된 NFT에 특정한 데이터가 포함됩니다. 다음을 저장합니다:
+
+- Bubblegum 트리의 **트리 제작자**.
+- Bubblegum 트리의 **트리 위임자** (있는 경우). 그렇지 않으면 **트리 제작자**로 설정됩니다.
+- 트리에서 민팅할 수 있는 cNFT의 최대 수인 Bubblegum 트리의 **총 용량**.
+- 트리에 민팅된 cNFT 수를 추적하는 **민팅된 수**. 이 값은 머클 트리 리프가 고유하도록 하는 작업에 대한 **넌스**("한 번 사용되는 수") 값으로 사용되기 때문에 중요합니다. 따라서 이 넌스는 자산의 트리 범위 고유 식별자 역할을 합니다.
+- 트리에서 누구나 cNFT를 민팅할 수 있는지 여부를 나타내는 **공개** 매개변수.
+- **압축 해제 가능**은 Bubblegum V1에서만 유효합니다.
+- **버전**은 사용할 수 있는 LeafSchema의 버전입니다.
+
+다음은 우리 라이브러리를 사용하여 모든 데이터를 가져오는 방법입니다:
+
+{% dialect-switcher title="트리 구성 가져오기" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { fetchTreeConfigFromSeeds } from '@metaplex-foundation/mpl-bubblegum';
+
+const treeConfig = await fetchTreeConfigFromSeeds(umi, { merkleTree });
+```
+
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/bubblegum-v2/delegate-cnfts.md

@@ -0,0 +1,70 @@
+---
+title: 압축된 NFT 위임
+metaTitle: 압축된 NFT 위임 | Bubblegum V2
+description: Bubblegum에서 압축된 NFT를 위임하는 방법을 알아보세요.
+---
+
+압축된 NFT의 소유자는 cNFT의 소유권을 유지하면서 다른 계정에 위임할 수 있습니다. {% .lead %}
+
+이를 통해 **위임 권한**이라고도 하는 위임된 계정이 소유자를 대신하여 작업을 수행할 수 있습니다. 이러한 작업은 다음과 같습니다:
+
+- [cNFT 전송](/kr/bubblegum-v2/transfer-cnfts): 위임 권한은 전송 후 재설정됩니다. 즉, 새 소유자로 설정됩니다.
+- [cNFT 소각](/kr/bubblegum-v2/burn-cnfts).
+- [cNFT 동결 및 해동](/kr/bubblegum-v2/freeze-cnfts).
+
+이러한 각 작업은 위임 권한을 사용하여 수행하는 방법의 예제를 제공합니다. 일반적으로 **리프 소유자** 계정 대신 **리프 위임자** 계정을 서명자로 제공하기만 하면 됩니다.
+압축된 NFT에 대한 위임 권한을 승인하고 취소하는 방법을 살펴보겠습니다.
+
+## 위임 권한 승인
+
+위임 권한을 승인하거나 교체하려면 소유자가 **위임** 명령어를 보내야 합니다. 이 명령어는 다음 매개변수를 받아들입니다:
+
+- **리프 소유자**: 서명자로서 압축된 NFT의 현재 소유자. 기본적으로 트랜잭션의 지불자로 설정됩니다.
+- **이전 리프 위임자**: 이전 위임 권한(있는 경우). 그렇지 않으면 **리프 소유자**로 설정되어야 합니다.
+- **새 리프 위임자**: 승인할 새 위임 권한.
+
+추가로 이 명령어는 Bubblegum 트리의 리프를 교체하므로 압축된 NFT의 무결성을 확인하기 위해 더 많은 매개변수를 제공해야 합니다. 이러한 매개변수는 리프를 변경하는 모든 명령어에 공통이므로 [다음 FAQ](/kr/bubblegum-v2/faq#replace-leaf-instruction-arguments)에 문서화되어 있습니다. 다행히 Metaplex DAS API를 사용하여 이러한 매개변수를 자동으로 가져오는 도우미 메서드를 사용할 수 있습니다.
+
+{% dialect-switcher title="압축된 NFT 위임" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import { getAssetWithProof, delegate } from '@metaplex-foundation/mpl-bubblegum';
+
+const assetWithProof = await getAssetWithProof(umi, assetId, { truncateCanopy: true });
+await delegate(umi, {
+  ...assetWithProof,
+  leafOwner,
+  previousLeafDelegate: leafOwner.publicKey,
+  newLeafDelegate: newDelegate,
+}).sendAndConfirm(umi);
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 위임 권한 취소
+
+기존 위임 권한을 취소하려면 소유자가 자신을 새 위임 권한으로 설정하기만 하면 됩니다.
+
+{% dialect-switcher title="압축된 NFT의 위임 권한 취소" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import { getAssetWithProof, delegate } from '@metaplex-foundation/mpl-bubblegum';
+
+const assetWithProof = await getAssetWithProof(umi, assetId, {truncateCanopy: true});
+await delegate(umi, {
+  ...assetWithProof,
+  leafOwner,
+  previousLeafDelegate: currentDelegate,
+  newLeafDelegate: leafOwner.publicKey,
+}).sendAndConfirm(umi);
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/bubblegum-v2/delegate-trees.md

@@ -0,0 +1,57 @@
+---
+title: 트리 위임
+metaTitle: 트리 위임 | Bubblegum V2
+description: Bubblegum에서 머클 트리를 위임하는 방법을 알아보세요.
+---
+
+압축된 NFT의 소유자가 위임 권한을 승인할 수 있는 것과 마찬가지로 Bubblegum 트리의 제작자도 다른 계정을 승인하여 대신 작업을 수행할 수 있습니다. {% .lead %}
+
+Bubblegum 트리에 대해 위임 권한이 승인되면 제작자를 대신하여 [압축된 NFT를 민팅](/kr/bubblegum-v2/mint-cnfts)할 수 있게 됩니다. 이는 개인 트리에서만 관련이 있으며, 공개 트리에서는 누구나 민팅할 수 있습니다.
+
+## 트리에 대한 위임 권한 승인
+
+Bubblegum 트리에서 새로운 위임 권한을 승인하려면 제작자가 **트리 위임 설정** 명령어를 사용할 수 있습니다. 다음 매개변수를 받아들입니다:
+
+- **머클 트리**: 위임할 머클 트리의 주소.
+- **트리 제작자**: 서명자로서 머클 트리의 제작자.
+- **새 트리 위임자**: 승인할 새 위임 권한.
+
+{% dialect-switcher title="Bubblegum 트리 위임" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import { setTreeDelegate } from '@metaplex-foundation/mpl-bubblegum'
+
+await setTreeDelegate(umi, {
+  merkleTree,
+  treeCreator,
+  newTreeDelegate,
+}).sendAndConfirm(umi)
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 트리에 대한 위임 권한 취소
+
+기존 위임 권한을 취소하려면 트리의 제작자가 자신을 새 위임 권한으로 설정하기만 하면 됩니다.
+
+{% dialect-switcher title="Bubblegum 트리의 위임 권한 취소" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import { setTreeDelegate } from '@metaplex-foundation/mpl-bubblegum'
+
+await setTreeDelegate(umi, {
+  merkleTree,
+  treeCreator,
+  newTreeDelegate: treeCreator.publicKey,
+}).sendAndConfirm(umi)
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/bubblegum-v2/faq.md

@@ -0,0 +1,114 @@
+---
+title: FAQ
+metaTitle: FAQ | Bubblegum V2
+description: Bubblegum에 대한 자주 묻는 질문.
+---
+
+## Bubblegum V2란 무엇인가요?
+
+Bubblegum V2는 여러 개선 사항과 새로운 기능을 도입하는 Bubblegum 프로그램의 새로운 반복입니다.
+이는 알려진 Bubblegum 프로그램의 일부이지만 명령어와 데이터 구조가 다릅니다.
+Bubblegum V2를 사용하면 cNFT가 Metaplex Token Metadata 컬렉션 대신 MPL-Core 컬렉션을 사용하여 그룹화됩니다. 또한 동결, 해동, 소울바운드 NFT와 같은 새로운 기능과 다음과 같은 추가 기능을 도입합니다:
+- **동결 및 해동 기능**: 프로젝트 제작자는 이제 cNFT를 동결하고 해동할 수 있어 특정 이벤트 중 전송을 방지하거나 베스팅 메커니즘을 구현하는 등 다양한 사용 사례를 위해 자산을 더 잘 제어할 수 있습니다.
+- **MPL-Core 컬렉션 통합**: Bubblegum V2 NFT는 이제 토큰 메타데이터 컬렉션에 제한되지 않고 MPL-Core 컬렉션에 추가될 수 있어 더 넓은 Metaplex 생태계와의 유연성과 통합을 제공합니다.
+- **로열티 강제**: Bubblegum V2는 [MPL-Core](https://docs.metaplex.com/core/overview) 컬렉션을 사용하므로 `ProgramDenyList`를 사용하여 cNFT에 로열티를 강제할 수 있습니다.
+- **소울바운드 NFT**: cNFT는 이제 소울바운드(양도 불가능)로 만들 수 있어 소유자의 지갑에 영구적으로 바인딩됩니다. 이는 자격증명, 참석 증명, 신원 확인 등에 완벽합니다. 컬렉션에서 `PermanentFreezeDelegate` 플러그인이 활성화되어야 합니다.
+- **영구 전송 허용**: 컬렉션에서 `PermanentTransferDelegate` 플러그인이 활성화된 경우 영구 전송 위임자는 리프 소유자의 상호 작용 없이 cNFT를 새 소유자에게 전송할 수 있습니다.
+
+## 전송, 위임, 소각 등과 같은 작업에 필요한 인수를 어떻게 찾나요? {% #replace-leaf-instruction-arguments %}
+
+전송, 위임, 소각 등과 같이 Bubblegum 트리에서 리프를 교체하는 명령어를 사용할 때마다 프로그램은 현재 리프가 유효하고 업데이트될 수 있음을 확인하는 데 사용되는 많은 매개변수가 필요합니다. 압축된 NFT의 데이터가 온체인 계정 내에서 사용할 수 없기 때문에 **증명**, **리프 인덱스**, **넌스** 등과 같은 추가 매개변수가 프로그램이 조각들을 채우는 데 필요합니다.
+
+모든 정보는 `getAsset`과 `getAssetProof` RPC 메서드를 모두 사용하여 **Metaplex DAS API**에서 검색할 수 있습니다. 하지만 이러한 메서드의 RPC 응답과 명령어에서 예상하는 매개변수는 정확히 같지 않으며 하나에서 다른 것으로 파싱하는 것은 간단하지 않습니다.
+
+다행히 우리 SDK는 아래 코드 예제에서 볼 수 있듯이 모든 무거운 작업을 수행하는 도우미 메서드를 제공합니다. 압축된 NFT의 자산 ID를 받아들이고 소각, 전송, 업데이트 등과 같이 리프를 교체하는 명령어에 직접 주입할 수 있는 매개변수 묶음을 반환합니다.
+
+그렇긴 하지만, 파싱을 직접 해야 한다면 명령어에서 예상하는 매개변수와 Metaplex DAS API에서 검색하는 방법에 대한 간단한 분석은 다음과 같습니다. 여기서는 `getAsset`과 `getAssetProof` RPC 메서드의 결과가 각각 `rpcAsset`과 `rpcAssetProof` 변수를 통해 액세스 가능하다고 가정합니다.
+
+- **리프 소유자**: `rpcAsset.ownership.owner`를 통해 액세스 가능.
+- **리프 위임자**: `rpcAsset.ownership.delegate`를 통해 액세스 가능하며 null일 때 `rpcAsset.ownership.owner`로 기본 설정되어야 합니다.
+- **머클 트리**: `rpcAsset.compression.tree` 또는 `rpcAssetProof.tree_id`를 통해 액세스 가능.
+- **루트**: `rpcAssetProof.root`를 통해 액세스 가능.
+- **데이터 해시**: `rpcAsset.compression.data_hash`를 통해 액세스 가능.
+- **크리에이터 해시**: `rpcAsset.compression.creator_hash`를 통해 액세스 가능.
+- **넌스**: `rpcAsset.compression.leaf_id`를 통해 액세스 가능.
+- **인덱스**: `rpcAssetProof.node_index - 2^max_depth`를 통해 액세스 가능. 여기서 `max_depth`는 트리의 최대 깊이이며 `rpcAssetProof.proof` 배열의 길이에서 추론할 수 있습니다.
+- **증명**: `rpcAssetProof.proof`를 통해 액세스 가능.
+- **메타데이터**: 현재 `rpcAsset` 응답의 다양한 필드에서 재구성되어야 합니다.
+
+{% dialect-switcher title="리프를 교체하는 명령어를 위한 매개변수 가져오기" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+Bubblegum Umi 라이브러리는 위의 설명에 맞는 `getAssetWithProof` 도우미 메서드를 제공합니다. 다음은 `transfer` 명령어를 사용하는 예제입니다. 이 경우 `leafOwner` 매개변수가 서명자여야 하고 `assetWithProof`가 소유자를 공개 키로 제공하므로 `leafOwner` 매개변수를 재정의합니다.
+
+캐노피 크기에 따라 `getAssetWithProof` 도우미의 `truncateCanopy: true` 매개변수를 사용하는 것이 합리적일 수 있습니다. 트리 구성을 가져와 필요하지 않은 증명을 자릅니다. 트랜잭션 크기가 너무 커지면 도움이 됩니다.
+
+```ts
+import { getAssetWithProof, transfer } from '@metaplex-foundation/mpl-bubblegum'
+
+const assetWithProof = await getAssetWithProof(umi, assetId, 
+// {  truncateCanopy: true } // 증명을 가지치기하는 선택사항 
+);
+await transferV2(umi, {
+  ...assetWithProof,
+  leafOwner: leafOwnerA, // 서명자로서.
+  newLeafOwner: leafOwnerB.publicKey,
+}).sendAndConfirm(umi);
+
+await transferV2(umi, {
+  ...assetWithProof,
+  leafOwner: leafOwnerA, // 서명자로서.
+  newLeafOwner: leafOwnerB.publicKey,
+}).sendAndConfirm(umi)
+```
+
+{% totem-accordion title="도우미 함수 없이 매개변수 가져오기" %}
+
+완성도를 위해 제공된 도우미 함수를 사용하지 않고 동일한 결과를 얻는 방법은 다음과 같습니다.
+
+```ts
+import { publicKeyBytes } from '@metaplex-foundation/umi'
+import { transfer } from '@metaplex-foundation/mpl-bubblegum'
+
+const rpcAsset = await umi.rpc.getAsset(assetId)
+const rpcAssetProof = await umi.rpc.getAssetProof(assetId)
+
+await transfer(umi, {
+  leafOwner: leafOwnerA,
+  newLeafOwner: leafOwnerB.publicKey,
+  merkleTree: rpcAssetProof.tree_id,
+  root: publicKeyBytes(rpcAssetProof.root),
+  dataHash: publicKeyBytes(rpcAsset.compression.data_hash),
+  creatorHash: publicKeyBytes(rpcAsset.compression.creator_hash),
+  nonce: rpcAsset.compression.leaf_id,
+  index: rpcAssetProof.node_index - 2 ** rpcAssetProof.proof.length,
+  proof: rpcAssetProof.proof,
+}).sendAndConfirm(umi)
+```
+
+{% /totem-accordion %}
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## "트랜잭션이 너무 큽니다" 오류를 해결하는 방법 {% #transaction-size %}
+
+전송이나 소각과 같은 리프 교체 작업을 수행할 때 "트랜잭션이 너무 큽니다" 오류가 발생할 수 있습니다. 이를 해결하려면 다음 솔루션을 고려하세요:
+
+1. `truncateCanopy` 옵션 사용:
+   `getAssetWithProof` 함수에 `{ truncateCanopy: true }`를 전달하세요:
+
+   ```ts
+   const assetWithProof = await getAssetWithProof(umi, assetId, 
+    { truncateCanopy: true }
+   );
+   ```
+
+   이 옵션은 머클 트리 구성을 검색하고 캐노피를 기반으로 불필요한 증명을 제거하여 `assetWithProof`를 최적화합니다. 추가 RPC 호출이 추가되지만 트랜잭션 크기를 크게 줄입니다.
+
+2. 버전화된 트랜잭션과 주소 조회 테이블 활용:
+   다른 접근 방식은 [버전화된 트랜잭션과 주소 조회 테이블](https://developers.metaplex.com/umi/toolbox/address-lookup-table)을 구현하는 것입니다. 이 방법은 트랜잭션 크기를 더 효과적으로 관리하는 데 도움이 될 수 있습니다.
+
+이러한 기술을 적용하면 트랜잭션 크기 제한을 극복하고 작업을 성공적으로 실행할 수 있습니다.

src/pages/kr/bubblegum-v2/fetch-cnfts.md

@@ -0,0 +1,170 @@
+---
+title: 압축된 NFT 가져오기
+metaTitle: 압축된 NFT 가져오기 | Bubblegum V2
+description: Bubblegum에서 압축된 NFT를 가져오는 방법을 알아보세요.
+---
+
+[개요](/kr/bubblegum#read-api) 페이지에서 언급했듯이 압축된 NFT는 일반 NFT처럼 온체인 계정 내에 저장되지 않고 대신 이를 생성하고 업데이트한 트랜잭션에 기록됩니다. {% .lead %}
+
+따라서 압축된 NFT의 검색을 용이하게 하기 위해 특별한 인덱서가 생성되었습니다. 이 인덱스된 데이터는 **Metaplex DAS API**라고 하는 Solana RPC 메서드의 확장을 통해 사용할 수 있습니다. 실제로 DAS API를 통해 모든 **디지털 자산**을 가져올 수 있습니다. 이는 압축된 NFT, 일반 NFT, 또는 심지어 대체 가능한 자산일 수 있습니다.
+
+모든 RPC가 DAS API를 지원하지 않기 때문에 압축된 NFT를 작업할 계획이라면 RPC 제공업체를 신중하게 선택해야 합니다. Metaplex DAS API를 지원하는 모든 RPC 목록을 [전용 페이지](/kr/rpc-providers)에서 유지 관리하고 있습니다.
+
+이 페이지에서는 Metaplex DAS API를 사용하여 압축된 NFT를 가져오는 방법을 알아보겠습니다.
+
+## Metaplex DAS API SDK 설치
+
+Metaplex DAS API를 지원하는 RPC 제공업체를 선택했다면 압축된 NFT를 가져오기 위해 특별한 RPC 메서드를 보낼 수 있습니다. 하지만 우리 SDK는 도우미 메서드를 제공하여 DAS API를 시작하는 더 편리한 방법을 제공합니다. SDK를 사용하여 Metaplex DAS API를 시작하려면 아래 지침을 따르세요.
+
+{% totem %}
+
+{% dialect-switcher title="Metaplex DAS API 시작하기" %}
+{% dialect title="JavaScript" id="js" %}
+
+{% totem-prose %}
+Umi를 사용할 때 Metaplex DAS API 플러그인이 `mplBubblegum` 플러그인 내에 자동으로 설치됩니다. 따라서 이미 준비가 되어 있습니다!
+
+전체 `mplBubblegum` 플러그인을 가져오지 _않고_ DAS API 플러그인을 사용하려면 Metaplex DAS API 플러그인을 직접 설치하여 그렇게 할 수 있습니다:
+
+```sh
+npm install @metaplex-foundation/digital-asset-standard-api
+```
+
+그 후 Umi 인스턴스에 라이브러리를 등록합니다:
+
+```ts
+import { dasApi } from '@metaplex-foundation/digital-asset-standard-api';
+
+umi.use(dasApi());
+```
+{% /totem-prose %}
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+{% totem-prose %}
+
+Metaplex DAS API에서 사용할 수 있는 메서드에 대한 자세한 정보는 [저장소](https://github.com/metaplex-foundation/digital-asset-standard-api)에서 찾을 수 있습니다.
+
+{% /totem-prose %}
+{% /totem %}
+
+## 자산 ID {% #asset-ids %}
+
+압축되었든 아니든 NFT를 가져오려면 NFT를 식별하는 고유 ID에 액세스해야 합니다. 이 고유 식별자를 **자산 ID**라고 합니다.
+
+- 일반 NFT의 경우 다른 모든 계정이 해당 주소에서 파생되므로 해당 목적으로 **NFT의 민트 주소**를 사용합니다.
+- 압축된 NFT의 경우 **머클 트리의 주소**와 머클 트리에서 압축된 NFT의 **리프 인덱스**에서 파생되는 특별한 **PDA**(프로그램 파생 주소)를 사용합니다. 이 특별한 PDA를 **리프 자산 ID**라고 합니다.
+
+DAS API 메서드가 대량으로 압축된 NFT를 가져올 때(예: 주어진 주소가 소유한 모든 NFT 가져오기) 이를 제공하므로 일반적으로 **리프 자산 ID**를 직접 파생할 필요는 없습니다. 하지만 머클 트리의 주소와 cNFT의 리프 인덱스에 액세스할 수 있다면 SDK를 사용하여 리프 자산 ID를 파생하는 방법은 다음과 같습니다.
+
+{% dialect-switcher title="리프 자산 ID PDA 찾기" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { findLeafAssetIdPda } from '@metaplex-foundation/mpl-bubblegum'
+
+const [assetId, bump] = await findLeafAssetIdPda(umi, {
+  merkleTree,
+  leafIndex,
+})
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 압축된 NFT 가져오기
+
+압축된 NFT를 가져오는 것은 DAS API의 `getAsset` 메서드를 호출하는 것만큼 간단합니다. 이 메서드는 다음 정보를 포함하는 **Rpc Asset** 객체를 반환합니다:
+
+- **Id**: 위에서 논의한 자산 ID.
+- **Interface**: 우리가 다루고 있는 자산의 유형을 정의하는 특별한 값. 예: `V1_NFT` 또는 `ProgrammableNFT`.
+- **Ownership**: 자산을 누가 소유하는지 알려주는 객체. 설정되었을 수 있는 모든 위임자와 자산이 동결로 표시되었는지 여부를 포함합니다.
+- **Mutable**: 자산의 데이터가 업데이트 가능한지 여부를 나타내는 부울.
+- **Authorities**: 권한 배열. 각각은 권한이 자산에서 수행할 수 있는 작업을 나타내는 범위 배열을 포함합니다.
+- **Content**: 자산의 데이터를 포함하는 객체. 즉, URI와 파싱된 `metadata` 객체를 포함합니다.
+- **Royalty**: 자산이 정의한 로열티 모델을 정의하는 객체. 현재 자산의 크리에이터에게 수익의 백분율을 보내는 하나의 로열티 모델만 지원됩니다.
+- **Supply**: 인쇄 가능한 자산을 다룰 때 이 객체는 인쇄된 에디션의 현재 및 최대 공급량을 제공합니다.
+- **Creators**: 자산의 크리에이터 목록. 각각은 크리에이터가 확인되었는지 여부를 나타내는 `verified` 부울과 크리에이터에게 보내야 하는 로열티 백분율을 나타내는 `share` 숫자를 포함합니다.
+- **Grouping**: 자산을 대량으로 인덱싱하고 검색하는 데 도움이 되는 키/값 그룹화 메커니즘 배열. 현재 하나의 그룹화 메커니즘만 지원됩니다 — `collection` — 이를 통해 컬렉션별로 자산을 그룹화할 수 있습니다.
+- **Compression**: 압축된 NFT를 다룰 때 이 객체는 Bubblegum 트리의 리프에 대한 다양한 정보를 제공합니다. 예를 들어 리프의 전체 해시를 제공하지만 자산의 진위를 확인하는 데 사용되는 **크리에이터 해시**와 **데이터 해시**와 같은 부분 해시도 제공합니다. 또한 머클 트리 주소, 루트, 시퀀스 등을 제공합니다.
+
+다음은 SDK를 사용하여 주어진 자산 ID에서 자산을 가져오는 방법입니다.
+
+{% dialect-switcher title="압축된 NFT 가져오기" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+const rpcAsset = await umi.rpc.getAsset(assetId)
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 압축된 NFT의 증명 가져오기
+
+`getAsset` RPC 메서드가 자산에 대한 많은 정보를 반환하지만 자산의 **증명**은 반환하지 않습니다. [개요](/kr/bubblegum#merkle-trees-leaves-and-proofs) 페이지에서 언급했듯이 압축된 NFT의 증명은 자산의 진위를 확인할 수 있는 해시 목록입니다. 이것 없이는 누구나 주어진 데이터로 트리에 압축된 NFT를 가지고 있다고 가장할 수 있습니다.
+
+따라서 압축된 NFT의 많은 작업(예: 소각, 전송, 업데이트 등)은 이를 수행하기 전에 자산의 증명을 요구합니다. 자산의 증명을 계산하는 것은 가능하지만 누군가가 주어진 트리 내에 존재하는 모든 압축된 NFT의 해시를 알아야 합니다. 이것이 DAS API가 모든 압축된 NFT의 증명도 추적하는 이유입니다.
+
+압축된 NFT의 증명에 액세스하려면 `getAssetProof` RPC 메서드를 사용할 수 있습니다. 이 메서드는 다음 정보를 포함하는 **Rpc Asset Proof** 객체를 반환합니다:
+
+- **Proof**: 약속된 대로 압축된 NFT의 증명.
+- **Root**: 자산이 속한 머클 트리의 루트. 제공된 증명을 사용하여 자산을 확인할 때 최종 해시로 이 루트가 나와야 합니다.
+- **Node Index**: 트리의 모든 단일 노드를 왼쪽에서 오른쪽으로, 위에서 아래로 세면 머클 트리에서 자산의 인덱스. **리프 인덱스**라고 하는 더 유용한 인덱스는 다음 공식으로 이 값에서 추론할 수 있습니다: `leaf_index = node_index - 2^max_depth` 여기서 `max_depth`는 머클 트리의 최대 깊이입니다. **리프 인덱스**는 트리의 리프만(즉, 가장 낮은 행) 왼쪽에서 오른쪽으로 센 경우 머클 트리에서 자산의 인덱스입니다. 이 인덱스는 많은 명령어에서 요청되며 자산의 **리프 자산 ID**를 파생하는 데 사용됩니다.
+- **Leaf**: 압축된 NFT의 전체 해시.
+- **Tree ID**: 자산이 속한 머클 트리의 주소.
+
+보시다시피 여기의 일부 정보는 `getAsset` RPC 호출에서 중복되지만 편의를 위해 여기에 제공됩니다. 하지만 자산의 **증명**과 **노드 인덱스**는 이 메서드를 통해서만 가져올 수 있습니다.
+
+다음은 SDK를 사용하여 자산의 증명을 가져오는 방법입니다.
+
+{% dialect-switcher title="압축된 NFT의 증명 가져오기" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+const rpcAssetProof = await umi.rpc.getAssetProof(assetId)
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 여러 압축된 NFT 가져오기
+
+DAS API를 사용하면 `getAssetsByOwner`와 `getAssetsByGroup` RPC 메서드를 사용하여 한 번에 여러 자산을 가져올 수도 있습니다. 이러한 메서드는 다음 정보를 포함하는 페이지네이션된 **Rpc Asset List** 객체를 반환합니다:
+
+- **Items**: 위에서 설명한 **Rpc Asset** 배열.
+- **Total**: 제공된 기준에 따라 사용 가능한 자산의 총 수.
+- **Limit**: 페이지에서 검색하는 자산의 최대 수.
+- **Page**: 번호 매김 페이지네이션을 사용할 때 현재 있는 페이지를 알려줍니다.
+- **Before**와 **After**: 커서 페이지네이션을 사용할 때 현재 어떤 자산 이후 및/또는 이전에 자산을 탐색하고 있는지 알려줍니다. 이러한 커서는 이전 및 다음 페이지로 이동하는 데 사용할 수 있습니다.
+- **Errors**: RPC에서 반환된 잠재적 오류 목록.
+
+다음은 SDK를 사용하여 이 두 RPC 메서드를 모두 사용하는 방법입니다.
+
+### 소유자별
+
+{% dialect-switcher title="소유자별로 압축된 NFT 가져오기" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+const rpcAssetList = await umi.rpc.getAssetsByOwner({ owner })
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+### 컬렉션별
+
+{% dialect-switcher title="컬렉션별로 압축된 NFT 가져오기" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+const rpcAssetList = await umi.rpc.getAssetsByGroup({
+  groupKey: 'collection',
+  groupValue: collectionMint,
+})
+```
+
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/bubblegum-v2/freeze-cnfts.md

@@ -0,0 +1,171 @@
+---
+title: 압축된 NFT 동결 및 해동
+metaTitle: 압축된 NFT 동결 및 해동 | Bubblegum V2
+description: Bubblegum에서 압축된 NFT를 동결하고 해동하는 방법을 알아보세요.
+---
+
+Bubblegum V2를 사용하면 압축된 NFT를 동결하고 해동할 수 있습니다. 이는 스테이킹과 같은 다양한 사용 사례에 유용합니다. {% .lead %}
+
+## 압축된 NFT 동결
+
+이전에 리프 위임자에게 위임된 압축된 NFT를 동결하려면 `freezeV2` 명령어를 사용할 수 있습니다. 아직 위임되지 않은 경우 아래의 `delegateAndFreezeV2`를 참조하세요. `freezeV2` 명령어는 다음과 같이 사용할 수 있습니다:
+
+{% dialect-switcher title="리프 위임자로 압축된 NFT 동결" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+```js
+import {
+  getAssetWithProof,
+  freezeV2,
+} from '@metaplex-foundation/mpl-bubblegum';
+
+const assetWithProof = await getAssetWithProof(umi, assetId);
+await freezeV2(umi, {
+  ...assetWithProof,
+  leafOwner: umi.identity.publicKey,
+  authority: leafDelegate, // 기본적으로 지불자로 설정됩니다
+  leafDelegate: leafDelegate.publicKey,
+  // cNFT가 컬렉션의 일부인 경우 컬렉션 주소를 전달합니다.
+  //coreCollection: collectionSigner.publicKey,
+}).sendAndConfirm(umi);
+```
+{% /totem %}
+{% totem-accordion title="영구 동결 위임자로" %}
+```js
+import {
+  getAssetWithProof,
+  freezeV2,
+} from '@metaplex-foundation/mpl-bubblegum';
+
+const assetWithProof = await getAssetWithProof(umi, assetId);
+await freezeV2(umi, {
+  ...assetWithProof,
+  leafOwner: umi.identity.publicKey,
+  authority: permanentFreezeDelegate,
+  leafDelegate: permanentFreezeDelegate.publicKey,
+  coreCollection: collectionSigner.publicKey,
+}).sendAndConfirm(umi);
+```
+{% /totem-accordion %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 압축된 NFT 위임 및 동결
+
+압축된 NFT를 동결하려면 `delegateAndFreezeV2` 명령어를 사용할 수 있습니다. 이 명령어는 다음과 같이 사용할 수 있습니다:
+
+{% dialect-switcher title="압축된 NFT 위임 및 동결" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+```js
+import {
+  getAssetWithProof,
+  delegateAndFreezeV2,
+} from '@metaplex-foundation/mpl-bubblegum';
+
+// newLeafDelegate는 나중에 cNFT를 해동할 수 있는 publicKey여야 합니다.
+
+const assetWithProof = await getAssetWithProof(umi, assetId);
+await delegateAndFreezeV2(umi, {
+  ...assetWithProof,
+  leafOwner: umi.identity.publicKey,
+  newLeafDelegate,
+}).sendAndConfirm(umi);
+
+```
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 압축된 NFT 해동
+
+압축된 NFT를 해동하려면 `thawV2` 명령어를 사용할 수 있습니다. 이 명령어는 다음과 같이 사용할 수 있습니다:
+
+{% dialect-switcher title="리프 위임자로 압축된 NFT 해동" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+```js
+import {
+  getAssetWithProof,
+  thawV2,
+} from '@metaplex-foundation/mpl-bubblegum';
+
+const assetWithProof = await getAssetWithProof(umi, assetId);
+// delegateAuthority는 cNFT의 위임 권한으로 승인된 서명자여야 합니다.
+await thawV2(umi, {
+  ...assetWithProof,
+  authority: delegateAuthority,
+}).sendAndConfirm(umi);
+```
+{% /totem %}    
+{% /dialect %}
+{% /dialect-switcher %}
+
+cNFT가 영구 동결 위임자에게 위임된 경우 다음과 같이 해동할 수 있습니다:
+
+{% dialect-switcher title="영구 동결 위임자로 압축된 NFT 해동" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+```js
+import {
+  getAssetWithProof,
+  thawV2,
+} from '@metaplex-foundation/mpl-bubblegum';
+
+const assetWithProof = await getAssetWithProof(umi, assetId);
+await thawV2(umi, {
+  ...assetWithProof,
+  authority: permanentFreezeDelegate,
+}).sendAndConfirm(umi);
+```
+{% /totem %}    
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 해동 및 위임 권한 취소
+
+해동과 위임 권한 취소를 동시에 하려면 `thawAndRevokeV2` 명령어를 사용할 수 있습니다. 이 명령어는 다음과 같이 사용할 수 있습니다:
+
+{% dialect-switcher title="해동 및 위임 권한 취소" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+```js
+import {
+  getAssetWithProof,
+  thawAndRevokeV2,
+} from '@metaplex-foundation/mpl-bubblegum';
+
+// delegateAuthority는 cNFT의 위임 권한으로 승인된 서명자여야 합니다.
+const assetWithProof = await getAssetWithProof(umi, assetId);
+await thawAndRevokeV2(umi, {
+  ...assetWithProof,
+  authority: delegateAuthority,
+}).sendAndConfirm(umi);
+```
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## cNFT를 소울바운드로 만들기
+cNFT를 소울바운드로 만들려면 cNFT가 [`permanentFreezeDelegate`](/kr/core/plugins/permanent-freeze-delegate) 플러그인이 있는 [mpl-core 컬렉션](/kr/core/collections)의 일부여야 합니다. `setNonTransferableV2` 명령어를 사용하여 cNFT를 양도 불가능하게 만들 수 있습니다.
+
+{% dialect-switcher title="cNFT를 소울바운드로 만들기" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+```js
+import {
+  getAssetWithProof,
+  setNonTransferableV2,
+} from '@metaplex-foundation/mpl-bubblegum';
+
+const assetWithProof = await getAssetWithProof(umi, assetId);
+
+await setNonTransferableV2(umi, {
+    ...assetWithProof,
+    authority, // 컬렉션의 영구 동결 위임자
+    coreCollection: collection.publicKey,
+}).sendAndConfirm(umi);
+```
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/bubblegum-v2/hashed-nft-data.md

@@ -0,0 +1,245 @@
+---
+title: NFT 데이터 해싱
+metaTitle: NFT 데이터 해싱 | Bubblegum V2
+description: Bubblegum에서 NFT 데이터가 해싱되는 방식에 대해 자세히 알아보세요.
+---
+
+이전 섹션에서 Bubblegum 머클 트리의 각 리프 노드는 압축된 NFT(cNFT)의 데이터를 해싱하여 얻는다고 설명했습니다. 그러나 이것이 정확히 어떻게 수행되는지 알아보겠습니다. cNFT의 메타데이터부터 시작합니다. Bubblegum V2의 각 cNFT는 민팅 명령어에 대한 인수로 다음 메타데이터 구조와 함께 민팅되며, Bubblegum v1은 대신 MetadataArgs를 사용한다는 점에 유의하세요:
+
+```rust
+pub struct MetadataArgsV2 {
+    /// 자산의 이름
+    pub name: String,
+    /// 자산의 심볼
+    pub symbol: String,
+    /// 자산을 나타내는 JSON을 가리키는 URI
+    pub uri: String,
+    /// 2차 판매에서 창작자에게 지불되는 로열티 베이시스 포인트 (0-10000)
+    pub seller_fee_basis_points: u16,
+    /// 불변, 한 번 뒤집히면 이 메타데이터의 모든 판매가 2차 판매로 간주됩니다.
+    pub primary_sale_happened: bool,
+    /// 데이터 구조가 변경 가능한지 여부, 기본값은 변경 불가능
+    pub is_mutable: bool,
+    /// 토큰 표준. 현재는 `NonFungible`만 허용됩니다.
+    pub token_standard: Option<TokenStandard>,
+    /// 창작자 배열
+    pub creators: Vec<Creator>,
+    /// 컬렉션. V2에서는 단순히 `Pubkey`이며 항상 검증된 것으로 간주됩니다.
+    pub collection: Option<Pubkey>,
+}
+```
+
+cNFT의 메타데이터는 아래 다이어그램에 표시되고 설명된 대로 여러 번 해싱됩니다:
+
+{% diagram %}
+
+{% node %}
+{% node #metadata label="Metadata Args" theme="blue" /%}
+{% node label="Name" /%}
+{% node label="Symbol" /%}
+{% node label="URI" /%}
+{% node label="Seller Fee Basis Points" /%}
+{% node label="Primary Sale Happened" /%}
+{% node label="Is Mutable" /%}
+{% node label="Token Standard" /%}
+{% node label="Collection" /%}
+{% node label="Creators" /%}
+{% /node %}
+
+{% node #seller-fee-basis-points parent="metadata" y="305" label="Seller Fee Basis Points" theme="blue" /%}
+
+{% node #creators parent="metadata" y="370" label="Creators" theme="blue" /%}
+
+{% node parent="metadata" x="300" y="150" %}
+{% node #data-hash label="Data Hash" theme="mint" /%}
+{% node theme="transparent" %}
+Hash(Metadata Args, \
+Seller Fee Basis Points)
+{% /node %}
+{% /node %}
+
+{% node parent="creators" x="300" %}
+{% node #creator-hash label="Creator Hash" theme="mint" /%}
+{% node theme="transparent" label="Hash(Creators)" /%}
+{% /node %}
+
+{% node parent="data-hash" x="250" %}
+{% node #leaf-schema label="Leaf Schema V2" theme="blue" /%}
+{% node label="ID" /%}
+{% node label="Owner" /%}
+{% node label="Delegate" /%}
+{% node label="Nonce" /%}
+{% node label="Data Hash" /%}
+{% node label="Creator Hash" /%}
+{% node label="Collection Hash (V2에서 새로 추가)" /%}
+{% node label="Asset Data Hash (V2에서 새로 추가)" /%}
+{% node label="Flags (V2에서 새로 추가)" /%}
+{% /node %}
+
+{% node parent="leaf-schema" x="200" %}
+{% node #leaf-node label="Leaf Node" theme="mint" /%}
+{% node theme="transparent" label="Hash(Leaf Schema)" /%}
+{% /node %}
+
+{% edge from="metadata" to="data-hash" /%}
+{% edge from="seller-fee-basis-points" to="data-hash" /%}
+{% edge from="creators" to="creator-hash" /%}
+
+{% edge from="data-hash" to="leaf-schema" /%}
+{% edge from="creator-hash" to="leaf-schema" /%}
+
+{% edge from="leaf-schema" to="leaf-node" /%}
+
+{% /diagram %}
+
+먼저 메타데이터가 keccak-256 해시 함수를 사용하여 해싱됩니다. Keccak-256은 SHA-256보다 훨씬 강력하며 Ethereum과 같은 다른 블록체인뿐만 아니라 Solana에서도 사용됩니다.
+
+메타데이터가 해싱된 다음 `seller_fee_basis_points`와 함께 다시 해싱된다는 점에 주목하세요. 이렇게 하면 마켓플레이스가 전체 `MetadataArgs` 구조체(최대 457바이트 길이가 될 수 있음)를 전달할 필요 없이 판매자 수수료 베이시스 포인트를 검증하기가 더 쉬워집니다. 대신 이미 해싱된 32바이트 배열의 `MetadataArgs`와 `u16`(2바이트) `seller_fee_basis_points`를 전달할 수 있으며, 이를 함께 해싱하여 데이터 해시를 재생성할 수 있습니다.
+
+```rust
+/// 메타데이터의 해시를 계산합니다.
+///
+/// 해시는 메타데이터 바이트의 keccak256 해시로 계산되며,
+/// 이는 `seller_fee_basis_points`와 함께 해싱됩니다.
+pub fn hash_metadata(metadata: &MetadataArgs) -> Result<[u8; 32]> {
+    let hash = keccak::hashv(&[metadata.try_to_vec()?.as_slice()]);
+    // 새 데이터 해시 계산.
+    Ok(keccak::hashv(&[
+        &hash.to_bytes(),
+        &metadata.seller_fee_basis_points.to_le_bytes(),
+    ])
+    .to_bytes())
+}
+```
+
+다음으로 창작자 배열이 개별적으로 해싱됩니다.
+
+```rust
+/// 창작자의 해시를 계산합니다.
+///
+/// 해시는 창작자 바이트의 keccak256 해시로 계산됩니다.
+pub fn hash_creators(creators: &[Creator]) -> [u8; 32] {
+    // 창작자 Vec를 바이트 Vec로 변환
+    let creator_data = creators
+        .iter()
+        .map(|c| [c.address.as_ref(), &[c.verified as u8], &[c.share]].concat())
+        .collect::<Vec<_>>();
+    // 해시 계산
+    keccak::hashv(
+        creator_data
+            .iter()
+            .map(|c| c.as_slice())
+            .collect::<Vec<&[u8]>>()
+            .as_ref(),
+    )
+    .to_bytes()
+}
+```
+
+이어서 컬렉션 및 자산 데이터 해시가 계산됩니다:
+
+```rust
+/// `LeafSchemaV2`에 대한 컬렉션의 해시를 계산합니다(`None`인 경우 기본값 제공).
+pub fn hash_collection_option(collection: Option<Pubkey>) -> Result<[u8; 32]> {
+    let collection_key = collection.unwrap_or(DEFAULT_COLLECTION);
+    Ok(keccak::hashv(&[collection_key.as_ref()]).to_bytes())
+}
+
+/// `LeafSchemaV2`에 대한 자산 데이터의 해시를 계산합니다(`None`인 경우 기본값 제공).
+pub fn hash_asset_data_option(asset_data: Option<&[u8]>) -> Result<[u8; 32]> {
+    let data = asset_data.unwrap_or(b""); // None을 빈 데이터로 처리
+    Ok(keccak::hashv(&[data]).to_bytes())
+}
+
+```
+
+데이터 해시와 창작자 해시는 리프를 고유하게 식별하는 데 필요한 다른 정보와 함께 리프 스키마에 추가됩니다.
+
+데이터와 창작자 해시의 분리는 `seller_fee_basis_points`와 유사한 이유로 수행됩니다. 마켓플레이스가 창작자 배열을 검증하려는 경우 이미 해싱된 32바이트 배열의 `MetadataArgs`를 창작자 배열과 함께 전달할 수 있습니다. 창작자 배열의 값들을 평가한 다음 `creator_hash`로 해싱하고 다른 기존 정보와 결합하여 리프 스키마로 만들 수 있습니다. Bubblegum V1은 `LeafSchemaV1`을 사용하고 Bubblegum V2는 `LeafSchemaV2`를 사용합니다.
+
+```rust
+#[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Debug, Clone)]
+pub enum LeafSchema {
+    V1 {
+        id: Pubkey,
+        owner: Pubkey,
+        delegate: Pubkey,
+        nonce: u64,
+        data_hash: [u8; 32],
+        creator_hash: [u8; 32],
+    },
+    V2 {
+        id: Pubkey,
+        owner: Pubkey,
+        delegate: Pubkey,
+        nonce: u64,
+        data_hash: [u8; 32],
+        creator_hash: [u8; 32],
+        collection_hash: [u8; 32],
+        asset_data_hash: [u8; 32],
+        flags: u8,
+    },
+}
+```
+
+데이터, 창작자, 컬렉션 및 자산 데이터 해시 외에도 리프 스키마에는 다음과 같은 다른 항목들이 포함됩니다:
+
+* nonce: 이는 트리의 각 리프에 대해 고유한 "한 번 사용되는 번호" 값입니다. 머클 트리 리프가 고유하도록 보장하는 데 필요합니다. 실제로는 자산 증명과 마찬가지로 오프체인 인덱서에서 검색됩니다.
+* id - 이 자산 ID는 고정된 접두사, 머클 트리 Pubkey 및 nonce로부터 파생된 PDA입니다.
+* owner - cNFT 소유자의 Pubkey로, 일반적으로 사용자의 지갑입니다.
+* delegate - cNFT의 위임자입니다. 기본적으로 이는 사용자의 지갑이지만 `delegate` Bubblegum 명령어로 설정할 수 있습니다.
+* flags - 이는 NFT 상태에 대한 추가 정보가 있는 비트마스크입니다. 비트 0은 자산 수준에서의 동결 상태(소유자에 의한)이고 비트 1은 컬렉션 수준에서 영구 위임자에 의한 동결 상태입니다. 둘 다 적절한 권한에 의해 변경될 수 있습니다. 비트 3은 아무도 재설정할 수 없고 소울바운드 자산에 사용되는 일반적인 `nonTransferable` 플래그입니다. 다른 비트들은 향후 사용을 위해 예약되어 있습니다.
+
+머클 트리에 존재하는 32바이트 리프 노드를 생성하기 위해 전체 리프 스키마는 스키마 버전에 따라 다음과 같이 해싱됩니다:
+
+```rust
+impl LeafSchema {
+    pub fn to_node(&self) -> Node {
+        let hashed_leaf = match self {
+            LeafSchema::V1 {
+                id,
+                owner,
+                delegate,
+                nonce,
+                data_hash,
+                creator_hash,
+            } => keccak::hashv(&[
+                &[self.version().to_bytes()],
+                id.as_ref(),
+                owner.as_ref(),
+                delegate.as_ref(),
+                nonce.to_le_bytes().as_ref(),
+                data_hash.as_ref(),
+                creator_hash.as_ref(),
+            ])
+            .to_bytes(),
+            LeafSchema::V2 {
+                id,
+                owner,
+                delegate,
+                nonce,
+                data_hash,
+                creator_hash,
+                collection_hash,
+                asset_data_hash,
+                flags,
+            } => keccak::hashv(&[
+                &[self.version().to_bytes()],
+                id.as_ref(),
+                owner.as_ref(),
+                delegate.as_ref(),
+                nonce.to_le_bytes().as_ref(),
+                data_hash.as_ref(),
+                creator_hash.as_ref(),
+                collection_hash.as_ref(),
+                asset_data_hash.as_ref(),
+                &[*flags],
+            ])
+            .to_bytes(),
+        };
+        hashed_leaf
+    }
+}
+```
+
+리프 변경을 포함하는 Bubblegum 작업(`transfer`, `delegate`, `burn` 등)은 머클 트리 변경을 검증하기 위해 리프 스키마 버전에 따라 `spl-account-compression` 또는 `mpl-account-compression`에 "이전" 및 "이후" 해싱된 리프 노드를 전송합니다.

src/pages/kr/bubblegum-v2/index.md

@@ -0,0 +1,147 @@
+---
+title: 개요
+metaTitle: 개요 | Bubblegum V2
+description: Bubblegum V2와 압축된 NFT에 대한 고수준 개요를 제공합니다.
+---
+
+Bubblegum V2는 Solana에서 압축된 NFT(cNFT)를 생성하고 상호 작용하기 위한 Metaplex Protocol 프로그램의 최신 반복입니다. 대규모 운영을 위해 구축된 Bubblegum V2는 원본 Bubblegum의 모든 장점을 유지하면서 강력한 새 기능을 도입합니다. 압축된 NFT는 온체인에서 데이터를 저장하는 방식을 재고함으로써 NFT 생성을 새로운 규모로 확장할 수 있게 합니다. {% .lead %}
+
+{% quick-links %}
+
+{% quick-link title="시작하기" icon="InboxArrowDown" href="/kr/bubblegum-v2/sdk" description="원하는 언어나 라이브러리를 찾아 압축된 NFT를 시작하세요." /%}
+
+{% quick-link title="API 참조" icon="CodeBracketSquare" href="https://mpl-bubblegum.typedoc.metaplex.com/" target="_blank" description="특정한 것을 찾고 계신가요? API 참조를 살펴보고 답을 찾아보세요." /%}
+
+{% /quick-links %}
+
+## Bubblegum V2의 새로운 기능
+
+Bubblegum V2는 원본 Bubblegum 프로그램의 기반 위에 구축되면서 여러 강력한 새 기능을 도입합니다:
+
+- **동결 및 해동 기능**: 두 가지 유형의 동결/해동이 가능합니다: 1) cNFT 소유자는 자산 수준 제어를 위해 리프 위임자에게 동결 권한을 위임할 수 있어 특정 이벤트 중 전송을 방지하거나 베스팅 메커니즘을 구현하는 등 다양한 사용 사례에 유연성을 제공합니다. 2) 컬렉션 생성 시 `PermanentFreezeDelegate` 플러그인이 활성화된 경우, 프로젝트 제작자는 컬렉션 전체 제어를 위해 영구 동결 위임자를 통해 cNFT를 동결하고 해동할 수 있습니다
+- **MPL-Core 컬렉션 통합**: Bubblegum V2 NFT는 이제 토큰 메타데이터 컬렉션에 제한되지 않고 MPL-Core 컬렉션에 추가될 수 있어 더 넓은 Metaplex 생태계와의 유연성과 통합을 제공합니다.
+- **로열티 강제**: Bubblegum V2는 [MPL-Core](https://docs.metaplex.com/core/overview) 컬렉션을 사용하므로 `ProgramDenyList`를 사용하여 cNFT에 로열티를 강제할 수 있습니다.
+- **소울바운드 NFT**: cNFT는 이제 소울바운드(양도 불가능)로 만들 수 있어 소유자의 지갑에 영구적으로 바인딩됩니다. 이는 자격증명, 참석 증명, 신원 확인 등에 완벽합니다. 컬렉션 생성 시 `PermanentFreezeDelegate` 플러그인이 활성화되어야 합니다.
+- **영구 전송 허용**: 컬렉션에서 `PermanentTransferDelegate` 플러그인이 활성화된 경우 영구 전송 위임자는 리프 소유자의 상호 작용 없이 cNFT를 새 소유자에게 전송할 수 있습니다.
+- **권한에 의한 소각**: 컬렉션에 `PermanentBurnDelegate` 플러그인이 활성화된 경우, 위임자는 리프 소유자의 서명 없이 NFT를 소각할 수 있습니다.
+- **속성**: MPL-Core `attributes` 플러그인을 사용하여 컬렉션 수준에서 속성 데이터를 추가할 수 있습니다.
+
+위 기능들이 작동하도록 하기 위해 Bubblegum V2는 새로운 리프 스키마(`LeafSchemaV2`)를 도입합니다. Bubblegum V2에서 사용되는 리프에 대해 더 자세히 알아보려면 다음 섹션을 확인하세요.
+
+## LeafSchemaV2
+
+Bubblegum V2는 추가 기능을 지원하면서 이전 버전과의 호환성을 유지하는 새로운 리프 스키마(LeafSchemaV2)를 도입합니다. 이 새로운 스키마는 다음을 가능하게 합니다:
+
+- 기존 토큰 메타데이터 대신 MPL-Core 컬렉션과의 통합
+- 동결/해동 기능 지원
+- 소울바운드 기능 활성화
+
+프로젝트는 요구 사항에 따라 레거시 Bubblegum을 사용한 원본 리프 스키마나 Bubblegum V2를 사용한 새 v2 스키마를 선택할 수 있습니다.
+
+새로운 `LeafSchemaV2`를 사용하려면 [`createTreeV2` 명령](/kr/bubblegum-v2/create-trees)을 사용하여 생성해야 하는 V2 머클 트리를 사용해야 합니다. V1 머클 트리는 새로운 리프 스키마를 지원하지 않으며 V2 머클 트리는 V1 리프와 호환되지 않습니다.
+
+## 머클 트리, 리프 및 증명
+
+압축된 NFT는 **머클 트리**의 맥락에서만 존재합니다. 머클 트리가 무엇인지는 [전용 고급 가이드](/kr/bubblegum-v2/concurrent-merkle-trees)에서 설명하지만, 이 개요에서는 머클 트리를 **리프**라고 부르는 해시의 컬렉션으로 생각할 수 있습니다. 각 리프는 [압축된 NFT의 데이터를 해싱](/kr/bubblegum-v2/hashed-nft-data)하여 얻어집니다.
+
+머클 트리의 각 리프에 대해 **증명**이라고 하는 해시 목록을 제공할 수 있습니다. 이를 통해 누구든지 주어진 리프가 해당 트리의 일부임을 확인할 수 있습니다. 압축된 NFT가 업데이트되거나 전송될 때마다 연관된 리프가 변경되고 증명도 마찬가지입니다.
+
+{% diagram %}
+
+{% node #root label="루트 노드" theme="slate" /%}
+{% node #root-hash label="해시" parent="root" x="56" y="40" theme="transparent" /%}
+{% node #node-1 label="노드 1" parent="root" y="100" x="-200" theme="blue" /%}
+{% node #node-1-hash label="해시" parent="node-1" x="42" y="40" theme="transparent" /%}
+{% node #node-2 label="노드 2" parent="root" y="100" x="200" theme="mint" /%}
+
+{% node #node-3 label="노드 3" parent="node-1" y="100" x="-100" theme="mint" /%}
+{% node #node-4 label="노드 4" parent="node-1" y="100" x="100" theme="blue" /%}
+{% node #node-4-hash label="해시" parent="node-4" x="42" y="40" theme="transparent" /%}
+{% node #node-5 label="노드 5" parent="node-2" y="100" x="-100" /%}
+{% node #node-6 label="노드 6" parent="node-2" y="100" x="100" /%}
+
+{% node #leaf-1 label="리프 1" parent="node-3" y="100" x="-45" /%}
+{% node #leaf-2 label="리프 2" parent="node-3" y="100" x="55" /%}
+{% node #leaf-3 label="리프 3" parent="node-4" y="100" x="-45" theme="blue" /%}
+{% node #leaf-4 label="리프 4" parent="node-4" y="100" x="55" theme="mint" /%}
+{% node #leaf-5 label="리프 5" parent="node-5" y="100" x="-45" /%}
+{% node #leaf-6 label="리프 6" parent="node-5" y="100" x="55" /%}
+{% node #leaf-7 label="리프 7" parent="node-6" y="100" x="-45" /%}
+{% node #leaf-8 label="리프 8" parent="node-6" y="100" x="55" /%}
+{% node #nft label="NFT 데이터" parent="leaf-3" y="100" x="-12" theme="blue" /%}
+
+{% node #proof-1 label="리프 4" parent="nft" x="200" theme="mint" /%}
+{% node #proof-2 label="노드 3" parent="proof-1" x="90" theme="mint" /%}
+{% node #proof-3 label="노드 2" parent="proof-2" x="97" theme="mint" /%}
+{% node #proof-legend label="증명" parent="proof-1" x="-6" y="-20" theme="transparent" /%}
+
+{% edge from="node-1" to="root" fromPosition="top" toPosition="bottom" theme="blue" animated=true /%}
+{% edge from="node-2" to="root" fromPosition="top" toPosition="bottom" theme="mint" animated=true /%}
+
+{% edge from="node-3" to="node-1" fromPosition="top" toPosition="bottom" theme="mint" animated=true /%}
+{% edge from="node-4" to="node-1" fromPosition="top" toPosition="bottom" theme="blue" animated=true /%}
+{% edge from="node-6" to="node-2" fromPosition="top" toPosition="bottom" /%}
+{% edge from="node-5" to="node-2" fromPosition="top" toPosition="bottom" /%}
+
+{% edge from="leaf-1" to="node-3" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-2" to="node-3" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-4" to="node-4" fromPosition="top" toPosition="bottom" theme="mint" animated=true /%}
+{% edge from="leaf-3" to="node-4" fromPosition="top" toPosition="bottom" theme="blue" animated=true /%}
+{% edge from="leaf-5" to="node-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-6" to="node-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-7" to="node-6" fromPosition="top" toPosition="bottom" /%}
+{% edge from="leaf-8" to="node-6" fromPosition="top" toPosition="bottom" /%}
+{% edge from="nft" to="leaf-3" fromPosition="top" toPosition="bottom" theme="blue" animated=true label="해시" /%}
+
+{% /diagram %}
+
+따라서 머클 트리는 주어진 압축된 NFT가 존재함을 누구든지 확인할 수 있는 온체인 구조 역할을 합니다. NFT 데이터를 저장하지 않고도 이를 수행하여 확장성을 제공합니다.
+
+이는 중요한 질문으로 이어집니다: NFT 데이터는 어디에 저장되나요?
+
+## Metaplex DAS API
+
+새로운 압축된 NFT를 민팅할 때 해당 데이터가 해싱되어 머클 트리에 새로운 리프로 추가됩니다. 하지만 더 있습니다. 추가로 전체 NFT 데이터가 압축된 NFT를 생성한 트랜잭션에 저장됩니다. 마찬가지로 압축된 NFT가 업데이트되면 업데이트된 데이터가 다시 한 번 변경 로그로 트랜잭션에 저장됩니다. 따라서 해당 데이터를 추적하는 계정은 없지만 원장의 모든 이전 트랜잭션을 살펴보고 해당 정보를 찾을 수 있습니다.
+
+{% diagram %}
+
+{% node #tx-1 label="트랜잭션 1" /%}
+{% node #tx-2 label="트랜잭션 2" parent="tx-1" y="50" /%}
+{% node #tx-3 label="트랜잭션 3" parent="tx-2" y="50" /%}
+{% node #tx-4 label="트랜잭션 4" parent="tx-3" y="50" /%}
+{% node #tx-5 label="트랜잭션 5" parent="tx-4" y="50" /%}
+{% node #tx-rest label="..." parent="tx-5" y="50" /%}
+
+{% node #nft-1 label="초기 NFT 데이터" parent="tx-2" x="300" theme="blue" /%}
+{% node #nft-2 label="NFT 데이터 변경 로그" parent="tx-3" x="300" theme="blue" /%}
+{% node #nft-3 label="NFT 데이터 변경 로그" parent="tx-5" x="300" theme="blue" /%}
+
+{% edge from="nft-1" to="tx-2" label="저장됨" /%}
+{% edge from="nft-2" to="tx-3" label="저장됨" /%}
+{% edge from="nft-3" to="tx-5" label="저장됨" /%}
+
+{% /diagram %}
+
+하나의 NFT 데이터를 가져오기 위해 수백만 개의 트랜잭션을 매번 크롤링하는 것은 최고의 사용자 경험이 아닙니다. 따라서 압축된 NFT는 일부 RPC가 실시간으로 해당 정보를 인덱싱하여 최종 사용자로부터 이를 추상화하는 것에 의존합니다. 압축된 NFT를 가져올 수 있게 하는 결과 RPC API를 **Metaplex DAS API**라고 합니다.
+
+모든 RPC가 DAS API를 지원하는 것은 아닙니다. 따라서 애플리케이션에서 압축된 NFT를 사용할 때 적절한 RPC를 선택하려면 ["Metaplex DAS API RPC"](/kr/rpc-providers) 페이지에 관심이 있을 수 있습니다.
+
+이에 대해 더 자세히 설명하는 고급 ["NFT 데이터 저장 및 인덱싱"](/kr/bubblegum-v2/stored-nft-data) 가이드에서 다룹니다.
+
+## 기능
+
+NFT 데이터가 계정 내에 있지 않더라도 압축된 NFT에서 다양한 작업을 수행할 수 있습니다. 이는 현재 NFT 데이터를 요청하고 해싱된 리프가 머클 트리에서 유효한지 확인함으로써 가능합니다. 따라서 압축된 NFT에서 다음 작업을 수행할 수 있습니다:
+
+- 연관된 컬렉션이 있거나 없이 [cNFT를 민팅](/kr/bubblegum-v2/mint-cnfts)합니다.
+- [cNFT를 전송](/kr/bubblegum-v2/transfer-cnfts)합니다.
+- [cNFT의 데이터나 컬렉션을 업데이트](/kr/bubblegum-v2/update-cnfts)합니다.
+- [cNFT를 소각](/kr/bubblegum-v2/burn-cnfts)합니다.
+- [cNFT를 위임](/kr/bubblegum-v2/delegate-cnfts)합니다.
+- [cNFT 컬렉션을 확인하고 확인 해제](/kr/bubblegum-v2/verify-collections)합니다.
+- [cNFT의 제작자를 확인하고 확인 해제](/kr/bubblegum-v2/verify-creators)합니다.
+- [cNFT를 동결하고 해동](/kr/bubblegum-v2/freeze-cnfts)합니다.
+- [cNFT를 소울바운드로 만듭니다](/kr/bubblegum-v2/freeze-cnfts#create-a-soulbound-c-nft).
+
+## 다음 단계
+
+압축된 NFT가 높은 수준에서 어떻게 작동하는지와 Bubblegum V2의 새로운 기능을 알았으니 압축된 NFT와 상호 작용하는 데 사용할 수 있는 다양한 언어/프레임워크를 열거하는 [시작하기](/kr/bubblegum-v2/sdk) 페이지를 확인하는 것을 권장합니다. 그 후 다양한 [기능 페이지](/kr/bubblegum-v2/create-trees)를 사용하여 cNFT에서 수행할 수 있는 특정 작업에 대해 더 자세히 알아볼 수 있습니다. 마지막으로 cNFT와 머클 트리에 대한 지식을 깊게 하기 위해 [고급 가이드](/kr/bubblegum-v2/concurrent-merkle-trees)도 사용할 수 있습니다.

src/pages/kr/bubblegum-v2/merkle-tree-canopy.md

@@ -0,0 +1,33 @@
+---
+title: 머클 트리 캐노피
+metaTitle: 머클 트리 캐노피 | Bubblegum V2
+description: Bubblegum의 머클 트리 캐노피에 대해 자세히 알아보세요.
+---
+
+## 소개
+
+Solana의 네트워킹 스택은 1280바이트의 MTU 크기를 사용하며, 헤더를 고려하면 데이터에 대해 1232바이트가 남습니다. 압축된 NFT(cNFT)에 미치는 영향은 현재 깊이가 24보다 큰 머클 트리를 수정하는 것이 불가능하다는 것입니다. 필요한 증명이 트랜잭션 크기를 너무 많이 차지하기 때문입니다.
+
+이러한 증명 크기 제한을 우회하기 위해 spl-account-compression은 머클 트리의 최상위 노드들을 캐시하는 기능을 제공합니다. 이를 **캐노피**라고 하며, 동시 머클 트리 계정의 끝에 저장됩니다.
+
+깊이 *d* 트리의 상위 *n* 레벨을 캐싱함으로써 증명을 첫 번째 *d - n* 노드로 잘라낼 수 있습니다. 이는 계정 압축 트랜잭션의 크기를 줄이는 데 도움이 되며, 10억 개 이상의 cNFT를 저장할 수 있는 깊이 31까지의 트리를 수정할 수 있게 합니다.
+
+머클 트리 계정에 캐노피를 초기화하려면 추가 바이트로 계정을 초기화해야 합니다. 필요한 추가 바이트 수는 (2*ⁿ*⁺¹ - 1) * 32입니다. 여기서 *n*은 캐노피가 캐시하려는 머클 트리의 레벨 수입니다.
+
+캐노피는 동시 머클 트리가 수정될 때마다 업데이트됩니다. 추가 작업은 필요하지 않습니다. 하지만 트리가 생성된 후에는 캐노피 크기를 변경할 수 없습니다.
+
+## 조합성 vs. 비용 절약
+
+아래 표는 [compressed.app](https://compressed.app/)의 도움으로 생성되었으며, 캐노피 크기에 따라 1,000,000 cNFT 민팅의 총 비용이 어떻게 크게 달라질 수 있는지 보여줍니다.
+
+### 다양한 캐노피 깊이로 1,000,000 cNFT를 위한 비용
+*깊이 20의 머클 트리는 1,048,576 cNFT를 저장할 수 있습니다.*
+| 캐노피 깊이     | 증명 바이트   | 스토리지 비용 | 민팅 비용 (LUT를 사용한 tx당 3회 민팅) | 총 비용 |
+| ---------------- | ------------- | ------------ | -----------------------------| ---------- |
+| 0                | 640           | 0.3091       | 1.6667                       | 1.9758     |
+| 14               | 192           | 7.6067       | 1.6667                       | 9.2734     |
+| 17               | 96            | 58.6933      | 1.6667                       | 60.36      |
+
+캐노피 깊이가 0인 이유는 가능한 한 가장 저렴한 민팅을 위해서입니다. 하지만 이는 `transfer`, `delegate`, `burn`과 같은 명령어와 함께 많은 증명 데이터를 보내야 합니다. 캐노피 깊이가 0인 경우, 트랜잭션 크기 제한의 절반 이상이 증명 데이터로 소비되어 Bubblegum 명령어를 다른 프로그램 명령어와 조합하는 능력에 부정적인 영향을 미칩니다.
+
+궁극적으로 캐노피 크기 결정은 비용과 조합성 사이의 트레이드오프를 고려해야 합니다. 이 평가는 cNFT의 의도된 사용, 개발 플랫폼의 호환성, 트리의 소유권 구조와 같은 요소들을 고려해야 합니다.

src/pages/kr/bubblegum-v2/mint-cnfts.md

@@ -0,0 +1,135 @@
+---
+title: 압축된 NFT 민팅
+metaTitle: 압축된 NFT 민팅 | Bubblegum V2
+description: Bubblegum V2에서 압축된 NFT를 민팅하는 방법을 알아보세요.
+---
+
+[이전 페이지](/kr/bubblegum-v2/create-trees)에서 압축된 NFT를 민팅하려면 Bubblegum 트리가 필요하다는 것을 보았고, 하나를 만드는 방법을 보았습니다. 이제 주어진 Bubblegum 트리에서 압축된 NFT를 민팅하는 방법을 살펴보겠습니다. {% .lead %}
+
+Bubblegum 프로그램은 다양한 리프 스키마 버전에 대해 여러 민팅 명령어를 제공합니다. Bubblegum V2는 주어진 컬렉션에 또는 컬렉션 없이 압축된 NFT를 민팅하는 데 사용되는 **mintV2**라는 새로운 민팅 명령어를 도입합니다.
+
+## 컬렉션 없이 민팅
+
+Bubblegum 프로그램은 Bubblegum 트리에서 압축된 NFT를 민팅할 수 있는 **mintV2** 명령어를 제공합니다. Bubblegum 트리가 공개된 경우 누구나 이 명령어를 사용할 수 있습니다. 그렇지 않으면 트리 제작자나 트리 위임자만 사용할 수 있습니다.
+
+**mintV2** 명령어의 주요 매개변수는 다음과 같습니다:
+
+- **머클 트리**: 압축된 NFT가 민팅될 머클 트리 주소.
+- **트리 제작자 또는 위임자**: Bubblegum 트리에서 민팅할 수 있는 권한 — 이는 트리의 제작자나 위임자가 될 수 있습니다. 이 권한은 트랜잭션에 서명해야 합니다. 공개 트리의 경우 이 매개변수는 모든 권한이 될 수 있지만 여전히 서명자여야 합니다.
+- **리프 소유자**: 민팅될 압축된 NFT의 소유자. 기본적으로 트랜잭션의 지불자로 설정됩니다.
+- **리프 위임자**: 민팅된 cNFT를 관리할 수 있는 위임 권한 (있는 경우). 그렇지 않으면 리프 소유자로 설정됩니다.
+- **컬렉션 권한**: 주어진 컬렉션을 관리할 수 있는 권한.
+- **코어 컬렉션**: 압축된 NFT가 추가될 MPL-Core 컬렉션 NFT.
+- **메타데이터**: 민팅될 압축된 NFT의 메타데이터. NFT의 **이름**, **URI**, **컬렉션**, **제작자** 등의 정보를 포함합니다. Bubblegum V2에서 메타데이터는 `uses`와 컬렉션의 `verified` 플래그와 같은 불필요한 필드를 제외한 `MetadataArgsV2`를 사용합니다.
+
+{% dialect-switcher title="컬렉션 없이 압축된 NFT 민팅" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { none } from '@metaplex-foundation/umi';
+import { mintV2 } from '@metaplex-foundation/mpl-bubblegum';
+
+await mintV2(umi, {
+  leafOwner: umi.identity.publicKey,
+  merkleTree: merkleTree.publicKey,
+  metadata: {
+    name: 'My NFT',
+    uri: 'https://example.com/my-nft.json',
+    sellerFeeBasisPoints: 550, 
+    collection: none(),
+    creators: [],
+  },
+}).sendAndConfirm(umi);
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 컬렉션에 민팅
+
+압축된 NFT가 민팅된 _후에_ 컬렉션을 설정하고 확인하는 것이 가능하지만, Bubblegum V2는 압축된 NFT를 주어진 컬렉션에 직접 민팅할 수 있게 합니다. Bubblegum V2는 압축된 NFT를 그룹화하기 위해 MPL-Core 컬렉션을 사용합니다. 동일한 **mintV2** 명령어가 이를 위해 사용됩니다. 위에서 설명한 매개변수 외에도 코어 컬렉션을 전달하고 컬렉션 권한 또는 위임자로 서명해야 합니다:
+
+- **코어 컬렉션**: MPL-Core 컬렉션 NFT를 가리키는 `coreCollection` 매개변수에 전달되는 민트 주소…
+- **컬렉션 권한**: 주어진 컬렉션 NFT를 관리할 수 있는 권한. 이는 컬렉션 NFT의 업데이트 권한이나 위임된 컬렉션 권한이 될 수 있습니다. 이 권한은 Bubblegum 트리가 공개되었는지 여부에 관계없이 트랜잭션에 서명해야 합니다.
+
+**메타데이터** 매개변수는 **컬렉션** 공개 키를 포함해야 합니다.
+
+{% dialect-switcher title="컬렉션에 압축된 NFT 민팅" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import { some } from '@metaplex-foundation/umi';
+import { mintV2 } from '@metaplex-foundation/mpl-bubblegum';
+
+await mintV2(umi, {
+  collectionAuthority: umi.identity,
+  leafOwner: umi.identity.publicKey,
+  merkleTree: merkleTree.publicKey,
+  coreCollection: collectionSigner.publicKey,
+  metadata: {
+    name: 'My NFT',
+    uri: 'https://example.com/my-nft.json',
+    sellerFeeBasisPoints: 550, // 5.5%
+    collection: some(collectionSigner.publicKey),
+    creators: [],
+  },
+}).sendAndConfirm(umi);
+```
+
+{% totem-accordion title="MPL-Core 컬렉션 생성" %}
+
+아직 컬렉션이 없다면 [`@metaplex-foundation/mpl-core` 라이브러리](https://developers.metaplex.com/core/collections#creating-a-collection-with-plugins)를 사용하여 하나를 만들 수 있습니다. 컬렉션에 `BubblegumV2` 플러그인도 추가해야 한다는 점을 명심하세요.
+npm install @metaplex-foundation/mpl-core
+그리고 다음과 같이 컬렉션을 만드세요:
+
+```ts
+import { generateSigner } from '@metaplex-foundation/umi';
+import { createCollection } from '@metaplex-foundation/mpl-core';
+
+const collectionSigner = generateSigner(umi);
+await createCollection(umi, {
+    collection: collectionSigner,
+    name: "My Collection",
+    uri: "https://example.com/my-nft.json",
+    plugins: [
+      {
+        type: "BubblegumV2",
+      },
+    ],
+  }).sendAndConfirm(umi);
+```
+
+{% /totem-accordion %}
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+### 민트 트랜잭션에서 자산 ID와 리프 스키마 가져오기 {% #get-leaf-schema-from-mint-transaction %}
+
+`parseLeafFromMintV2Transaction` 도우미를 사용하여 `mintV2` 트랜잭션에서 리프를 검색하고 자산 ID를 결정할 수 있습니다. 이 함수는 트랜잭션을 파싱하므로 `parseLeafFromMintV2Transaction`을 호출하기 전에 트랜잭션이 완료되었는지 확인해야 합니다.
+
+{% callout type="note" title="트랜잭션 완료" %}
+`parseLeafFromMintV2Transaction`을 호출하기 전에 트랜잭션이 완료되었는지 확인하세요.
+{% /callout %}
+
+{% dialect-switcher title="민트 트랜잭션에서 리프 스키마 가져오기" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import {
+  mintV2,
+  parseLeafFromMintV2Transaction,
+} from '@metaplex-foundation/mpl-bubblegum';
+
+const { signature } = await mintV2(umi, {
+  // ... 위의 세부사항 참조
+}).sendAndConfirm(umi);
+
+const leaf = await parseLeafFromMintV2Transaction(umi, signature);
+const assetId = leaf.id;
+```
+
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/bubblegum-v2/sdk/index.md

@@ -0,0 +1,15 @@
+---
+title: MPL-Bubblegum SDK
+metaTitle: SDK | Bubblegum V2
+description: MPL-Bubblegum SDK를 사용하여 Metaplex의 압축된 NFT 표준(cNFT)으로 시작하는 방법을 알아보세요.
+---
+
+MPL-Bubblegum을 사용하여 새로운 Metaplex 압축된 NFT(cNFT) 표준을 시작하려면 아래에서 사용하고 싶은 언어/라이브러리를 선택하세요.
+
+{% quick-links %}
+
+{% quick-link title="JavaScript" icon="JavaScript" href="/kr/bubblegum-v2/sdk/javascript" description="Umi 프레임워크를 기반으로 한 MPL-Bubblegum JavaScript 라이브러리로 시작하세요." /%}
+
+{% quick-link title="Rust" icon="Rust" href="/kr/bubblegum-v2/sdk/rust" description="MPL-Bubblegum Rust 크레이트를 사용하여 시작하세요." /%}
+
+{% /quick-links %}

src/pages/kr/bubblegum-v2/sdk/javascript.md

@@ -0,0 +1,46 @@
+---
+title: MPL-Bubblegum JavaScript SDK
+metaTitle: JavaScript SDK | MPL-Bubblegum
+description: MPL-Bubblegum JavaScript SDK를 실행하도록 프로젝트를 설정하는 방법을 알아보세요.
+---
+
+Metaplex는 MPL-Bubblegum 프로그램과 상호 작용하는 데 사용할 수 있는 JavaScript 라이브러리를 제공합니다. [Umi 프레임워크](/kr/umi) 덕분에 많은 의견이 있는 종속성 없이 제공되므로 모든 JavaScript 프로젝트에서 사용할 수 있는 경량 라이브러리를 제공합니다.
+
+시작하려면 [Umi 프레임워크를 설치](/kr/umi/getting-started)하고 MPL-Bubblegum JavaScript 라이브러리를 설치해야 합니다.
+
+## 설치
+
+JavaScript 패키지 매니저(npm, yarn, bun 등)로 설치할 수 있습니다.
+```sh
+npm install @metaplex-foundation/mpl-bubblegum
+```
+
+{% quick-links %}
+
+{% quick-link title="typedoc" target="_blank" icon="JavaScript" href="https://mpl-bubblegum.typedoc.metaplex.com/" description="MPL-Bubblegum JavaScript SDK 생성된 패키지 API 문서." /%}
+
+{% quick-link title="npmjs.com" target="_blank" icon="JavaScript" href="https://www.npmjs.com/package/@metaplex-foundation/mpl-bubblegum" description="NPM의 MPL-Bubblegum Javascript SDK." /%}
+
+{% /quick-links %}
+
+## Umi 설정
+
+아직 `umi` 인스턴스를 설정하고 구성하지 않았다면 [Umi 시작하기](/kr/umi/getting-started) 페이지를 확인할 수 있습니다.
+
+`umi` 인스턴스를 초기화하는 동안 다음을 사용하여 MPL-Bubblegum 패키지를 `umi`에 추가할 수 있습니다
+
+```js
+.use(mplBubblegum())
+```
+
+```ts
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { mplBubblegum } from '@metaplex-foundation/mpl-bubblegum'
+
+// 원하는 RPC 엔드포인트를 사용하세요.
+const umi = createUmi('http://api.devnet.solana.com')
+... // 추가 umi 설정, 패키지 및 서명자
+.use(mplBubblegum())
+```
+
+여기서부터 `umi` 인스턴스가 MPL-Bubblegum 패키지에 액세스할 수 있어 그 기능을 탐색할 수 있습니다.

src/pages/kr/bubblegum-v2/sdk/rust.md

@@ -0,0 +1,116 @@
+---
+title: MPL-Bubblegum Rust SDK
+metaTitle: Rust SDK | MPL-Bubblegum
+description: MPL-Bubblegum Rust SDK를 실행하도록 프로젝트를 설정하는 방법을 알아보세요.
+---
+
+Metaplex는 MPL-Bubblegum 프로그램과 상호 작용하는 데 사용할 수 있는 Rust 라이브러리를 제공합니다. Rust 라이브러리는 CPI 명령어를 통해 Rust 스크립트/빌드와 온체인 프로그램에서 사용할 수 있습니다.
+
+## 설치
+
+MPL-Bubblegum Rust SDK는 스크립트/데스크톱/모바일 애플리케이션과 Solana 온체인 프로그램 모두에서 사용할 수 있습니다.
+
+```rust
+cargo add mpl-bubblegum
+```
+
+{% quick-links %}
+
+{% quick-link title="crates.io" target="_blank" icon="Rust" href="https://crates.io/crates/mpl-bubblegum" description="MPL-Bubblegum Rust 크레이트로 시작하세요." /%}
+
+{% quick-link title="docs.rs" target="_blank" icon="Rust" href="https://docs.rs/MPL-Bubblegum/latest/mpl_bubblegum/" description="MPL-Bubblegum용 Rust SDK typedoc 플랫폼." /%}
+
+{% /quick-links %}
+
+## 로컬 스크립트
+
+로컬 스크립트의 경우 나열된 모든 명령어의 `Builder` 버전을 사용하는 것을 권장합니다. 이러한 빌더는 많은 작업을 추상화하고 트랜잭션에 추가할 수 있는 명령어를 반환합니다.
+
+모든 Bubblegum 명령어 목록은 여기에서 찾을 수 있습니다: [MPL-Bubblegum - Rust Instructions](https://docs.rs/mpl-bubblegum/latest/mpl_bubblegum/instructions/index.html)
+
+Rust 사용에 대한 더 포괄적인 가이드는 [Metaplex Rust SDK 가이드](/kr/guides/rust/metaplex-rust-sdks) 페이지를 확인하세요.
+
+#### CreateTreeConfigBuilder - 예제
+
+```rust
+use mpl_bubblegum::{instructions::CreateTreeConfigV2Builder, programs::{SPL_ACCOUNT_COMPRESSION_ID, SPL_NOOP_ID}};
+use solana_client::{nonblocking::rpc_client, rpc_config::RpcSendTransactionConfig};
+use solana_sdk::{commitment_config::CommitmentConfig, pubkey::Pubkey, signature::Keypair, signer::Signer, system_program, transaction::Transaction};
+
+#[tokio::main]
+pub async fn create_tree(keypair: Keypair) {
+    let rpc_client = rpc_client::RpcClient::new("https://api.devnet.solana.com/".to_string());
+
+    let payer = keypair;
+        
+
+    let asset = Keypair::new();
+
+    let merkle_tree = Keypair::new();
+
+    let tree_config = Pubkey::find_program_address(
+        &[
+            &merkle_tree.pubkey().to_bytes(),
+        ],
+        &mpl_bubblegum::ID,
+    );
+
+    let create_tree_config_ix = CreateTreeConfigV2Builder::new()
+        .merkle_tree(merkle_tree.pubkey())
+        .tree_config(tree_config.0)
+        .payer(payer.pubkey())
+        .max_depth(20)
+        .max_buffer_size(1024)
+        .public(false)
+        .instruction();
+
+    let signers = vec![&asset, &payer];
+
+    let last_blockhash = rpc_client.get_latest_blockhash().await;
+
+    let create_tree_config_tx = Transaction::new_signed_with_payer(
+        &[create_tree_config_ix],
+        Some(&payer.pubkey()),
+        &signers,
+        last_blockhash.unwrap(),
+    );
+
+    let res = rpc_client
+        .send_transaction_with_config(&create_tree_config_tx, RpcSendTransactionConfig {
+            skip_preflight: false,
+            preflight_commitment: Some(CommitmentConfig::confirmed().commitment),
+            encoding: None,
+            max_retries: None,
+            min_context_slot: None,
+        })
+        .await
+        .unwrap();
+
+    println!("Signature: {:?}", res);
+}
+```
+
+## CPI (Cross Program Invocation)
+
+자체 프로그램에서 CPI 명령어를 수행하는 것은 `MPL-Bubblegum` Rust 크레이트의 모든 명령어에서 찾을 수 있는 명령어 함수의 `CpiBuilder` 버전을 사용하여 쉽게 달성할 수 있습니다.
+
+모든 Bubblegum 명령어 목록은 여기에서 찾을 수 있습니다: [Metaplex Bubblegum - Rust Instructions](https://docs.rs/mpl-bubblegum/latest/mpl_bubblegum/instructions/index.html)
+
+Metaplex 크레이트를 사용하여 CPI 명령어를 생성하는 더 포괄적인 가이드는 [Metaplex 프로그램에 CPI하는 방법 가이드](/kr/guides/rust/how-to-cpi-into-a-metaplex-program) 페이지를 확인하세요.
+
+#### CreateTreeConfigCpiBuilder - 예제
+
+```rust
+CreateTreeConfigV2CpiBuilder::new()
+        .merkle_tree(context.accounts.merkle_tree)
+        .tree_config(context.accounts.tree_config)
+        .payer(context.accounts.payer)
+        .tree_creator(context.accounts.tree_creator)
+        .log_wrapper(SPL_NOOP_ID)
+        .compression_program(context.accounts.compression_program)
+        .system_program(context.accounts.system_program)
+        .max_depth(20)
+        .max_buffer_size(1024)
+        .public(false)
+        .invoke()
+```

src/pages/kr/bubblegum-v2/stored-nft-data.md

@@ -0,0 +1,76 @@
+---
+title: NFT 데이터 저장 및 인덱싱
+metaTitle: NFT 데이터 저장 및 인덱싱 | Bubblegum V2
+description: Bubblegum에서 NFT 데이터가 저장되는 방식에 대해 자세히 알아보세요.
+---
+
+[개요](/kr/bubblegum#read-api)에서 언급했듯이 압축된 NFT(cNFT)가 생성되거나 수정될 때마다 해당 트랜잭션이 원장에 온체인으로 기록되지만 cNFT 상태 데이터는 계정 공간에 저장되지 않습니다. 이는 cNFT의 엄청난 비용 절약의 이유이지만 편의성과 유용성을 위해 cNFT 상태 데이터는 RPC 제공업체에 의해 인덱싱되고 **Metaplex DAS API**를 통해 사용할 수 있습니다.
+
+Metaplex는 DAS API의 [참조 구현](https://github.com/metaplex-foundation/digital-asset-rpc-infrastructure)을 만들었으며, 일부 RPC 제공업체는 특정 구현을 위해 이 코드의 일부 또는 전부를 사용하는 반면 다른 RPC 제공업체는 자체적으로 작성했습니다. Metaplex DAS API를 지원하는 다른 RPC 제공업체 목록은 ["Metaplex DAS API RPC"](/kr/rpc-providers) 페이지를 참조하세요.
+
+DAS API의 Metaplex 참조 구현에는 다음 주요 항목이 포함됩니다:
+* Solana 무투표 검증자 - 이 검증자는 합의하에 검증자 원장과 계정 데이터에만 안전하게 액세스하도록 구성됩니다.
+* Geyser 플러그인 - 플러그인을 "Plerkle"라고 하며 검증자에서 실행됩니다. 플러그인은 계정 업데이트, 슬롯 상태 업데이트, 트랜잭션 또는 블록 메타데이터 업데이트가 있을 때마다 알림을 받습니다. cNFT 인덱싱의 목적을 위해 플러그인의 `notify_transaction` 메서드는 Bubblegum이나 spl-account-compression 트랜잭션이 검증자에서 보일 때마다 트랜잭션 데이터를 제공하는 데 사용됩니다. 실제로 이러한 트랜잭션은 이벤트를 spl-noop 명령어 데이터로 전환하여 로그 잘림을 방지하기 위해 spl-account-compression과 Bubblegum에서 사용되는 spl-noop("작업 없음") 프로그램에서 오는 것입니다.
+* Redis 클러스터 - Redis 스트림은 각 업데이트 유형(계정, 트랜잭션 등)에 대한 큐로 사용됩니다. Geyser 플러그인은 이러한 스트림에 들어가는 데이터의 생산자입니다. Geyser 플러그인은 Flatbuffers 프로토콜을 사용하는 Plerkle 직렬화 형식으로 데이터를 변환한 다음 직렬화된 레코드를 적절한 Redis 데이터 스트림에 넣습니다.
+* 인제스터 프로세스 - 이는 Redis 스트림의 데이터 소비자입니다. 인제스터는 직렬화된 데이터를 파싱한 다음 Postgres 데이터베이스에 저장되는 SeaORM 데이터 객체로 변환합니다.
+* Postgres 데이터베이스 - 자산을 나타내는 여러 데이터베이스 테이블과 보았던 머클 트리의 상태를 저장하는 변경 로그 테이블이 있습니다. 후자는 Bubblegum 명령어와 함께 사용할 자산 증명을 요청할 때 사용됩니다. 머클 트리 변경에 대한 시퀀스 번호는 DAS API가 트랜잭션을 순서 없이 처리할 수 있도록 하는 데도 사용됩니다.
+* API 프로세스 - 최종 사용자가 RPC 제공업체에서 자산 데이터를 요청할 때 API 프로세스는 데이터베이스에서 자산 데이터를 검색하고 요청에 대해 제공할 수 있습니다.
+
+{% diagram %}
+{% node %}
+{% node #validator label="검증자" theme="indigo" /%}
+{% node theme="dimmed" %}
+Geyser 플러그인을 실행하고 \
+트랜잭션, 계정 \
+업데이트 등에 대해 알림을 받습니다.
+{% /node %}
+{% /node %}
+
+{% node x="200" parent="validator" %}
+{% node #messenger label="메시지 버스" theme="blue" /%}
+{% node theme="dimmed" %}
+각 업데이트 유형에 대한 \
+큐로서의 Redis 스트림.
+{% /node %}
+{% /node %}
+
+{% node x="200" parent="messenger" %}
+{% node #ingester label="인제스터 프로세스" theme="indigo" /%}
+{% node theme="dimmed" %}
+데이터를 파싱하고 \
+데이터베이스에 저장합니다
+{% /node %}
+{% /node %}
+
+{% node x="28" y="150" parent="ingester" %}
+{% node #database label="데이터베이스" theme="blue" /%}
+{% node theme="dimmed" %}
+Postgres \
+데이터베이스
+{% /node %}
+{% /node %}
+
+{% node x="-228" parent="database" %}
+{% node #api label="API 프로세스" theme="indigo" /%}
+{% node theme="dimmed" %}
+RPC 제공업체가 API를 실행하고\
+최종 사용자에게 자산 데이터를 \
+제공합니다.
+{% /node %}
+{% /node %}
+
+{% node x="-200" parent="api" %}
+{% node #end_user label="최종 사용자" theme="mint" /%}
+{% node theme="dimmed" %}
+getAsset(), \
+getAssetProof() 등을 호출합니다.
+{% /node %}
+{% /node %}
+
+{% edge from="validator" to="messenger" /%}
+{% edge from="messenger" to="ingester" /%}
+{% edge from="ingester" to="database" /%}
+{% edge from="database" to="api" /%}
+{% edge from="api" to="end_user" /%}
+
+{% /diagram %}

src/pages/kr/bubblegum-v2/transfer-cnfts.md

@@ -0,0 +1,110 @@
+---
+title: 압축된 NFT 전송
+metaTitle: 압축된 NFT 전송 | Bubblegum v2
+description: Bubblegum에서 압축된 NFT를 전송하는 방법을 알아보세요.
+---
+
+**transferV2** 명령어는 압축된 NFT를 한 소유자에서 다른 소유자로 전송하는 데 사용할 수 있습니다. 전송을 승인하려면 현재 소유자나 위임 권한(있는 경우) 중 하나가 트랜잭션에 서명해야 합니다. 위임된 권한은 리프 위임자나 컬렉션의 `permanentTransferDelegate`일 수 있습니다.
+
+이 명령어는 압축된 NFT를 업데이트하므로 Bubblegum 트리의 리프를 교체합니다. 이는 압축된 NFT의 무결성을 확인하기 위해 추가 매개변수를 제공해야 함을 의미합니다. 이러한 매개변수는 리프를 변경하는 모든 명령어에 공통이므로 [다음 FAQ](/kr/bubblegum-v2/faq#replace-leaf-instruction-arguments)에 문서화되어 있습니다. 다행히 Metaplex DAS API를 사용하여 이러한 매개변수를 자동으로 가져오는 도우미 메서드를 사용할 수 있습니다.
+
+{% callout title="트랜잭션 크기" type="note" %}
+트랜잭션 크기 오류가 발생하면 `getAssetWithProof`와 함께 `{ truncateCanopy: true }`를 사용하는 것을 고려하세요. 자세한 내용은 [FAQ](/kr/bubblegum-v2/faq#replace-leaf-instruction-arguments)를 참조하세요.
+{% /callout %}
+
+## Bubblegum V2 압축된 NFT 전송
+
+명령어는 다음 매개변수를 받아들입니다:
+
+- **리프 소유자**: 압축된 NFT의 현재 소유자. 기본적으로 트랜잭션의 지불자로 설정됩니다.
+- **리프 위임자**: 압축된 NFT의 현재 소유자와 위임 권한(있는 경우). 이 중 하나가 트랜잭션에 서명해야 합니다.
+- **권한**: 트랜잭션에 서명하는 선택적 권한. 리프 소유자나 `permanentTransferDelegate`일 수 있으며 기본적으로 트랜잭션의 `지불자`로 설정됩니다.
+- **새 리프 소유자**: 압축된 NFT의 새 소유자 주소
+- **머클 트리**: Bubblegum 트리의 주소
+- **루트**: Bubblegum 트리의 현재 루트
+- **데이터 해시**: 압축된 NFT의 메타데이터 해시
+- **크리에이터 해시**: 압축된 NFT의 크리에이터 해시
+- **넌스**: 압축된 NFT의 넌스
+- **인덱스**: 압축된 NFT의 인덱스
+- **컬렉션**: 압축된 NFT의 코어 컬렉션(cNFT가 컬렉션의 일부인 경우)
+
+JavaScript를 사용할 때 먼저 `getAssetWithProof` 함수를 사용하여 매개변수를 가져온 다음 `transferV2` 명령어에 전달하는 것을 제안합니다.
+
+{% dialect-switcher title="압축된 NFT 전송" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import { getAssetWithProof, transferV2 } from '@metaplex-foundation/mpl-bubblegum';
+const assetWithProof = await getAssetWithProof(umi, assetId, {
+  truncateCanopy: true,
+})
+
+// 그러면 leafOwnerA가 이를 사용하여 NFT를 leafOwnerB로 전송할 수 있습니다.
+const leafOwnerB = generateSigner(umi)
+await transferV2(umi, {
+  // 자산과 증명의 매개변수를 전달합니다.
+  ...assetWithProof,
+  authority: leafOwnerA,
+  newLeafOwner: leafOwnerB.publicKey,
+  // cNFT가 컬렉션의 일부인 경우 코어 컬렉션을 전달합니다.
+  //coreCollection: coreCollection.publicKey, 
+}).sendAndConfirm(umi)
+```
+
+{% totem-accordion title="위임자 사용" %}
+
+```ts
+import { getAssetWithProof, transferV2 } from '@metaplex-foundation/mpl-bubblegum'
+
+const assetWithProof = await getAssetWithProof(umi, assetId, {
+  truncateCanopy: true,
+})
+await transferV2(umi, {
+  // 자산과 증명의 매개변수를 전달합니다.
+  ...assetWithProof,
+  authority: delegateAuthority, // <- 위임된 권한이 트랜잭션에 서명합니다.
+  newLeafOwner: leafOwnerB.publicKey,
+  // cNFT가 컬렉션의 일부인 경우 코어 컬렉션을 전달합니다.
+  //coreCollection: coreCollection.publicKey, 
+}).sendAndConfirm(umi)
+```
+
+{% /totem-accordion %}
+
+{% totem-accordion title="영구 전송 위임자 사용" %}
+
+```ts
+import { getAssetWithProof, transferV2 } from '@metaplex-foundation/mpl-bubblegum'
+
+const assetWithProof = await getAssetWithProof(umi, assetId, {
+  truncateCanopy: true,
+})
+await transferV2(umi, {
+  ...assetWithProof,
+  authority: permanentTransferDelegate, // <- 위임된 권한이 트랜잭션에 서명합니다.
+  newLeafOwner: leafOwnerB.publicKey,
+  coreCollection: coreCollection.publicKey, 
+}).sendAndConfirm(umi)
+```
+
+{% /totem-accordion %}
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+### 압축된 NFT에 대한 전송 가능성 확인
+
+`canTransfer` 함수는 압축된 NFT를 전송할 수 있는지 확인하는 데 사용할 수 있습니다. NFT를 전송할 수 있으면 `true`를 반환하고 그렇지 않으면 `false`를 반환합니다. 동결된 cNFT와 `NonTransferable` cNFT는 전송할 수 없습니다.
+
+```ts
+import { canTransfer } from '@metaplex-foundation/mpl-bubblegum'
+
+const assetWithProof = await getAssetWithProof(umi, assetId, {
+  truncateCanopy: true,
+})
+
+const canBeTransferred = canTransfer(assetWithProof)
+console.log("canBeTransferred", canBeTransferred ? "Yes" : "No")
+```

src/pages/kr/bubblegum-v2/update-cnfts.md

@@ -0,0 +1,74 @@
+---
+title: 압축된 NFT 업데이트
+metaTitle: 압축된 NFT 업데이트 | Bubblegum V2
+description: Bubblegum에서 압축된 NFT를 업데이트하는 방법을 알아보세요.
+---
+
+**updateMetadataV2** 명령어는 압축된 NFT의 메타데이터를 수정하는 데 사용할 수 있습니다. 머클 루트가 업데이트되어 데이터의 전파된 해시를 반영하고, [Metaplex DAS API](https://github.com/metaplex-foundation/digital-asset-standard-api)를 준수하는 RPC 제공업체는 cNFT의 인덱스를 업데이트합니다.
+
+메타데이터는 압축된 NFT가 컬렉션의 확인된 항목인지 여부에 따라 두 권한 중 하나에 의해 업데이트될 수 있습니다.
+
+## 업데이트 권한
+
+cNFT는 두 가지 가능한 업데이트 권한을 가집니다: 트리 소유자, 또는 (컬렉션에 속한 경우) 컬렉션 권한.
+
+### 컬렉션 권한
+
+cNFT가 컬렉션에 속한 경우 해당 cNFT의 업데이트 권한은 컬렉션의 권한이 됩니다. cNFT를 업데이트할 때 업데이트 함수에 `coreCollection` 인수를 전달해야 합니다.
+
+권한은 현재 umi 신원에서 추론됩니다. 권한이 현재 umi 신원과 다른 경우 `authority` 인수를 서명자 타입으로 전달하거나 나중에 서명하기 위해 `noopSigner`를 생성해야 합니다.
+
+```js
+await updateMetadataV2(umi, {
+  ...
+  authority: collectionAuthority,
+  coreCollection: publicKey("11111111111111111111111111111111"),
+}).sendAndConfirm(umi)
+```
+
+### 트리 권한
+
+cNFT가 컬렉션에 속하지 않는 경우 cNFT의 업데이트 권한은 cNFT가 속한 트리의 권한이 됩니다. 이 경우 업데이트 함수에서 `coreCollection` 인수를 **생략**합니다.
+
+권한은 현재 umi 신원에서 추론됩니다. 권한이 현재 umi 신원과 다른 경우 `authority` 인수를 서명자 타입으로 전달하거나 나중에 서명하기 위해 `noopSigner`를 생성해야 합니다.
+
+## cNFT 업데이트
+
+{% dialect-switcher title="압축된 NFT 업데이트" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import {
+  getAssetWithProof,
+  updateMetadataV2,
+  UpdateArgsArgs,
+} from '@metaplex-foundation/mpl-bubblegum'
+import { some } from '@metaplex-foundation/umi'
+
+// 도우미를 사용하여 자산과 증명을 가져옵니다.
+const assetWithProof = await getAssetWithProof(umi, assetId, {
+  truncateCanopy: true,
+})
+
+// 그런 다음 NFT의 메타데이터를 업데이트하는 데 사용할 수 있습니다.
+const updateArgs: UpdateArgsArgs = {
+  name: some('새 이름'),
+  uri: some('https://updated-example.com/my-nft.json'),
+}
+await updateMetadataV2(umi, {
+  ...assetWithProof,
+  leafOwner,
+  currentMetadata: assetWithProof.metadata,
+  updateArgs,
+  // 선택적 매개변수. 권한이 현재 umi 신원과 다른 서명자 타입인 경우
+  // 여기에 해당 서명자를 할당합니다.
+  authority: <Signer>,
+  // 선택적 매개변수. cNFT가 컬렉션에 속한 경우 여기에 전달합니다.
+  coreCollection: publicKey("22222222222222222222222222222222"),
+}).sendAndConfirm(umi)
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/bubblegum-v2/verify-creators.md

@@ -0,0 +1,94 @@
+---
+title: 크리에이터 검증
+metaTitle: 크리에이터 검증 | Bubblegum V2
+description: Bubblegum에서 크리에이터를 확인하고 확인 해제하는 방법을 알아보세요.
+---
+
+압축된 NFT의 메타데이터에 크리에이터 목록이 설정되어 있는 경우 이러한 크리에이터는 특별한 명령어를 사용하여 cNFT에서 자신을 확인하고 확인 해제할 수 있습니다. {% .lead %}
+
+이러한 명령어는 cNFT의 **Creators** 배열의 해당 항목에서 **Verified** 부울을 토글합니다. 이 부울은 지갑과 마켓플레이스와 같은 앱이 어떤 크리에이터가 진짜이고 어떤 크리에이터가 아닌지 알 수 있게 해주므로 중요합니다.
+
+크리에이터는 민트 트랜잭션에 서명하여 [압축된 NFT를 민팅](/kr/bubblegum-v2/mint-cnfts)할 때 직접 자신을 확인할 수 있다는 점이 주목할 만합니다. 그렇긴 하지만 이제 크리에이터가 기존 압축된 NFT에서 자신을 확인하거나 확인 해제하는 방법을 살펴보겠습니다.
+
+## 크리에이터 확인
+
+Bubblegum 프로그램은 확인하려는 크리에이터가 서명해야 하는 **verifyCreatorV2** 명령어를 제공합니다. 크리에이터는 이미 압축된 NFT의 **Creators** 배열의 일부여야 합니다. 배열의 일부가 아닌 경우 [`updateMetadataV2`](/kr/bubblegum-v2/update-cnfts) 명령어를 사용하여 **Creators** 배열에 크리에이터를 먼저 추가하세요.
+
+추가로 이 명령어는 Bubblegum 트리의 리프를 교체하므로 압축된 NFT의 무결성을 확인하기 위해 더 많은 매개변수를 제공해야 합니다. 이러한 매개변수는 리프를 변경하는 모든 명령어에 공통이므로 [다음 FAQ](/kr/bubblegum-v2/faq#replace-leaf-instruction-arguments)에 문서화되어 있습니다. 다행히 Metaplex DAS API를 사용하여 이러한 매개변수를 자동으로 가져오는 도우미 메서드를 사용할 수 있습니다.
+
+{% dialect-switcher title="압축된 NFT의 크리에이터 확인" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import {
+  getAssetWithProof,
+  verifyCreatorV2,
+  MetadataArgsV2Args
+} from '@metaplex-foundation/mpl-bubblegum';
+import {
+  unwrapOption,
+  none,
+} from '@metaplex-foundation/umi';
+
+const assetWithProof = await getAssetWithProof(umi, assetId, {truncateCanopy: true});
+const collectionOption = unwrapOption(assetWithProof.metadata.collection);
+const metadata: MetadataArgsV2Args = {
+  name: assetWithProof.metadata.name,
+  uri: assetWithProof.metadata.uri,
+  sellerFeeBasisPoints: assetWithProof.metadata.sellerFeeBasisPoints,
+  collection: collectionOption
+    ? collectionOption.key
+    : none(),
+  creators: assetWithProof.metadata.creators,
+};
+await verifyCreatorV2(umi, {
+  ...assetWithProof,
+  metadata,
+  creator: umi.identity, // 또는 umi 신원과 다른 서명자
+}).sendAndConfirm(umi);
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 크리에이터 확인 해제
+
+**verifyCreatorV2** 명령어와 마찬가지로 **unverifyCreatorV2** 명령어는 크리에이터가 서명해야 하며 압축된 NFT에서 크리에이터의 확인을 해제합니다.
+
+{% dialect-switcher title="압축된 NFT의 크리에이터 확인 해제" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import {
+  getAssetWithProof,
+  unverifyCreatorV2,
+  MetadataArgsV2Args
+} from '@metaplex-foundation/mpl-bubblegum'
+import {
+  unwrapOption,
+  none,
+} from '@metaplex-foundation/umi';
+
+const assetWithProof = await getAssetWithProof(umi, assetId, {truncateCanopy: true});
+const metadata: MetadataArgsV2Args = {
+  name: assetWithProof.metadata.name,
+  uri: assetWithProof.metadata.uri,
+  sellerFeeBasisPoints: assetWithProof.metadata.sellerFeeBasisPoints,
+  collection: unwrapOption(assetWithProof.metadata.collection)
+    ? unwrapOption(assetWithProof.metadata.collection)!.key
+    : none(),
+  creators: assetWithProof.metadata.creators,
+};
+await unverifyCreatorV2(umi, {
+  ...assetWithProof,
+  metadata,
+  creator: umi.identity, // 또는 umi 신원과 다른 서명자
+}).sendAndConfirm(umi);
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/candy-machine/custom-guards/generating-client.md

@@ -0,0 +1,191 @@
+---
+title: Candy Machine용 커스텀 가드 클라이언트 생성
+metaTitle: 커스텀 가드 클라이언트 생성 | Candy Machine 
+description: 커스텀 가드용 Umi 호환 클라이언트를 생성하는 방법입니다.
+---
+
+Candy Machine Guard 프로그램용 커스텀 가드를 작성한 후에는 Umi SDK와 함께 작동하는 Kinobi 클라이언트를 생성해야 합니다. 예를 들어 프론트엔드에서 가드를 사용할 수 있도록 하기 위해서입니다.
+
+## IDL 및 초기 클라이언트 생성
+
+### Shankjs 구성
+
+Shankjs는 Anchor와 비-Anchor 프로그램 모두에서 작동하는 IDL 생성기입니다. 제대로 작동하는 클라이언트를 생성하려면 새로운 커스텀 Candy Guard 배포 키로 이를 구성하려고 합니다. mpl-candy-machine 저장소의 `/configs/shank.cjs`에 있는 파일을 편집하세요.
+
+```js
+/configs/shank.cjs
+
+generateIdl({
+  generator: "anchor",
+  programName: "candy_guard",
+  programId: "Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g", // 커스텀 Candy Guard 배포된 프로그램 키
+  idlDir,
+  binaryInstallDir,
+  programDir: path.join(programDir, "candy-guard", "program"),
+});
+
+```
+
+{% callout %}
+anchor 28을 사용하여 생성하는 경우 누락된 crates.io crate로 인해 Shankjs idl 생성기에 anchor 27로의 폴백을 추가해야 합니다.
+{% /callout %}
+
+```js
+/configs/shank.cjs
+
+generateIdl({
+  generator: "anchor",
+  programName: "candy_guard",
+  programId: "Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g", // 커스텀 Candy Guard 배포된 프로그램 키
+  idlDir,
+  binaryInstallDir,
+  programDir: path.join(programDir, "candy-guard", "program"),
+  rustbin: {
+    locked: true,
+    versionRangeFallback: "0.27.0",
+  },
+});
+
+```
+
+### IDL 및 클라이언트 생성
+
+이제 IDL과 초기 클라이언트를 생성할 수 있을 것입니다. 프로젝트 루트에서 실행하세요
+
+```shell
+pnpm run generate
+```
+
+이는 `pnpm generate:idls`와 `pnpm generate:clients` 스크립트를 모두 실행하고 초기 클라이언트를 구축합니다.
+어떤 이유로든 이를 별도로 실행해야 하는 경우 그렇게 할 수 있습니다.
+
+## 클라이언트에 가드 추가
+
+### 가드 파일 생성
+
+초기 클라이언트의 성공적인 생성이 완료되면 `/clients/js/src`로 이동하세요.
+
+첫 번째 단계는 `/clients/js/src/defaultGuards` 폴더에 새로운 가드를 추가하는 것입니다.
+
+아래는 생성한 가드 유형에 따라 필요에 맞게 조정할 수 있는 템플릿입니다.
+가드에 원하는 이름을 지을 수 있지만 예시로 `customGuard.ts`라고 하겠습니다
+
+```ts
+import { PublicKey } from '@metaplex-foundation/umi'
+import {
+  getCustomGuardSerializer,
+  CustomGuard,
+  CustomGuardArgs,
+} from '../generated'
+import { GuardManifest, noopParser } from '../guards'
+
+export const customGuardManifest: GuardManifest<
+  CustomGuardArgs,
+  CustomGuard,
+  CustomGuardMintArgs
+> = {
+  name: 'customGuard',
+  serializer: getCustomGuardSerializer,
+  mintParser: (context, mintContext, args) => {
+    const { publicKeyArg1, arg1 } = args
+    return {
+      data: new Uint8Array(),
+      // 민트 args에서 커스텀 가드에 필요한 모든 계정을 전달합니다.
+      // 가드는 나머지 계정이 필요할 수도 있고 필요하지 않을 수도 있습니다.
+      remainingAccounts: [
+        { publicKey: publicKeyArg1, isWritable: true },
+        { publicKey: publicKeyArg2, isWritable: false },
+      ],
+    }
+  },
+  routeParser: noopParser,
+}
+
+// 여기서 가드가 작동하기 위해 필요한 모든 커스텀 민트 args를 작성합니다.
+// 가드는 MintArgs가 필요할 수도 있고 필요하지 않을 수도 있습니다.
+
+export type CustomGuardMintArgs = {
+  /**
+   * 커스텀 가드 민트 인수 1
+   */
+  publicKeyArg1: PublicKey
+
+  /**
+   * 커스텀 가드 민트 인수 2
+   */
+  publicKeyArg2: PublicKey
+
+  /**
+   * 커스텀 가드 민트 인수 3
+   */
+  arg3: Number
+}
+```
+
+### 기존 파일에 가드 추가
+
+여기서 기존 파일들에 새로운 가드를 추가해야 합니다.
+
+`/clients/js/src/defaultGuards/index.ts`에서 새로운 가드를 내보내세요
+
+```ts
+...
+export * from './tokenGate';
+export * from './tokenPayment';
+export * from './token2022Payment';
+// 가드를 목록에 추가
+export * from './customGuard';
+```
+
+`/clients/js/src/defaultGuards/defaults.ts` 내에서 다음 위치에 가드를 추가하세요;
+
+```ts
+import { CustomGuardArgs } from "../generated"
+
+export type DefaultGuardSetArgs = GuardSetArgs & {
+    ...
+     // 가드를 목록에 추가
+    customGuard: OptionOrNullable<CustomGuardArgs>;
+}
+```
+
+```ts
+import { CustomGuard } from "../generated"
+
+export type DefaultGuardSet = GuardSet & {
+    ...
+     // 가드를 목록에 추가
+    customGuard: Option<CustomGuard>
+}
+```
+
+```ts
+import { CustomGuardMintArgs } from "./defaultGuards/customGuard.ts"
+export type DefaultGuardSetMintArgs = GuardSetMintArgs & {
+    ...
+    // 가드를 목록에 추가
+    customGuard: OptionOrNullable<CustomGuardMintArgs>
+}
+```
+
+```ts
+export const defaultCandyGuardNames: string[] = [
+  ...// 가드를 목록에 추가
+  'customGuard',
+]
+```
+
+마지막으로 내보낸 customGuardManifest를 `/clients/js/src/plugin.ts`에 있는 플러그인 파일에 추가해야 합니다
+
+```ts
+import {customGuardManifest} from "./defaultGuards"
+
+ umi.guards.add(
+  ...// 가드 매니페스트를 목록에 추가
+  customGuardManifest
+)
+```
+
+이 지점에서 클라이언트 패키지를 구축하여 npm에 업로드하거나 새로운 가드 클라이언트에 액세스하려는 프로젝트 폴더에 링크/이동할 수 있습니다.
+
+AVA의 내장 테스트 도구를 사용하여 여러 시나리오에서 가드를 완전히 테스트하는 테스트를 작성하는 것이 좋습니다. 테스트 예시는 `/clients/js/tests`에서 찾을 수 있습니다.

src/pages/kr/candy-machine/getting-started/index.md

@@ -0,0 +1,17 @@
+---
+title: 시작하기
+metaTitle: 시작하기 | Candy Machine
+description: Candy Machine을 시작하세요.
+---
+
+Candy Machine을 시작하려면 아래에서 사용하고자 하는 언어/라이브러리를 선택하세요.
+
+{% quick-links %}
+
+{% quick-link title="JavaScript" icon="JavaScript" href="/kr/candy-machine/getting-started/js" description="Umi 프레임워크 기반의 JavaScript 라이브러리를 시작하세요." /%}
+
+{% quick-link title="Rust" icon="Rust" href="/kr/candy-machine/getting-started/rust" description="Rust 크레이트를 사용하여 시작하세요." /%}
+
+{% quick-link title="Sugar" icon="SolidCommandLine" href="/kr/candy-machine/sugar/getting-started" description="명령줄 도구 Sugar를 사용하여 시작하세요." /%}
+
+{% /quick-links %}

src/pages/kr/candy-machine/getting-started/js.md

@@ -0,0 +1,50 @@
+---
+title: JavaScript를 사용하여 시작하기
+metaTitle: JavaScript SDK | Candy Machine
+description: JavaScript를 사용하여 Candy Machine을 시작하세요
+---
+
+Metaplex는 Candy Machine과 상호작용하는 데 사용할 수 있는 JavaScript 라이브러리를 제공합니다. [Umi 프레임워크](https://github.com/metaplex-foundation/umi) 덕분에 많은 고정된 종속성 없이 제공되므로 모든 JavaScript 프로젝트에서 사용할 수 있는 경량 라이브러리를 제공합니다.
+
+시작하려면 [Umi 프레임워크](https://github.com/metaplex-foundation/umi/blob/main/docs/installation.md)와 Candy Machine JavaScript 라이브러리를 설치해야 합니다.
+
+```sh
+npm install \
+  @metaplex-foundation/umi \
+  @metaplex-foundation/umi-bundle-defaults \
+  @solana/web3.js@1 \
+  @metaplex-foundation/mpl-candy-machine
+```
+
+다음으로 `Umi` 인스턴스를 생성하고 다음과 같이 `mplCandyMachine` 플러그인을 설치할 수 있습니다.
+
+```ts
+import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
+import { mplCandyMachine } from '@metaplex-foundation/mpl-candy-machine'
+
+// 선택한 RPC 엔드포인트를 사용하세요.
+const umi = createUmi('http://127.0.0.1:8899').use(mplCandyMachine())
+```
+
+그런 다음 사용할 지갑을 Umi에게 알려주어야 합니다. 이는 [키페어](/kr/umi/connecting-to-umi#connecting-w-a-secret-key) 또는 [Solana 지갑 어댑터](/kr/umi/connecting-to-umi#connecting-w-wallet-adapter)일 수 있습니다.
+
+이제 [라이브러리에서 제공하는 다양한 함수](https://mpl-candy-machine.typedoc.metaplex.com/)를 사용하고 `Umi` 인스턴스를 전달하여 NFT와 상호작용할 수 있습니다. 다음은 Candy Machine 계정과 관련된 Candy Guard 계정을 가져오는 예시입니다.
+
+```ts
+import { publicKey } from '@metaplex-foundation/umi'
+import {
+  fetchCandyMachine,
+  fetchCandyGuard,
+} from '@metaplex-foundation/mpl-candy-machine'
+
+const candyMachinePublicKey = publicKey('...')
+const candyMachine = await fetchCandyMachine(umi, candyMachinePublicKey)
+const candyGuard = await fetchCandyGuard(umi, candyMachine.mintAuthority)
+```
+
+🔗 **유용한 링크:**
+
+- [Umi 프레임워크](https://github.com/metaplex-foundation/umi)
+- [GitHub 저장소](https://github.com/metaplex-foundation/mpl-candy-machine)
+- [NPM 패키지](https://www.npmjs.com/package/@metaplex-foundation/mpl-candy-machine)
+- [API 참조](https://mpl-candy-machine.typedoc.metaplex.com/)

src/pages/kr/candy-machine/getting-started/rust.md

@@ -0,0 +1,20 @@
+---
+title: Rust를 사용하여 시작하기
+metaTitle: Candy Machine - 시작하기 - Rust SDK | Candy Machine
+description: Rust를 사용하여 Candy Machine을 시작하세요
+---
+
+Rust 개발자라면 Rust 크레이트를 사용하여 Candy Machine 프로그램과 상호작용할 수도 있습니다. 프로그램이 Rust로 작성되었기 때문에 이 크레이트에는 우리를 위해 명령어를 준비하는 도우미 메서드를 포함하여 모든 프로그램 로직이 포함되어 있습니다.
+
+이는 Rust 클라이언트를 개발하거나 프로그램 내에서 Candy Machine 프로그램에 [CPI 호출](https://solanacookbook.com/references/programs.html#how-to-do-cross-program-invocation)을 하려는 경우에 도움이 될 수 있습니다.
+
+Candy Machine은 두 개의 프로그램으로 구성되어 있으므로 두 개의 라이브러리를 설치해야 합니다.
+
+- **Candy Machine Core**
+  - [GitHub 저장소](https://github.com/metaplex-foundation/mpl-candy-machine/tree/main/programs/candy-machine-core)
+  - [크레이트 페이지](https://crates.io/crates/mpl-candy-machine-core)
+  - [API 참조](https://docs.rs/mpl-candy-machine-core/0.1.0/mpl_candy_machine_core/)
+- **Candy Guard**
+  - [GitHub 저장소](https://github.com/metaplex-foundation/mpl-candy-machine/tree/main/programs/candy-guard)
+  - [크레이트 페이지](https://crates.io/crates/mpl-candy-guard)
+  - [API 참조](https://docs.rs/mpl-candy-guard/0.1.0/mpl_candy_guard/)

src/pages/kr/candy-machine/guard-groups.md

@@ -0,0 +1,351 @@
+---
+title: 가드 그룹
+metaTitle: 가드 그룹 | Candy Machine
+description: 여러 가드 그룹을 구성하는 방법을 설명합니다.
+---
+
+[이전 페이지](/kr/candy-machine/guards)에서 가드를 소개하고 이를 사용하여 Candy Machine의 접근 제어를 정의했습니다. 가드를 사용하여 민팅당 1 SOL의 결제를 추가하고 특정 날짜 이후에 민팅이 시작되도록 할 수 있음을 보았습니다. 하지만 두 번째 날짜 이후에 2 SOL을 청구하고 싶다면 어떨까요? 특정 토큰 보유자가 무료로 또는 할인된 가격으로 민팅할 수 있도록 하고 싶다면 어떨까요? {% .lead %}
+
+각각 고유한 요구 사항을 가진 여러 가드 세트를 정의할 수 있다면 어떨까요? 이러한 이유로 **가드 그룹**을 만들었습니다!
+
+## 그룹은 어떻게 작동하나요?
+
+활성화하려는 가드의 설정을 제공하여 [Candy Machine에 가드를 설정할 수 있는 방법](/kr/candy-machine/guards#creating-a-candy-machine-with-guards)을 기억하시나요? 가드 그룹도 같은 방식으로 작동하지만, 식별을 위해 고유한 **레이블**을 제공해야 합니다.
+
+따라서 각 가드 그룹은 다음과 같은 속성을 가집니다:
+
+- **레이블**: 고유한 텍스트 식별자입니다. 6자 이하여야 합니다.
+- **가드**: 해당 그룹 내에서 활성화된 모든 가드의 설정입니다. 이는 Candy Machine에 직접 가드를 설정하는 것과 같은 방식으로 작동합니다.
+
+간단한 예시를 들어보겠습니다. 오후 4시부터 5시까지 1 SOL을 청구하고, 오후 5시부터 Candy Machine이 소진될 때까지 2 SOL을 청구하고 싶다고 해봅시다. 모든 것은 Bot Tax 가드를 통해 봇으로부터 보호받으면서 말입니다. 다음과 같이 가드를 설정할 수 있습니다:
+
+- 그룹 1:
+  - **레이블**: "early"
+  - **가드**:
+    - SOL 결제: 1 SOL
+    - 시작 날짜: 오후 4시 (단순함을 위해 실제 날짜는 무시)
+    - 종료 날짜: 오후 5시
+    - Bot Tax: 0.001 SOL
+- 그룹 2:
+  - **레이블**: "late"
+  - **가드**:
+    - SOL 결제: 2 SOL
+    - 시작 날짜: 오후 5시
+    - Bot Tax: 0.001 SOL
+
+이렇게 해서 맞춤형 2단계 민팅 프로세스를 만들었습니다!
+
+이제 누군가가 우리의 Candy Machine에서 민팅을 시도할 때마다 **어느 그룹에서 민팅하는지 명시적으로 알려줘야 합니다**. 민팅할 때 그룹 레이블을 요청하는 것이 중요한 이유는:
+
+- 구매자가 예상치 못한 민팅 동작을 경험하지 않도록 보장합니다. 첫 번째 그룹의 종료 날짜 맨 마지막에 1 SOL로 민팅을 시도했지만, 트랜잭션이 실행될 때까지 해당 날짜가 지났다고 해봅시다. 그룹 레이블을 요청하지 않았다면 트랜잭션은 성공하고 1 SOL만 지불할 것으로 예상했음에도 불구하고 2 SOL이 청구될 것입니다.
+- 병렬 그룹을 지원할 수 있게 해줍니다. 이에 대해서는 이 페이지 뒷부분에서 더 자세히 다루겠습니다.
+
+{% diagram %}
+
+{% node %}
+{% node #candy-machine-1 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% /node %}
+
+{% node parent="candy-machine-1" y=80 x=20 %}
+{% node #candy-guard-1 label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node #group-1 theme="mint" z=1 %}
+그룹 1: "early" {% .font-semibold %}
+{% /node %}
+{% node label="SOL 결제" /%}
+{% node label="시작 날짜" /%}
+{% node label="종료 날짜" /%}
+{% node label="Bot Tax" /%}
+{% node theme="mint" z=1 %}
+그룹 2: "late"
+{% /node %}
+{% node label="SOL 결제" /%}
+{% node label="시작 날짜" /%}
+{% node label="Bot Tax" /%}
+{% /node %}
+
+{% node parent="candy-machine-1" x=350 %}
+{% node #mint-1 label="민팅" theme="pink" /%}
+{% node label="Candy Guard Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-1" x=45 y=-20 label="접근 제어" theme="transparent" /%}
+
+{% node parent="mint-1" x=-22 y=100 %}
+{% node #mint-2 label="민팅" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-2" x=120 y=-20 label="민팅 로직" theme="transparent" /%}
+
+{% node #nft parent="mint-2" x=62 y=100 label="NFT" /%}
+
+{% edge from="candy-guard-1" to="candy-machine-1" fromPosition="left" toPosition="left" arrow=false /%}
+{% edge from="mint-1" to="mint-2" theme="pink" path="straight" /%}
+{% edge from="mint-2" to="nft" theme="pink" path="straight" /%}
+{% edge from="candy-machine-1" to="mint-1" theme="pink" /%}
+{% edge from="group-1" to="mint-1" theme="pink" %}
+어느 그룹에서 \
+민팅할지 선택
+{% /edge %}
+
+{% /diagram %}
+
+이제 SDK를 사용하여 그룹을 생성하고 업데이트하는 방법을 살펴보겠습니다.
+
+{% dialect-switcher title="가드 그룹과 함께 Candy Machine 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+가드 그룹과 함께 Candy Machine을 생성하려면 `create` 함수에 `groups` 배열을 제공하기만 하면 됩니다. 이 배열의 각 항목은 `label`과 해당 그룹에서 활성화하려는 모든 가드의 설정을 포함하는 `guards` 객체를 포함해야 합니다.
+
+Umi 라이브러리를 사용하여 위 예시를 구현하는 방법은 다음과 같습니다.
+
+```ts
+import { some, sol, dateTime } from '@metaplex-foundation/umi'
+
+await create(umi, {
+  // ...
+  groups: [
+    {
+      label: 'early',
+      guards: {
+        solPayment: some({ lamports: sol(1), destination: treasury }),
+        startDate: some({ date: dateTime('2022-10-18T16:00:00Z') }),
+        endDate: some({ date: dateTime('2022-10-18T17:00:00Z') }),
+        botTax: some({ lamports: sol(0.001), lastInstruction: true }),
+      },
+    },
+    {
+      label: 'late',
+      guards: {
+        solPayment: some({ lamports: sol(2), destination: treasury }),
+        startDate: some({ date: dateTime('2022-10-18T17:00:00Z') }),
+        botTax: some({ lamports: sol(0.001), lastInstruction: true }),
+      },
+    },
+  ],
+}).sendAndConfirm(umi)
+```
+
+그룹을 업데이트하려면 `updateCandyGuard` 함수에 동일한 `groups` 속성을 제공하면 됩니다.
+전체 `guards` 객체와 `groups` 배열이 업데이트되므로 **기존의 모든 데이터를 덮어씁니다!**
+
+따라서 설정이 변경되지 않더라도 모든 그룹의 설정을 제공해야 합니다. 기존 설정을 덮어쓰지 않도록 미리 최신 candy guard 계정 데이터를 가져올 수 있습니다.
+
+다음은 "late" 그룹의 SOL 결제 가드를 2 SOL 대신 3 SOL로 변경하는 예시입니다.
+
+```ts
+import { some, sol, dateTime } from '@metaplex-foundation/umi'
+
+const candyGuard = await fetchCandyGuard(umi, candyMachine.mintAuthority)
+await updateCandyGuard(umi, {
+  candyGuard: candyGuard.publicKey,
+  guards: candyGuard.guards,
+  groups: [
+    {
+      label: 'early',
+      guards: {
+        solPayment: some({ lamports: sol(1), destination: treasury }),
+        startDate: some({ date: dateTime('2022-10-18T16:00:00Z') }),
+        endDate: some({ date: dateTime('2022-10-18T17:00:00Z') }),
+        botTax: some({ lamports: sol(0.001), lastInstruction: true }),
+      },
+    },
+    {
+      label: 'late',
+      guards: {
+        solPayment: some({ lamports: sol(3), destination: treasury }),
+        startDate: some({ date: dateTime('2022-10-18T17:00:00Z') }),
+        botTax: some({ lamports: sol(0.001), lastInstruction: true }),
+      },
+    },
+  ],
+}).sendAndConfirm(umi)
+```
+
+API 참조: [create](https://mpl-candy-machine.typedoc.metaplex.com/functions/create.html), [updateCandyGuard](https://mpl-candy-machine.typedoc.metaplex.com/functions/updateCandyGuard.html), [DefaultGuardSetArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/DefaultGuardSetArgs.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 기본 가드
+
+위의 예시에서 두 그룹 모두에 동일한 **Bot Tax** 가드를 제공해야 했음에 주목하세요. 이는 Candy Machine에 설정된 글로벌 **가드**를 활용하여 단순화할 수 있습니다.
+
+가드 그룹을 사용할 때, [이전 페이지](/kr/candy-machine/guards)에서 설명한 Candy Machine의 글로벌 가드는 **기본 가드 역할**을 합니다! 즉, 그룹에서 명시적으로 활성화하여 덮어쓰지 않는 한 그룹은 글로벌 가드와 동일한 가드 설정을 기본값으로 사용합니다.
+
+간단한 요약입니다:
+
+- 기본 가드에서는 활성화되어 있지만 그룹의 가드에서는 활성화되어 있지 않은 가드가 있으면, 그룹은 **기본 가드에서 정의된 대로** 가드를 사용합니다.
+- 기본 가드에서도 활성화되어 있고 그룹의 가드에서도 활성화되어 있는 가드가 있으면, 그룹은 **그룹의 가드에서 정의된 대로** 가드를 사용합니다.
+- 기본 가드나 그룹의 가드에서 활성화되어 있지 않은 가드는 그룹에서 사용하지 않습니다.
+
+이를 설명하기 위해 이전 섹션의 예시를 가져와서 **Bot Tax** 가드를 기본 가드로 이동해보겠습니다.
+
+- 기본 가드:
+  - Bot Tax: 0.001 SOL
+- 그룹 1:
+  - **레이블**: "early"
+  - **가드**:
+    - SOL 결제: 1 SOL
+    - 시작 날짜: 오후 4시
+    - 종료 날짜: 오후 5시
+- 그룹 2:
+  - **레이블**: "late"
+  - **가드**:
+    - SOL 결제: 2 SOL
+    - 시작 날짜: 오후 5시
+
+보시다시피, 기본 가드는 그룹 내에서 반복을 피하는 데 유용합니다.
+
+{% diagram %}
+
+{% node %}
+{% node #candy-machine-1 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% /node %}
+
+{% node parent="candy-machine-1" y=80 x=20 %}
+{% node #candy-guard-1 label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node label="가드 (기본 가드)" theme="mint" z=1 /%}
+{% node label="Bot Tax" /%}
+{% node #group-1 theme="mint" z=1 %}
+그룹 1: "early" {% .font-semibold %}
+{% /node %}
+{% node label="SOL 결제" /%}
+{% node label="시작 날짜" /%}
+{% node label="종료 날짜" /%}
+{% node theme="mint" z=1 %}
+그룹 2: "late"
+{% /node %}
+{% node label="SOL 결제" /%}
+{% node label="시작 날짜" /%}
+{% /node %}
+
+{% node parent="candy-machine-1" x=350 %}
+{% node #mint-1 label="민팅" theme="pink" /%}
+{% node label="Candy Guard Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-1" x=45 y=-20 label="접근 제어" theme="transparent" /%}
+
+{% node parent="mint-1" x=-22 y=100 %}
+{% node #mint-2 label="민팅" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-2" x=120 y=-20 label="민팅 로직" theme="transparent" /%}
+
+{% node #nft parent="mint-2" x=62 y=100 label="NFT" /%}
+
+{% edge from="candy-guard-1" to="candy-machine-1" fromPosition="left" toPosition="left" arrow=false /%}
+{% edge from="mint-1" to="mint-2" theme="pink" path="straight" /%}
+{% edge from="mint-2" to="nft" theme="pink" path="straight" /%}
+{% edge from="candy-machine-1" to="mint-1" theme="pink" /%}
+{% edge from="group-1" to="mint-1" theme="pink" /%}
+
+{% /diagram %}
+
+기본 가드를 사용하더라도 민팅할 때 그룹을 제공해야 함에 주의하세요. 즉, 가드 그룹을 사용할 때는 **기본 가드만을 사용하여 민팅하는 것이 불가능합니다**.
+
+{% dialect-switcher title="기본 가드와 가드 그룹으로 Candy Machine 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+Umi 라이브러리에서 기본 가드를 사용하려면 Candy Machine을 생성하거나 업데이트할 때 `guards` 속성을 `groups` 배열과 함께 사용하기만 하면 됩니다. 예를 들어, 위에서 설명한 가드 설정을 사용하여 Candy Machine을 생성하는 방법은 다음과 같습니다.
+
+```ts
+import { some, sol, dateTime } from '@metaplex-foundation/umi'
+
+await create(umi, {
+  // ...
+  guards: {
+    botTax: some({ lamports: sol(0.001), lastInstruction: true }),
+  },
+  groups: [
+    {
+      label: 'early',
+      guards: {
+        solPayment: some({ lamports: sol(1), destination: treasury }),
+        startDate: some({ date: dateTime('2022-10-18T16:00:00Z') }),
+        endDate: some({ date: dateTime('2022-10-18T17:00:00Z') }),
+      },
+    },
+    {
+      label: 'late',
+      guards: {
+        solPayment: some({ lamports: sol(2), destination: treasury }),
+        startDate: some({ date: dateTime('2022-10-18T17:00:00Z') }),
+      },
+    },
+  ],
+}).sendAndConfirm(umi)
+```
+
+API 참조: [create](https://mpl-candy-machine.typedoc.metaplex.com/functions/create.html), [DefaultGuardSetArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/DefaultGuardSetArgs.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 병렬 그룹
+
+민팅할 때 그룹 레이블을 요구하는 정말 흥미로운 이점 중 하나는 **주어진 시간에 둘 이상의 유효한 그룹을 가질 수 있다**는 것입니다. 이는 프로그램에서 모든 모호함을 제거하고 구매자가 민팅을 시도할 그룹을 선택할 수 있게 해줍니다.
+
+새로운 예시로 이를 설명해보겠습니다. "Innocent Bird"라는 NFT 컬렉션이 있고 "Innocent Bird" NFT를 보유한 누구에게나 1 SOL의 할인 가격을 제공하고 다른 모든 사람에게는 2 SOL을 청구하고 싶다고 해봅시다. 두 그룹 모두 동시에(오후 4시라고 하자) 민팅을 시작할 수 있도록 하고, 두 그룹 모두 봇으로부터 보호받고 싶습니다. 다음과 같이 가드를 구성할 수 있습니다:
+
+- 기본 가드:
+  - 시작 날짜: 오후 4시
+  - Bot Tax: 0.001 SOL
+- 그룹 1:
+  - **레이블**: "nft"
+  - **가드**:
+    - SOL 결제: 1 SOL
+    - NFT 게이트: "Innocent Bird" 컬렉션
+- 그룹 2:
+  - **레이블**: "public"
+  - **가드**:
+    - SOL 결제: 2 SOL
+
+보시다시피, 이러한 가드 설정으로 두 그룹 모두 동시에 민팅할 수 있습니다. NFT 보유자가 "public" 그룹에서 민팅하기로 결정한다면 전체 2 SOL을 지불할 수도 있습니다. 하지만 가능하다면 "nft" 그룹을 선택하는 것이 그들의 최선의 이익입니다.
+
+{% dialect-switcher title="병렬 그룹으로 Candy Machine 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+Umi 라이브러리를 통해 위에서 설명한 가드 설정을 사용하여 Candy Machine을 생성하는 방법은 다음과 같습니다.
+
+```ts
+import { some, sol, dateTime } from '@metaplex-foundation/umi'
+
+await create(umi, {
+  // ...
+  guards: {
+    botTax: some({ lamports: sol(0.001), lastInstruction: true }),
+    startDate: some({ date: dateTime('2022-10-18T16:00:00Z') }),
+  },
+  groups: [
+    {
+      label: 'early',
+      guards: {
+        solPayment: some({ amount: sol(1), destination: treasury }),
+        nftGate: some({
+          requiredCollection: innocentBirdCollectionNft.publicKey,
+        }),
+      },
+    },
+    {
+      label: 'late',
+      guards: {
+        solPayment: some({ amount: sol(2), destination: treasury }),
+      },
+    },
+  ],
+}).sendAndConfirm(umi)
+```
+
+API 참조: [create](https://mpl-candy-machine.typedoc.metaplex.com/functions/create.html), [DefaultGuardSetArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/DefaultGuardSetArgs.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 결론
+
+가드 그룹은 우리의 요구에 맞춘 순차적 그리고/또는 병렬 민팅 워크플로를 정의할 수 있게 하여 Candy Machine에 완전히 새로운 차원을 제공합니다.
+
+[다음 페이지](/kr/candy-machine/guard-route)에서는 가드에 대한 또 다른 흥미로운 기능인 가드 명령어를 살펴보겠습니다!

src/pages/kr/candy-machine/guard-route.md

@@ -0,0 +1,207 @@
+---
+title: 특별한 가드 명령어
+metaTitle: 특별한 가드 명령어 | Candy Machine
+description: 가드별 명령어를 실행하는 방법을 설명합니다.
+---
+
+이전 페이지에서 본 바와 같이, 가드는 Candy Machine의 민팅 프로세스를 맞춤화할 수 있는 강력한 방법입니다. 하지만 가드가 고유한 맞춤 명령어를 제공할 수도 있다는 것을 알고 계셨나요? {% .lead %}
+
+## Route 명령어
+
+Candy Guard 프로그램은 **"Route" 명령어**라고 불리는 특별한 명령어와 함께 제공됩니다.
+
+이 명령어를 사용하면 Candy Machine에서 **특정 가드를 선택**하고 해당 가드에 특화된 **맞춤 명령어를 실행**할 수 있습니다. 요청을 선택된 가드로 라우팅하기 때문에 "Route" 명령어라고 부릅니다.
+
+이 기능은 가드가 고유한 프로그램 로직과 함께 제공될 수 있게 하여 가드를 더욱 강력하게 만듭니다. 이를 통해 가드는 다음과 같은 일을 할 수 있습니다:
+
+- 무거운 작업에 대해 검증 프로세스를 민팅 프로세스에서 분리합니다.
+- 커스텀 프로그램 배포가 필요했던 맞춤 기능을 제공합니다.
+
+route 명령어를 호출하려면 라우팅할 가드를 지정하고 **가드가 기대하는 route 설정을 제공**해야 합니다. 지원하지 않는 가드를 선택하여 "route" 명령어를 실행하려고 하면 트랜잭션이 실패할 것입니다.
+
+Candy Guard 프로그램에 등록된 가드당 하나의 "route" 명령어만 있을 수 있기 때문에, 동일한 가드에서 제공하는 여러 기능을 구분하기 위해 route 설정에 **Path** 속성을 제공하는 것이 일반적입니다.
+
+예를 들어, 민팅이 끝난 후에만 해동될 수 있는 동결된 NFT에 대한 지원을 추가하는 가드는 route 명령어를 사용하여 treasury escrow 계정을 초기화하고 올바른 조건 하에서 누구나 민팅된 NFT를 해동할 수 있게 할 수 있습니다. 전자의 경우 "init", 후자의 경우 "thaw"와 같은 **Path** 속성을 사용하여 이 두 기능을 구분할 수 있습니다.
+
+route 명령어를 지원하는 각 가드와 그 기본 경로에 대한 자세한 설명은 [각각의 페이지](/kr/candy-machine/guards)에서 찾을 수 있습니다.
+
+예시를 제공하여 route 명령어가 어떻게 작동하는지 설명해보겠습니다. 예를 들어 [**Allow List**](/kr/candy-machine/guards/allow-list) 가드는 민팅 지갑이 미리 구성된 지갑 목록의 일부인지 확인하기 위해 route 명령어를 지원합니다.
+
+이는 [Merkle Trees](https://en.m.wikipedia.org/wiki/Merkle_tree)를 사용하여 수행되므로 허용된 지갑의 전체 목록의 해시를 생성하고 해당 해시(**Merkle Root**라고 알려진)를 가드 설정에 저장해야 합니다. 지갑이 허용 목록에 있음을 증명하려면 프로그램이 Merkle Root를 계산하고 가드의 설정과 일치하는지 확인할 수 있는 해시 목록(**Merkle Proof**라고 알려진)을 제공해야 합니다.
+
+따라서 Allow List 가드는 **route 명령어를 사용하여 주어진 지갑의 Merkle Proof를 확인**하고, 성공하면 민팅 명령어에 대한 검증 증명 역할을 하는 블록체인에 작은 PDA 계정을 생성합니다.
+
+{% diagram %}
+
+{% node %}
+{% node #candy-machine-1 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% /node %}
+
+{% node parent="candy-machine-1" y=80 x=20 %}
+{% node #candy-guard-1 label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node label="가드" theme="mint" z=1 /%}
+{% node #allow-list-guard label="Allow List" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine-1" x=550 %}
+{% node #mint-1 label="민팅" theme="pink" /%}
+{% node label="Candy Guard Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-1" x=45 y=-20 label="접근 제어" theme="transparent" /%}
+
+{% node parent="mint-1" x=-22 y=100 %}
+{% node #mint-2 label="민팅" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-2" x=120 y=-20 label="민팅 로직" theme="transparent" /%}
+
+{% node #nft parent="mint-2" x=62 y=100 label="NFT" /%}
+
+{% node parent="mint-2" x=-250 %}
+{% node #route label="Route" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="route" x=70 y=-20 label="Merkle Proof 검증" theme="transparent" /%}
+
+{% node #allow-list-pda parent="route" x=23 y=100 label="Allow List PDA" /%}
+
+{% edge from="candy-guard-1" to="candy-machine-1" fromPosition="left" toPosition="left" arrow=false /%}
+{% edge from="mint-1" to="mint-2" theme="pink" path="straight" /%}
+{% edge from="mint-2" to="nft" theme="pink" path="straight" /%}
+{% edge from="candy-machine-1" to="mint-1" theme="pink" /%}
+{% edge from="allow-list-guard" to="route" theme="pink" /%}
+{% edge from="route" to="allow-list-pda" theme="pink" path="straight" /%}
+{% edge from="allow-list-pda" to="mint-1" theme="pink" /%}
+
+{% /diagram %}
+
+그렇다면 왜 민팅 명령어 내에서 직접 Merkle Proof를 검증하지 않을까요? 단순히 큰 허용 목록의 경우 Merkle Proof가 상당히 길어질 수 있기 때문입니다. 특정 크기 이후에는 이미 상당한 양의 명령어를 포함하는 민팅 트랜잭션에 포함하는 것이 불가능해집니다. 검증 프로세스를 민팅 프로세스에서 분리함으로써 허용 목록을 필요한 만큼 크게 만들 수 있게 됩니다.
+
+{% dialect-switcher title="가드의 route 명령어 호출" %}
+{% dialect title="JavaScript" id="js" %}
+
+Umi 라이브러리를 사용하여 가드의 route 명령어를 호출하려면 `route` 함수를 사용할 수 있습니다. `guard` 속성을 통해 가드의 이름을 전달하고 `routeArgs` 속성을 통해 route 설정을 전달해야 합니다.
+
+다음은 민팅 전에 지갑의 Merkle Proof를 검증하는 Allow List 가드를 사용한 예시입니다.
+
+```ts
+import {
+  create,
+  route,
+  getMerkleProof,
+  getMerkleRoot,
+} from '@metaplex-foundation/mpl-candy-machine'
+
+// 허용 목록을 준비합니다.
+// 목록의 첫 번째 지갑이 Metaplex identity라고 가정해봅시다.
+const allowList = [
+  'GjwcWFQYzemBtpUoN5fMAP2FZviTtMRWCmrppGuTthJS',
+  '2vjCrmEFiN9CLLhiqy8u1JPh48av8Zpzp3kNkdTtirYG',
+  'AT8nPwujHAD14cLojTcB1qdBzA1VXnT6LVGuUd6Y73Cy',
+]
+const merkleRoot = getMerkleRoot(allowList)
+
+// Allow List 가드와 함께 Candy Machine을 생성합니다.
+await create(umi, {
+  // ...
+  guards: {
+    allowList: some({ merkleRoot }),
+  },
+}).sendAndConfirm(umi)
+
+// 지금 민팅을 시도하면 Merkle Proof를 검증하지 않았기 때문에 실패합니다.
+
+// route 명령어를 사용하여 Merkle Proof를 검증합니다.
+await route(umi, {
+  candyMachine: candyMachine.publicKey,
+  guard: 'allowList',
+  routeArgs: {
+    path: 'proof',
+    merkleRoot,
+    merkleProof: getMerkleProof(
+      allowList,
+      'GjwcWFQYzemBtpUoN5fMAP2FZviTtMRWCmrppGuTthJS'
+    ),
+  },
+}).sendAndConfirm(umi)
+
+// 이제 민팅을 시도하면 성공합니다.
+```
+
+API 참조: [route](https://mpl-candy-machine.typedoc.metaplex.com/functions/route.html), [DefaultGuardSetRouteArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/DefaultGuardSetRouteArgs.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 그룹과 함께하는 Route 명령어
+
+가드 그룹을 사용하면서 route 명령어를 호출할 때는 선택하려는 가드의 **그룹 레이블을 지정하는 것**이 중요합니다. 이는 서로 다른 그룹에 동일한 타입의 여러 가드가 있을 수 있고 프로그램이 route 명령어에 어떤 것을 사용해야 하는지 알아야 하기 때문입니다.
+
+예를 들어, 한 그룹에는 엄선된 VIP 지갑의 **Allow List**가 있고 다른 그룹에는 추첨 당첨자를 위한 또 다른 **Allow List**가 있다고 해봅시다. 그러면 Allow List 가드에 대한 Merkle Proof를 검증하고 싶다고 말하는 것만으로는 충분하지 않으며, 어느 그룹에 대해 검증을 수행해야 하는지도 알아야 합니다.
+
+{% dialect-switcher title="route 명령어 호출 시 그룹으로 필터링" %}
+{% dialect title="JavaScript" id="js" %}
+
+그룹을 사용할 때 Umi 라이브러리의 `route` 함수는 선택하려는 그룹의 레이블로 설정되어야 하는 `Option<string>` 타입의 추가 `group` 속성을 받습니다.
+
+```ts
+import {
+  create,
+  route,
+  getMerkleProof,
+  getMerkleRoot,
+} from "@metaplex-foundation/mpl-candy-machine";
+import { base58PublicKey, some } from "@metaplex-foundation/umi";
+
+// 허용 목록들을 준비합니다.
+const allowListA = [...];
+const allowListB = [...];
+
+// 두 개의 Allow List 가드와 함께 Candy Machine을 생성합니다.
+await create(umi, {
+  // ...
+  groups: [
+    {
+      label: "listA",
+      guards: {
+        allowList: some({ merkleRoot: getMerkleRoot(allowListA) }),
+      },
+    },
+    {
+      label: "listB",
+      guards: {
+        allowList: some({ merkleRoot: getMerkleRoot(allowListB) }),
+      },
+    },
+  ],
+}).sendAndConfirm(umi);
+
+// 선택할 그룹을 지정하여 Merkle Proof를 검증합니다.
+await route(umi, {
+  candyMachine: candyMachine.publicKey,
+  guard: 'allowList',
+  group: some('listA'), // <- "allowListA"를 사용하여 검증합니다.
+  routeArgs: {
+    path: 'proof',
+    merkleRoot: getMerkleRoot(allowListA),
+    merkleProof: getMerkleProof(
+      allowListA,
+      base58PublicKey(umi.identity),
+    ),
+  },
+}).sendAndConfirm(umi);
+```
+
+API 참조: [route](https://mpl-candy-machine.typedoc.metaplex.com/functions/route.html), [DefaultGuardSetRouteArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/DefaultGuardSetRouteArgs.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 결론
+
+route 명령어는 가드가 고유한 맞춤 프로그램 로직과 함께 제공될 수 있게 하여 가드를 더욱 강력하게 만듭니다. 각 가드의 전체 기능 세트를 보려면 [사용 가능한 모든 가드](/kr/candy-machine/guards)의 전용 페이지를 확인하세요.
+
+이제 Candy Machine과 가드 설정에 대해 알아야 할 모든 것을 알았으니 민팅에 대해 이야기할 때입니다. [다음 페이지](/kr/candy-machine/mint)에서 만나요!

src/pages/kr/candy-machine/guards.md

@@ -0,0 +1,391 @@
+---
+title: Candy 가드
+metaTitle: Candy 가드 | Candy Machine
+description: 가드가 어떻게 작동하고 어떻게 활성화하는지 설명합니다.
+---
+
+이제 Candy Machine이 어떻게 작동하고 어떻게 로드하는지 알았으니, 퍼즐의 마지막 조각인 가드에 대해 이야기해보겠습니다. {% .lead %}
+
+## 가드란 무엇인가요?
+
+가드는 Candy Machine의 민팅에 대한 접근을 제한하고 새로운 기능을 추가할 수도 있는 모듈식 코드 조각입니다!
+
+선택할 수 있는 다양한 가드가 있으며, 각각 원하는 대로 활성화하고 구성할 수 있습니다.
+
+이 문서의 뒷부분에서 사용 가능한 모든 가드를 다룰 예정이지만, 여기서는 몇 가지 예시를 통해 설명해보겠습니다.
+
+- **시작 날짜** 가드가 활성화되면 사전 구성된 날짜 이전에는 민팅이 금지됩니다. 주어진 날짜 이후의 민팅을 금지하는 **종료 날짜** 가드도 있습니다.
+- **SOL 결제** 가드가 활성화되면 민팅 지갑은 구성된 금액을 구성된 대상 지갑에 지불해야 합니다. 특정 컬렉션의 토큰이나 NFT로 결제하는 유사한 가드들이 존재합니다.
+- **토큰 게이트**와 **NFT 게이트** 가드는 각각 특정 토큰 보유자와 NFT 보유자로 민팅을 제한합니다.
+- **허용 목록** 가드는 지갑이 미리 정의된 지갑 목록의 일부인 경우에만 민팅을 허용합니다. 민팅을 위한 게스트 리스트와 같습니다.
+
+보시다시피, 각 가드는 하나의 책임만을 담당하며, 이는 가드들을 조합 가능하게 만듭니다. 다시 말해, 완벽한 Candy Machine을 만들기 위해 필요한 가드들을 선택하고 조합할 수 있습니다.
+
+## Candy Guard 계정
+
+[Candy Machine 계정](/kr/candy-machine/manage#candy-machine-account)의 내용을 기억해보시면, 그곳에서는 가드의 흔적을 찾을 수 없습니다. 이는 가드들이 **Candy Guard 프로그램**에 의해 생성되는 **Candy Guard 계정**이라는 별도의 계정에 저장되기 때문입니다.
+
+각 Candy Machine 계정은 일반적으로 자체 Candy Guard 계정과 연결되어야 하며, 이는 추가적인 보호 계층을 제공합니다.
+
+이는 Candy Guard 계정을 생성하고 이를 Candy Machine 계정의 **민트 권한**으로 만드는 방식으로 작동합니다. 이렇게 함으로써 더 이상 메인 Candy Machine 프로그램(**Candy Machine Core 프로그램**이라고 알려진)에서 직접 민팅하는 것이 불가능해집니다. 대신, 모든 가드가 성공적으로 해결되면 Candy Machine Core 프로그램에 위임하여 민팅 프로세스를 완료하는 Candy Guard 프로그램을 통해 민팅해야 합니다.
+
+{% diagram %}
+
+{% node %}
+{% node #candy-machine-1 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% node label="기능" /%}
+{% node label="권한" /%}
+{% node #mint-authority-1 %}
+
+민트 권한 = Candy Guard {% .font-semibold %}
+
+{% /node %}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine-1" y=160 x=20 %}
+{% node #candy-guard-1 label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node label="가드" theme="mint" z=1 /%}
+{% node label="SOL 결제" /%}
+{% node label="토큰 결제" /%}
+{% node label="시작 날짜" /%}
+{% node label="종료 날짜" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine-1" x=350 %}
+{% node #mint-1 label="민팅" theme="pink" /%}
+{% node label="Candy Guard Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-1" x=45 y=-20 label="접근 제어" theme="transparent" /%}
+{% node parent="mint-1" x=-120 y=-35 theme="transparent" %}
+활성화된 가드들을 \
+준수하는 한 누구나 \
+민팅할 수 있습니다.
+{% /node %}
+
+{% node parent="mint-1" x=-22 y=100 %}
+{% node #mint-2 label="민팅" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-2" x=120 y=-20 label="민팅 로직" theme="transparent" /%}
+{% node parent="mint-2" x=200 y=-18 theme="transparent" %}
+Alice만 \
+민팅할 수 \
+있습니다.
+{% /node %}
+
+{% node #nft parent="mint-2" x=62 y=100 label="NFT" /%}
+
+{% node parent="mint-2" x=280 %}
+{% node #candy-machine-2 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% node label="기능" /%}
+{% node label="권한" /%}
+{% node #mint-authority-2 %}
+
+민트 권한 = Alice {% .font-semibold %}
+
+{% /node %}
+{% node label="..." /%}
+{% /node %}
+
+{% edge from="candy-guard-1" to="mint-authority-1" fromPosition="left" toPosition="left" arrow=false dashed=true /%}
+{% edge from="mint-1" to="mint-2" theme="pink" path="straight" /%}
+{% edge from="mint-2" to="nft" theme="pink" path="straight" /%}
+{% edge from="candy-machine-1" to="mint-1" theme="pink" /%}
+{% edge from="candy-guard-1" to="mint-1" theme="pink" /%}
+{% edge from="candy-machine-2" to="mint-2" theme="pink" path="straight" /%}
+
+{% /diagram %}
+
+Candy Machine과 Candy Guard 계정이 함께 작동하므로, 저희 SDK들은 이들을 하나의 엔티티로 취급합니다. SDK로 Candy Machine을 생성하면 연결된 Candy Guard 계정도 기본적으로 함께 생성됩니다. Candy Machine을 업데이트할 때도 마찬가지로 동시에 가드를 업데이트할 수 있습니다. 이 페이지에서 구체적인 예시들을 보겠습니다.
+
+## 왜 별도의 프로그램인가요?
+
+가드들이 메인 Candy Machine 프로그램에 포함되지 않은 이유는 접근 제어 로직을 NFT를 민팅하는 것이 주 책임인 메인 Candy Machine 책임과 분리하기 위함입니다.
+
+이는 가드들을 모듈식으로 만들 뿐만 아니라 확장 가능하게 만듭니다. 누구나 커스텀 가드를 생성하기 위해 자신만의 Candy Guard 프로그램을 만들고 배포할 수 있으며, 나머지 모든 것은 Candy Machine Core 프로그램에 의존할 수 있습니다.
+
+{% diagram %}
+
+{% node %}
+{% node #candy-machine-1 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% /node %}
+
+{% node parent="candy-machine-1" y=80 x=20 %}
+{% node #candy-guard-1 label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node label="가드" theme="mint" z=1 /%}
+{% node label="SOL 결제" /%}
+{% node label="토큰 결제" /%}
+{% node label="시작 날짜" /%}
+{% node label="종료 날짜" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine-1" x=300 %}
+{% node #mint-1 label="민팅" theme="pink" /%}
+{% node label="Candy Guard Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-1" x=160 %}
+{% node #mint-1b label="민팅" theme="pink" /%}
+{% node label="커스텀 Candy Guard Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-1b" x=-80 y=-22 label="다른 접근 제어" theme="transparent" /%}
+
+{% node parent="mint-1" x=60 y=100 %}
+{% node #mint-2 label="민팅" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-2" x=95 y=-20 label="동일한 민팅 로직" theme="transparent" /%}
+
+{% node #nft parent="mint-2" x=62 y=100 label="NFT" /%}
+
+{% node parent="mint-1b" x=250 %}
+{% node #candy-machine-2 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% /node %}
+
+{% node parent="candy-machine-2" y=80 x=0 %}
+{% node #candy-guard-2 label="Candy Guard" theme="blue" /%}
+{% node label="소유자: 커스텀 Candy Guard Program" theme="dimmed" /%}
+{% node label="가드" theme="mint" z=1 /%}
+{% node label="SOL 결제" /%}
+{% node label="토큰 결제" /%}
+{% node label="시작 날짜" /%}
+{% node %}
+나의 커스텀 가드 {% .font-semibold %}
+{% /node %}
+{% node label="..." /%}
+{% /node %}
+
+{% edge from="candy-guard-1" to="candy-machine-1" fromPosition="left" toPosition="left" arrow=false /%}
+{% edge from="candy-guard-2" to="candy-machine-2" fromPosition="right" toPosition="right" arrow=false /%}
+{% edge from="mint-1" to="mint-2" theme="pink" fromPosition="bottom" toPosition="top" /%}
+{% edge from="mint-1b" to="mint-2" theme="pink" fromPosition="bottom" toPosition="top" /%}
+{% edge from="mint-2" to="nft" theme="pink" path="straight" /%}
+{% edge from="candy-machine-1" to="mint-1" theme="pink" /%}
+{% edge from="candy-guard-1" to="mint-1" theme="pink" /%}
+{% edge from="candy-machine-2" to="mint-1b" theme="pink" /%}
+{% edge from="candy-guard-2" to="mint-1b" theme="pink" /%}
+
+{% /diagram %}
+
+저희 SDK들은 또한 자신만의 Candy Guard 프로그램과 커스텀 가드들을 등록할 수 있는 방법을 제공하므로 친숙한 API를 활용하고 가드들을 다른 사람들과 쉽게 공유할 수 있습니다.
+
+## 사용 가능한 모든 가드
+
+이제 가드가 무엇인지 이해했으니, 저희가 사용할 수 있는 기본 가드들이 무엇인지 살펴보겠습니다.
+
+다음 목록에서는 각 가드에 대한 간단한 설명과 더 자세한 내용을 위한 전용 페이지 링크를 제공합니다.
+
+- [**Address Gate**](/kr/candy-machine/guards/address-gate): 민팅을 단일 주소로 제한합니다.
+- [**Allow List**](/kr/candy-machine/guards/allow-list): 지갑 주소 목록을 사용하여 누가 민팅할 수 있는지 결정합니다.
+- [**Bot Tax**](/kr/candy-machine/guards/bot-tax): 유효하지 않은 트랜잭션에 대해 부과할 구성 가능한 세금입니다.
+- [**End Date**](/kr/candy-machine/guards/end-date): 민팅을 종료할 날짜를 결정합니다.
+- [**Freeze Sol Payment**](/kr/candy-machine/guards/freeze-sol-payment): 동결 기간과 함께 민팅 가격을 SOL로 설정합니다.
+- [**Freeze Token Payment**](/kr/candy-machine/guards/freeze-token-payment): 동결 기간과 함께 민팅 가격을 토큰 양으로 설정합니다.
+- [**Gatekeeper**](/kr/candy-machine/guards/gatekeeper): Gatekeeper Network를 통해 민팅을 제한합니다 (예: Captcha 통합).
+- [**Mint Limit**](/kr/candy-machine/guards/mint-limit): 지갑당 민팅 수 제한을 지정합니다.
+- [**Nft Burn**](/kr/candy-machine/guards/nft-burn): 지정된 컬렉션의 보유자로 민팅을 제한하며, NFT 소각을 요구합니다.
+- [**Nft Gate**](/kr/candy-machine/guards/nft-gate): 지정된 컬렉션의 보유자로 민팅을 제한합니다.
+- [**Nft Payment**](/kr/candy-machine/guards/nft-payment): 민팅 가격을 지정된 컬렉션의 NFT로 설정합니다.
+- [**Redeemed Amount**](/kr/candy-machine/guards/redeemed-amount): 민팅된 총량을 기준으로 민팅 종료를 결정합니다.
+- [**Sol Payment**](/kr/candy-machine/guards/sol-payment): 민팅 가격을 SOL로 설정합니다.
+- [**Start Date**](/kr/candy-machine/guards/start-date): 민팅 시작 날짜를 결정합니다.
+- [**Third Party Signer**](/kr/candy-machine/guards/third-party-signer): 트랜잭션에 추가 서명자를 요구합니다.
+- [**Token Burn**](/kr/candy-machine/guards/token-burn): 지정된 토큰의 보유자로 민팅을 제한하며, 토큰 소각을 요구합니다.
+- [**Token Gate**](/kr/candy-machine/guards/token-gate): 지정된 토큰의 보유자로 민팅을 제한합니다.
+- [**Token Payment**](/kr/candy-machine/guards/token-payment): 민팅 가격을 토큰 양으로 설정합니다.
+
+## 가드와 함께 Candy Machine 생성하기
+
+지금까지 우리가 생성한 Candy Machine에는 활성화된 가드가 없었습니다. 이제 사용 가능한 모든 가드를 알았으니, 일부 가드가 활성화된 새로운 Candy Machine을 설정하는 방법을 살펴보겠습니다.
+
+구체적인 구현은 사용하는 SDK에 따라 달라지지만(아래 참조), 주요 아이디어는 필요한 설정을 제공하여 가드를 활성화한다는 것입니다. 설정되지 않은 가드는 비활성화됩니다.
+
+{% dialect-switcher title="가드와 함께 Candy Machine 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+Umi 라이브러리를 사용하여 가드를 활성화하려면, `create` 함수에 `guards` 속성을 제공하고 활성화하려는 모든 가드의 설정을 전달하기만 하면 됩니다. `none()`으로 설정되거나 제공되지 않은 가드는 비활성화됩니다.
+
+```ts
+import { some, sol, dateTime } from '@metaplex-foundation/umi'
+
+await create(umi, {
+  // ...
+  guards: {
+    botTax: some({ lamports: sol(0.01), lastInstruction: true }),
+    solPayment: some({ lamports: sol(1.5), destination: treasury }),
+    startDate: some({ date: dateTime('2023-04-04T16:00:00Z') }),
+    // 다른 모든 가드는 비활성화됩니다...
+  },
+}).sendAndConfirm(umi)
+```
+
+API 참조: [create](https://mpl-candy-machine.typedoc.metaplex.com/functions/create.html), [DefaultGuardSetArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/DefaultGuardSetArgs.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 가드 업데이트
+
+가드에서 뭔가 잘못 설정하셨나요? 민팅 가격에 대해 마음이 바뀌셨나요? 민팅 시작을 조금 연기해야 하나요? 걱정하지 마세요. 가드는 생성할 때 사용한 것과 동일한 설정으로 쉽게 업데이트할 수 있습니다.
+
+설정을 제공하여 새로운 가드를 활성화하거나 빈 설정을 제공하여 현재 가드를 비활성화할 수 있습니다.
+
+{% dialect-switcher title="가드 업데이트" %}
+{% dialect title="JavaScript" id="js" %}
+
+Candy Machine의 가드를 생성할 때와 같은 방식으로 업데이트할 수 있습니다. 즉, `updateCandyGuard` 함수의 `guards` 객체 내에 설정을 제공하면 됩니다. `none()`으로 설정되거나 제공되지 않은 가드는 비활성화됩니다.
+
+전체 `guards` 객체가 업데이트되므로 **기존의 모든 가드를 덮어씁니다!**
+
+따라서 설정이 변경되지 않더라도 활성화하려는 모든 가드의 설정을 제공해야 합니다. 현재 가드로 폴백하기 위해 먼저 candy guard 계정을 가져올 수 있습니다.
+
+```tsx
+import { some, none, sol } from '@metaplex-foundation/umi'
+
+const candyGuard = fetchCandyGuard(umi, candyMachine.mintAuthority)
+await updateCandyGuard(umi, {
+  candyGuard: candyGuard.publicKey,
+  guards: {
+    ...candyGuard.guards,
+    botTax: none(),
+    solPayment: some({ lamports: sol(3), destination: treasury }),
+  },
+})
+```
+
+API 참조: [updateCandyGuard](https://mpl-candy-machine.typedoc.metaplex.com/functions/updateCandyGuard.html), [CandyGuard](https://mpl-candy-machine.typedoc.metaplex.com/types/CandyGuard.html), [DefaultGuardSetArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/DefaultGuardSetArgs.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## Candy Machine의 가드 보기
+
+Candy Machine에 가드를 설정하면, 제공된 모든 설정을 Candy Guard 계정에서 누구나 검색하고 볼 수 있습니다.
+
+{% dialect-switcher title="가드 가져오기" %}
+{% dialect title="JavaScript" id="js" %}
+
+candy machine의 `mintAuthority` 속성에서 `fetchCandyGuard` 함수를 사용하여 candy machine과 연결된 candy guard에 접근할 수 있습니다.
+
+```ts
+import {
+  fetchCandyMachine,
+  fetchCandyGuard,
+} from '@metaplex-foundation/mpl-candy-machine'
+
+const candyMachine = await fetchCandyMachine(umi, candyMachineAddress)
+const candyGuard = await fetchCandyGuard(umi, candyMachine.mintAuthority)
+
+candyGuard.guards // 모든 가드 설정
+candyGuard.guards.botTax // Bot Tax 설정
+candyGuard.guards.solPayment // Sol Payment 설정
+// ...
+```
+
+`create` 함수를 사용할 때 각 candy machine에 대해 연결된 candy guard 계정이 자동으로 생성되어 주소가 결정적임을 참고하세요. 따라서 이 경우 다음과 같이 하나의 RPC 호출만 사용하여 두 계정을 모두 가져올 수 있습니다.
+
+```ts
+import { assertAccountExists } from '@metaplex-foundation/umi'
+import {
+  findCandyGuardPda,
+  deserializeCandyMachine,
+  deserializeCandyGuard,
+} from '@metaplex-foundation/mpl-candy-machine'
+
+const candyGuardAddress = findCandyGuardPda(umi, { base: candyMachineAddress })
+const [rawCandyMachine, rawCandyGuard] = await umi.rpc.getAccounts([
+  candyMachineAddress,
+  candyGuardAddress,
+])
+assertAccountExists(rawCandyMachine)
+assertAccountExists(rawCandyGuard)
+
+const candyMachine = deserializeCandyMachine(umi, rawCandyMachine)
+const candyGuard = deserializeCandyGuard(umi, rawCandyGuard)
+```
+
+API 참조: [fetchCandyGuard](https://mpl-candy-machine.typedoc.metaplex.com/functions/fetchCandyGuard.html), [findCandyGuardPda](https://mpl-candy-machine.typedoc.metaplex.com/functions/findCandyGuardPda.html), [CandyGuard](https://mpl-candy-machine.typedoc.metaplex.com/types/CandyGuard.html), [DefaultGuardSetArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/DefaultGuardSetArgs.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 수동으로 Candy Guard 계정 래핑 및 언래핑
+
+지금까지 우리는 대부분의 프로젝트에 가장 적합하기 때문에 Candy Machine과 Candy Guard 계정을 함께 관리했습니다.
+
+하지만 Candy Machine과 Candy Guard는 SDK를 사용하더라도 다른 단계에서 생성하고 연결할 수 있다는 점을 유의하는 것이 중요합니다.
+
+먼저 두 계정을 별도로 생성하고 수동으로 연결/분리해야 합니다.
+
+{% dialect-switcher title="Candy Machine에서 가드 연결 및 분리" %}
+{% dialect title="JavaScript" id="js" %}
+
+Umi 라이브러리의 `create` 함수는 이미 생성된 모든 Candy Machine 계정에 대해 새로운 Candy Guard 계정을 생성하고 연결하는 작업을 처리합니다.
+
+하지만 별도로 생성하고 수동으로 연결/분리하고 싶다면 다음과 같이 할 수 있습니다.
+
+```ts
+import { some, percentAmount, sol, dateTime } from '@metaplex-foundation/umi'
+
+// Candy Guard 없이 Candy Machine 생성
+const candyMachine = generateSigner(umi)
+await (await createCandyMachineV2(umi, {
+  candyMachine,
+  tokenStandard: TokenStandard.NonFungible,
+  collectionMint: collectionMint.publicKey,
+  collectionUpdateAuthority: umi.identity,
+  itemsAvailable: 100,
+  sellerFeeBasisPoints: percentAmount(1.23),
+  creators: [
+    { address: umi.identity.publicKey, verified: false, percentageShare: 100 },
+  ],
+  configLineSettings: some({
+    prefixName: 'My NFT #',
+    nameLength: 3,
+    prefixUri: 'https://example.com/',
+    uriLength: 20,
+    isSequential: false,
+  }),
+})).sendAndConfirm(umi)
+
+// Candy Guard 생성
+const base = generateSigner(umi)
+const candyGuard = findCandyGuardPda(umi, { base: base.publicKey })
+await createCandyGuard(umi, {
+  base,
+  guards: {
+    botTax: { lamports: sol(0.01), lastInstruction: false },
+    solPayment: { lamports: sol(1.5), destination: treasury },
+    startDate: { date: dateTime('2022-10-17T16:00:00Z') },
+  },
+}).sendAndConfirm(umi)
+
+// Candy Guard를 Candy Machine과 연결
+await wrap(umi, {
+  candyMachine: candyMachine.publicKey,
+  candyGuard,
+}).sendAndConfirm(umi)
+
+// 연결 해제
+await unwrap(umi, {
+  candyMachine: candyMachine.publicKey,
+  candyGuard,
+}).sendAndConfirm(umi)
+```
+
+API 참조: [createCandyMachineV2](https://mpl-candy-machine.typedoc.metaplex.com/functions/createCandyMachineV2.html), [createCandyGuard](https://mpl-candy-machine.typedoc.metaplex.com/functions/createCandyGuard.html), [wrap](https://mpl-candy-machine.typedoc.metaplex.com/functions/wrap.html), [unwrap](https://mpl-candy-machine.typedoc.metaplex.com/functions/unwrap.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 결론
+
+가드는 Candy Machine의 중요한 구성 요소입니다. 가드는 민팅 프로세스를 쉽게 구성할 수 있게 하며, 애플리케이션 특정 요구에 따라 누구나 자신만의 가드를 만들 수 있게 해줍니다. [다음 페이지](/kr/candy-machine/guard-groups)에서는 가드 그룹을 사용하여 훨씬 더 많은 민팅 시나리오를 만드는 방법을 살펴보겠습니다!

src/pages/kr/candy-machine/guards/allow-list.md

@@ -0,0 +1,384 @@
+---
+title: Allow List 가드
+metaTitle: Allow List | Candy Machine
+description: "지갑 주소 목록을 사용하여 누가 민팅할 수 있는지 결정합니다."
+---
+
+## 개요
+
+**Allow List** 가드는 민팅 지갑을 미리 정의된 지갑 목록과 대조하여 검증합니다. 민팅 지갑이 이 목록에 포함되지 않으면 민팅이 실패합니다.
+
+이 가드의 설정에 큰 지갑 목록을 제공하는 것은 블록체인에 많은 저장 공간이 필요하고 모든 것을 삽입하는 데 하나 이상의 트랜잭션이 필요할 것입니다. 따라서 Allow List 가드는 [**Merkle Trees**](https://en.m.wikipedia.org/wiki/Merkle_tree)를 사용하여 민팅 지갑이 미리 구성된 지갑 목록의 일부임을 확인합니다.
+
+이는 모든 잎이 두 개씩 자기 자신을 해시하여 **Merkle Root**라고 알려진 최종 해시에 도달할 때까지의 해시 이진 트리를 생성하는 방식으로 작동합니다. 즉, 어떤 잎이라도 변경되면 최종 Merkle Root가 손상됩니다.
+
+{% diagram %}
+{% node #hash-7 label="Hash 7" theme="brown" /%}
+{% node #merkle-root label="Merkle Root" theme="transparent" parent="hash-7" x="-90" y="8" /%}
+{% node #hash-5 label="Hash 5" parent="hash-7" y="100" x="-200" theme="orange" /%}
+{% node #hash-6 label="Hash 6" parent="hash-7" y="100" x="200" theme="orange" /%}
+
+{% node #leaves label="잎" parent="hash-5" y="105" x="-170" theme="transparent" /%}
+{% node #hash-1 label="Hash 1" parent="hash-5" y="100" x="-100" theme="orange" /%}
+{% node #hash-2 label="Hash 2" parent="hash-5" y="100" x="100" theme="orange" /%}
+{% node #hash-3 label="Hash 3" parent="hash-6" y="100" x="-100" theme="orange" /%}
+{% node #hash-4 label="Hash 4" parent="hash-6" y="100" x="100" theme="orange" /%}
+
+{% node #data label="데이터" parent="hash-1" y="105" x="-80" theme="transparent" /%}
+{% node #Ur1C label="Ur1C...bWSG" parent="hash-1" y="100" x="-23" /%}
+{% node #sXCd label="sXCd...edkn" parent="hash-2" y="100" x="-20" /%}
+{% node #RbJs label="RbJs...Ek7u" parent="hash-3" y="100" x="-17" /%}
+{% node #rwAv label="rwAv...u1ud" parent="hash-4" y="100" x="-16" /%}
+
+{% edge from="hash-5" to="hash-7" fromPosition="top" toPosition="bottom" /%}
+{% edge from="hash-6" to="hash-7" fromPosition="top" toPosition="bottom" /%}
+
+{% edge from="hash-1" to="hash-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="hash-2" to="hash-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="hash-3" to="hash-6" fromPosition="top" toPosition="bottom" /%}
+{% edge from="hash-4" to="hash-6" fromPosition="top" toPosition="bottom" /%}
+
+{% edge from="Ur1C" to="hash-1" fromPosition="top" toPosition="bottom" path="straight" /%}
+{% edge from="sXCd" to="hash-2" fromPosition="top" toPosition="bottom" path="straight" /%}
+{% edge from="RbJs" to="hash-3" fromPosition="top" toPosition="bottom" path="straight" /%}
+{% edge from="rwAv" to="hash-4" fromPosition="top" toPosition="bottom" path="straight" /%}
+
+{% /diagram %}
+
+잎이 트리의 일부임을 확인하기 위해서는 트리를 올라가서 Merkle Root를 다시 계산할 수 있게 해주는 모든 중간 해시의 목록만 있으면 됩니다. 이 중간 해시 목록을 **Merkle Proof**라고 부릅니다. 계산된 Merkle Root가 저장된 Merkle Root와 일치하면, 잎이 트리의 일부이며 따라서 원래 목록의 일부임을 확신할 수 있습니다.
+
+{% diagram %}
+{% node #hash-7 label="Hash 7" theme="brown" /%}
+{% node #merkle-root label="Merkle Root" theme="transparent" parent="hash-7" x="-90" y="8" /%}
+{% node #hash-5 label="Hash 5" parent="hash-7" y="100" x="-200" theme="mint" /%}
+{% node #hash-6 label="Hash 6" parent="hash-7" y="100" x="200" theme="blue" /%}
+
+{% node #legend-merkle-proof label="Merkle Proof =" theme="transparent" parent="hash-7" x="200" y="10" /%}
+{% node #legend-hash-4 label="Hash 4" parent="legend-merkle-proof" x="100" y="-7" theme="mint" /%}
+{% node #plus label="+" parent="legend-hash-4" theme="transparent" x="81" y="8" /%}
+{% node #legend-hash-5 label="Hash 5" parent="legend-hash-4" x="100" theme="mint" /%}
+
+
+{% node #leaves label="잎" parent="hash-5" y="105" x="-170" theme="transparent" /%}
+{% node #hash-1 label="Hash 1" parent="hash-5" y="100" x="-100" theme="orange" /%}
+{% node #hash-2 label="Hash 2" parent="hash-5" y="100" x="100" theme="orange" /%}
+{% node #hash-3 label="Hash 3" parent="hash-6" y="100" x="-100" theme="blue" /%}
+{% node #hash-4 label="Hash 4" parent="hash-6" y="100" x="100" theme="mint" /%}
+
+{% node #data label="데이터" parent="hash-1" y="105" x="-80" theme="transparent" /%}
+{% node #Ur1C label="Ur1C...bWSG" parent="hash-1" y="100" x="-23" /%}
+{% node #sXCd label="sXCd...edkn" parent="hash-2" y="100" x="-20" /%}
+{% node #RbJs label="RbJs...Ek7u" parent="hash-3" y="100" x="-17" theme="blue" /%}
+{% node #rwAv label="rwAv...u1ud" parent="hash-4" y="100" x="-16" /%}
+
+{% edge from="hash-5" to="hash-7" fromPosition="top" toPosition="bottom" theme="mint" /%}
+{% edge from="hash-6" to="hash-7" fromPosition="top" toPosition="bottom" theme="blue" /%}
+
+{% edge from="hash-1" to="hash-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="hash-2" to="hash-5" fromPosition="top" toPosition="bottom" /%}
+{% edge from="hash-3" to="hash-6" fromPosition="top" toPosition="bottom" theme="blue" /%}
+{% edge from="hash-4" to="hash-6" fromPosition="top" toPosition="bottom" theme="mint" /%}
+
+{% edge from="Ur1C" to="hash-1" fromPosition="top" toPosition="bottom" path="straight" /%}
+{% edge from="sXCd" to="hash-2" fromPosition="top" toPosition="bottom" path="straight" /%}
+{% edge from="RbJs" to="hash-3" fromPosition="top" toPosition="bottom" path="straight" theme="blue" /%}
+{% edge from="rwAv" to="hash-4" fromPosition="top" toPosition="bottom" path="straight" /%}
+
+{% /diagram %}
+
+따라서 Allow List 가드의 설정에는 미리 구성된 허용 지갑 목록의 진실의 원천 역할을 하는 Merkle Root가 필요합니다. 지갑이 허용 목록에 있음을 증명하려면 프로그램이 Merkle Root를 다시 계산하고 가드의 설정과 일치하는지 확인할 수 있는 유효한 Merkle Proof를 제공해야 합니다.
+
+저희 SDK는 주어진 지갑 목록에 대해 Merkle Root와 Merkle Proof를 쉽게 생성할 수 있는 도우미를 제공한다는 점을 참고하세요.
+
+{% diagram  %}
+
+{% node %}
+{% node #candy-machine label="Candy Machine" theme="blue" /%}
+{% node theme="dimmed" %}
+소유자: Candy Machine Core Program {% .whitespace-nowrap %}
+{% /node %}
+{% /node %}
+
+{% node parent="candy-machine" y="100" x="20" %}
+{% node #candy-guard label="Candy Guard" theme="blue" /%}
+{% node theme="dimmed" %}
+소유자: Candy Guard Program {% .whitespace-nowrap %}
+{% /node %}
+{% node #candy-guard-guards label="가드" theme="mint" z=1 /%}
+{% node #allowList label="AllowList" /%}
+{% node #guardMerkleRoot label="- Merkle Root" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="allowList" x="250" y="10" %}
+{% node #merkleRoot theme="slate" %}
+Merkle Root {% .whitespace-nowrap %}
+{% /node %}
+{% /node %}
+
+{% node parent="merkleRoot" x="170" %}
+{% node #merkleProof theme="slate" %}
+Merkle Proof {% .whitespace-nowrap %}
+{% /node %}
+{% /node %}
+
+{% node parent="merkleRoot" y="100" x="-12" %}
+{% node #walletList  %}
+민팅이 허용된
+
+지갑 목록
+{%/node %}
+{% /node %}
+{% edge from="merkleProof" to="walletList" arrow="none" fromPosition="bottom" toPosition="top" arrow="start" /%}
+{% edge from="merkleRoot" to="walletList" arrow="none" fromPosition="bottom" toPosition="top" arrow="start" /%}
+
+
+{% node parent="merkleProof" y="100" %}
+{% node #payer label="지불자" theme="indigo" /%}
+{% node theme="dimmed"%}
+소유자: Any Program {% .whitespace-nowrap %}
+{% /node %}
+{% /node %}
+{% edge from="merkleProof" to="payer" arrow="none" fromPosition="bottom" toPosition="top" arrow="start" path="straight" /%}
+
+{% node parent="candy-machine" x="740" %}
+  {% node #route-validation theme="pink" %}
+    Route from the
+
+    _Candy Guard Program_
+  {% /node %}
+{% /node %}
+{% node parent="route-validation" y="-20" x="100" theme="transparent" %}
+  Merkle Proof 검증
+{% /node %}
+
+{% node parent="route-validation" #allowList-pda y="130" x="32" %}
+{% node theme="slate" %}
+Allowlist PDA {% .whitespace-nowrap %}
+{% /node %}
+{% /node %}
+
+{% node parent="allowList-pda" #mint-candy-guard y="90" x="-31" %}
+  {% node theme="pink" %}
+    민팅 from
+
+    _Candy Guard Program_ {% .whitespace-nowrap %}
+  {% /node %}
+{% /node %}
+{% node parent="mint-candy-guard" y="-20" x="100" theme="transparent" %}
+  접근 제어
+{% /node %}
+
+{% node parent="mint-candy-guard" #mint-candy-machine y="110" x="-8" %}
+  {% node theme="pink" %}
+    민팅 from 
+    
+    _Candy Machine Program_ {% .whitespace-nowrap %}
+  {% /node %}
+{% /node %}
+{% node parent="mint-candy-machine" y="-20" x="110" theme="transparent" %}
+  민팅 로직
+{% /node %}
+
+{% node #nft parent="mint-candy-machine" y="110" x="70" theme="blue" %}
+  NFT
+{% /node %}
+{% edge from="mint-candy-machine" to="nft" path="straight" /%}
+
+{% edge from="candy-guard" to="candy-machine" /%}
+{% edge from="guardMerkleRoot" to="merkleRoot" arrow="start" path="straight" /%}
+{% edge from="merkleRoot" to="route-validation" arrow="none" fromPosition="top" dashed=true /%}
+{% edge from="merkleProof" to="route-validation" arrow="none" fromPosition="top" dashed=true  %}
+지불자의 Merkle Proof가 
+
+가드의 Merkle Root와 일치하지 않으면 검증이 실패합니다
+{% /edge %}
+{% edge from="candy-guard-guards" to="guards" /%}
+{% edge from="route-validation" to="allowList-pda" path="straight" /%}
+{% edge from="allowList-pda" to="mint-candy-guard" path="straight" /%}
+{% edge from="mint-candy-guard" to="mint-candy-machine" path="straight" /%}
+
+
+{% /diagram %}
+
+## 가드 설정
+
+Allow List 가드는 다음 설정을 포함합니다:
+
+- **Merkle Root**: 허용 목록을 나타내는 Merkle Tree의 Root입니다.
+
+{% dialect-switcher title="Allow List 가드를 사용하여 Candy Machine 설정" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+Merkle Tree를 관리하는 데 도움이 되도록 Umi 라이브러리는 다음과 같이 사용할 수 있는 `getMerkleRoot`와 `getMerkleProof`라는 두 가지 도우미 메서드를 제공합니다.
+
+```ts
+import {
+  getMerkleProof,
+  getMerkleRoot,
+} from "@metaplex-foundation/mpl-candy-machine";
+
+const allowList = [
+  "Ur1CbWSGsXCdedknRbJsEk7urwAvu1uddmQv51nAnXB",
+  "GjwcWFQYzemBtpUoN5fMAP2FZviTtMRWCmrppGuTthJS",
+  "AT8nPwujHAD14cLojTcB1qdBzA1VXnT6LVGuUd6Y73Cy",
+];
+
+const merkleRoot = getMerkleRoot(allowList);
+const validMerkleProof = getMerkleProof(
+  allowList,
+  "Ur1CbWSGsXCdedknRbJsEk7urwAvu1uddmQv51nAnXB"
+);
+const invalidMerkleProof = getMerkleProof(allowList, "invalid-address");
+```
+
+허용 목록의 Merkle Root를 계산한 후에는 이를 사용하여 Candy Machine에 Allow List 가드를 설정할 수 있습니다.
+
+```ts
+import { getMerkleRoot } from "@metaplex-foundation/mpl-candy-machine";
+
+const allowList = [
+  "Ur1CbWSGsXCdedknRbJsEk7urwAvu1uddmQv51nAnXB",
+  "GjwcWFQYzemBtpUoN5fMAP2FZviTtMRWCmrppGuTthJS",
+  "AT8nPwujHAD14cLojTcB1qdBzA1VXnT6LVGuUd6Y73Cy",
+];
+
+create(umi, {
+  // ...
+  guards: {
+    allowList: some({ merkleRoot: getMerkleRoot(allowList) }),
+  },
+});
+```
+
+API 참조: [create](https://mpl-candy-machine.typedoc.metaplex.com/functions/create.html), [AllowList](https://mpl-candy-machine.typedoc.metaplex.com/types/AllowList.html)
+
+{% /totem %}
+{% /dialect %}
+{% dialect title="Sugar" id="sugar" %}
+{% totem %}
+
+Sugar에는 merkle root를 생성하고 관리하는 함수가 포함되어 있지 않습니다. sugar와 함께 허용 목록을 사용할 때는 앞서 설명한 JavaScript 함수나 [sol-tools](https://sol-tools.tonyboyle.io/cmv3/allow-list) 등을 사용하여 미리 계산한 다음, 다음과 같이 config에 merkle root 해시를 추가해야 합니다:
+
+```json
+"allowList" : {
+    "merkleRoot": "<HASH>"
+}
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 민팅 설정
+
+Allow List 가드는 다음 민팅 설정을 포함합니다:
+
+- **Merkle Root**: 허용 목록을 나타내는 Merkle Tree의 Root입니다.
+
+민팅할 수 있기 전에 **Merkle Proof를 제공하여 민팅 지갑을 검증해야 합니다**. 자세한 내용은 아래의 [Merkle Proof 검증](#validate-a-merkle-proof)을 참조하세요.
+
+또한 SDK의 도움 없이 명령어를 구성할 계획이라면 민팅 명령어의 나머지 계정에 Allow List Proof PDA를 추가해야 합니다. 자세한 내용은 [Candy Guard의 프로그램 문서](https://github.com/metaplex-foundation/mpl-candy-machine/tree/main/programs/candy-guard#allowlist)를 참조하세요.
+
+{% dialect-switcher title="Allow List 가드로 민팅" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+다음과 같이 `mintArgs` 인수를 사용하여 Allow List 가드의 민팅 설정을 전달할 수 있습니다.
+
+```ts
+import { getMerkleRoot } from "@metaplex-foundation/mpl-candy-machine";
+
+const allowList = [
+  "Ur1CbWSGsXCdedknRbJsEk7urwAvu1uddmQv51nAnXB",
+  "GjwcWFQYzemBtpUoN5fMAP2FZviTtMRWCmrppGuTthJS",
+  "AT8nPwujHAD14cLojTcB1qdBzA1VXnT6LVGuUd6Y73Cy",
+];
+
+mintV2(umi, {
+  // ...
+  mintArgs: {
+    allowList: some({ merkleRoot: getMerkleRoot(allowList) }),
+  },
+});
+```
+
+API 참조: [mintV2](https://mpl-candy-machine.typedoc.metaplex.com/functions/mintV2.html), [AllowListMintArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/AllowListMintArgs.html)
+
+{% /totem %}
+{% /dialect %}
+{% dialect title="Sugar" id="sugar" %}
+{% totem %}
+
+_가드가 할당되는 즉시 sugar를 사용하여 민팅할 수 없습니다 - 따라서 특정 민팅 설정이 없습니다._
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## Route 명령어
+
+Allow List route 명령어는 다음 기능을 지원합니다.
+
+### Merkle Proof 검증
+
+_Path: `proof`_
+
+민팅 명령어에 직접 Merkle Proof를 전달하는 대신, 민팅 지갑은 Allow List 가드의 route 명령어를 사용하여 [사전 검증](/kr/candy-machine/mint#minting-with-pre-validation)을 수행해야 합니다.
+
+이 route 명령어는 제공된 Merkle Proof로부터 Merkle Root를 계산하고, 유효한 경우 민팅 지갑이 허용 목록의 일부임을 증명하는 새로운 PDA 계정을 생성합니다. 따라서 민팅할 때 Allow List 가드는 지갑에 대한 민팅을 승인하거나 거부하기 위해 이 PDA 계정의 존재만 확인하면 됩니다.
+
+그렇다면 왜 민팅 명령어 내에서 직접 Merkle Proof를 검증할 수 없을까요? 단순히 큰 허용 목록의 경우 Merkle Proof가 상당히 길어질 수 있기 때문입니다. 특정 크기 이후에는 이미 상당한 양의 명령어를 포함하는 민팅 트랜잭션에 포함하는 것이 불가능해집니다. 검증 프로세스를 민팅 프로세스에서 분리함으로써 허용 목록을 필요한 만큼 크게 만들 수 있게 됩니다.
+
+route 명령어의 이 경로는 다음 인수를 받습니다:
+
+- **Path** = `proof`: route 명령어에서 실행할 경로를 선택합니다.
+- **Merkle Root**: 허용 목록을 나타내는 Merkle Tree의 Root입니다.
+- **Merkle Proof**: Merkle Root를 계산하고 가드 설정에 저장된 Merkle Root와 일치하는지 확인하는 데 사용되어야 하는 중간 해시 목록입니다.
+- **Minter** (선택사항): 지불자와 동일하지 않은 경우 서명자로서의 민터 계정입니다. 제공될 때, 이 계정은 증명이 유효하려면 허용 목록의 일부여야 합니다.
+
+{% dialect-switcher title="지갑 사전 검증" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+다음과 같이 `routeArgs` 인수를 사용하여 Allow List 가드의 "Proof" Route 설정을 전달할 수 있습니다.
+
+```ts
+import {
+  getMerkleProof,
+  getMerkleRoot,
+} from "@metaplex-foundation/mpl-candy-machine";
+import { publicKey } from "@metaplex-foundation/umi";
+
+const allowList = [
+  "Ur1CbWSGsXCdedknRbJsEk7urwAvu1uddmQv51nAnXB",
+  "GjwcWFQYzemBtpUoN5fMAP2FZviTtMRWCmrppGuTthJS",
+  "AT8nPwujHAD14cLojTcB1qdBzA1VXnT6LVGuUd6Y73Cy",
+];
+
+await route(umi, {
+  // ...
+  guard: "allowList",
+  routeArgs: {
+    path: "proof",
+    merkleRoot: getMerkleRoot(allowList),
+    merkleProof: getMerkleProof(allowList, publicKey(umi.identity)),
+  },
+}).sendAndConfirm(umi);
+```
+
+이제 `umi.identity` 지갑이 Candy Machine에서 민팅할 수 있습니다.
+
+API 참조: [route](https://mpl-candy-machine.typedoc.metaplex.com/functions/route.html), [AllowListRouteArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/AllowListRouteArgs.html)
+
+{% /totem %}
+{% /dialect %}
+{% dialect title="Sugar" id="sugar" %}
+{% totem %}
+
+_Sugar는 "Proof" Route를 호출하는 데 사용할 수 없습니다._ 
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/candy-machine/guards/bot-tax.md

@@ -0,0 +1,137 @@
+---
+title: Bot Tax 가드
+metaTitle: Bot Tax 가드 | Candy Machine
+description: "유효하지 않은 트랜잭션에 대해 부과할 구성 가능한 세금입니다."
+---
+
+{% callout type="warning" %}
+일부 지갑(Solflare, Phantom 및 기타 지갑들)은 현재 트랜잭션에 Lighthouse 명령어를 자동으로 삽입합니다. 이로 인해 `lastInstruction`이 `true`로 설정되어 있을 때 Bot Tax 가드가 작동합니다.
+
+지갑 선택은 사용자의 몫이므로 **Solflare나 유사한 지갑으로 민팅하는 것을 막을 수 없습니다**. 사용자가 이러한 지갑을 사용하여 민팅할 것으로 예상된다면, 거짓 양성을 피하기 위해 `lastInstruction`을 `false`로 설정하는 것을 고려하세요.
+
+Bot Tax 가드는 신중하게 사용하세요.
+{% /callout %}
+
+## 개요
+
+**Bot Tax** 가드는 봇이 NFT 민팅을 시도하는 것을 막기 위해 유효하지 않은 트랜잭션에 대한 벌금을 부과합니다. 이 금액은 보통 실제 사용자의 진정한 실수에는 영향을 주지 않으면서 봇에게 피해를 주도록 작게 설정됩니다. 모든 봇 세금은 Candy Machine 계정으로 전송되므로 민팅이 끝나면 Candy Machine 계정을 삭제하여 이 자금에 접근할 수 있습니다.
+
+이 가드는 약간 특별하며 다른 모든 가드의 민팅 동작에 영향을 줍니다. Bot Tax가 활성화되고 다른 가드가 민팅 검증에 실패할 때, **트랜잭션은 성공한 것처럼 가장합니다**. 즉, 프로그램에서 오류가 반환되지 않지만 NFT도 민팅되지 않습니다. 이는 봇에서 Candy Machine 계정으로 자금을 전송하려면 트랜잭션이 성공해야 하기 때문입니다.
+
+또한 Bot Tax 가드는 민팅 명령어가 트랜잭션의 마지막 명령어였는지 확인할 수 있게 해줍니다. 이는 봇이 민팅 후에 악성 명령어를 추가하는 것을 방지하고 세금 지불을 피하기 위해 오류를 반환합니다.
+
+{% diagram  %}
+
+{% node %}
+{% node #candy-machine label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% /node %}
+
+{% node parent="candy-machine" y="100" x="22" %}
+{% node #candy-guard label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node #candy-guard-guards label="가드" theme="mint" z=1 /%}
+{% node #botTax label="botTax" /%}
+{% node #lamports label="- Lamports" /%}
+{% node #lastInstruction label="- Last Instruction" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine" x="700" %}
+  {% node #mint-candy-guard theme="pink" %}
+    민팅 from
+
+    _Candy Guard Program_
+  {% /node %}
+{% /node %}
+{% node parent="mint-candy-guard" y="-20" x="100" theme="transparent" %}
+  접근 제어
+{% /node %}
+
+{% node parent="mint-candy-guard" y="150" x="-8" %}
+  {% node #mint-candy-machine theme="pink" %}
+    민팅 from 
+    
+    _Candy Machine Program_
+  {% /node %}
+{% /node %}
+{% node parent="mint-candy-machine" y="-20" x="110" theme="transparent" %}
+  민팅 로직
+{% /node %}
+
+{% node #nft parent="mint-candy-machine" y="120" x="76" theme="blue" %}
+  NFT
+{% /node %}
+{% edge from="mint-candy-machine" to="nft" path="straight" /%}
+
+{% edge from="candy-guard" to="candy-machine" /%}
+{% edge from="lamports" to="mint-candy-guard" arrow="none" dashed=true /%}
+{% node parent="lamports" y="-30" x="200" theme="transparent" %}
+다른 가드가 검증에 실패하면
+
+이 금액의 SOL을 청구
+{% /node %}
+{% edge from="lastInstruction" to="mint-candy-guard" arrow="none" dashed=true %}
+
+{% /edge %}
+{% node parent="lastInstruction" y="15" x="200" theme="transparent" %}
+민팅 명령어가 트랜잭션의
+
+마지막 명령어가 아니면 민팅이 실패합니다
+{% /node %}
+{% edge from="candy-guard-guards" to="guards" /%}
+{% edge from="mint-candy-guard" to="mint-candy-machine" path="straight" /%}
+
+
+{% /diagram %}
+
+## 가드 설정
+
+Bot Tax 가드는 다음 설정들을 포함합니다:
+
+- **Lamports**: 유효하지 않은 트랜잭션에 대해 청구할 SOL(또는 lamports) 금액입니다. 진정한 실수를 한 실제 사용자에게 영향을 주지 않도록 상당히 작은 금액을 설정하는 것을 권장합니다. 클라이언트 측 검증도 실제 사용자에게 미치는 영향을 줄이는 데 도움이 될 수 있습니다.
+- **Last Instruction**: 민팅 명령어가 트랜잭션의 마지막 명령어가 아닐 때 민팅을 금지하고 봇 세금을 청구할지 여부입니다. 봇으로부터 더 나은 보호를 위해 이를 `true`로 설정하는 것을 권장합니다.
+
+{% dialect-switcher title="Bot Tax 가드를 사용하여 Candy Machine 설정" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+create(umi, {
+  // ...
+  guards: {
+    botTax: some({
+      lamports: sol(0.01),
+      lastInstruction: true,
+    }),
+  },
+});
+```
+
+API 참조: [create](https://mpl-candy-machine.typedoc.metaplex.com/functions/create.html), [BotTax](https://mpl-candy-machine.typedoc.metaplex.com/types/BotTax.html)
+
+{% /totem %}
+{% /dialect %}
+{% dialect title="Sugar" id="sugar" %}
+{% totem %}
+
+config.json 파일의 guard 섹션에 다음 객체를 추가하세요: 
+
+```json
+"botTax" : {
+    "value": SOL value,
+    "lastInstruction": boolean
+}
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 민팅 설정
+
+_Bot Tax 가드는 민팅 설정이 필요하지 않습니다._
+
+## Route 명령어
+
+_Bot Tax 가드는 route 명령어를 지원하지 않습니다._

src/pages/kr/candy-machine/guards/sol-payment.md

@@ -0,0 +1,162 @@
+---
+title: "Sol Payment 가드"
+metaTitle: Sol Payment 가드 | Candy Machine
+description: "Sol Payment 가드는 민팅할 때 지불자에게 SOL 금액을 청구할 수 있게 해줍니다."
+---
+
+## 개요
+
+**Sol Payment** 가드는 민팅할 때 지불자에게 SOL 금액을 청구할 수 있게 해줍니다. SOL 금액과 대상 주소 모두 구성할 수 있습니다.
+
+{% diagram  %}
+
+{% node %}
+{% node #candy-machine label="Candy Machine" theme="blue" /%}
+{% node theme="dimmed" %}
+소유자: Candy Machine Core Program {% .whitespace-nowrap %}
+{% /node %}
+{% /node %}
+
+{% node parent="candy-machine" y="100" x="20" %}
+{% node #candy-guard label="Candy Guard" theme="blue" /%}
+{% node theme="dimmed" %}
+소유자: Candy Guard Program {% .whitespace-nowrap %}
+{% /node %}
+{% node #candy-guard-guards label="가드" theme="mint" z=1/%}
+{% node label="Sol Payment" /%}
+{% node #amount label="- 금액" /%}
+{% node #destination label="- 대상" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="destination" x="270" y="-9" %}
+{% node #payer theme="indigo" %}
+대상 지갑 {% .whitespace-nowrap %}
+{% /node %}
+{% node theme="dimmed" %}
+소유자: System Program {% .whitespace-nowrap %}
+{% /node %}
+{% /node %}
+
+{% node parent="candy-machine" x="600" %}
+  {% node #mint-candy-guard theme="pink" %}
+    민팅 from
+
+    _Candy Guard Program_{% .whitespace-nowrap %}
+  {% /node %}
+{% /node %}
+{% node parent="mint-candy-guard" y="-20" x="100" theme="transparent" %}
+  접근 제어
+{% /node %}
+
+{% node parent="mint-candy-guard" #mint-candy-machine y="150" x="-8" %}
+  {% node theme="pink" %}
+    민팅 from 
+    
+    _Candy Machine Program_{% .whitespace-nowrap %}
+  {% /node %}
+{% /node %}
+{% node parent="mint-candy-machine" y="-20" x="140" theme="transparent" %}
+  민팅 로직
+{% /node %}
+
+{% node #nft parent="mint-candy-machine" y="140" x="72" theme="blue" %}
+  NFT
+{% /node %}
+{% edge from="mint-candy-machine" to="nft" path="straight" /%}
+
+{% edge from="candy-guard" to="candy-machine" path="straight" /%}
+{% edge from="destination" to="payer" arrow="none" dashed=true /%}
+{% edge from="mint-candy-guard" to="payer" %}
+지불자로부터
+
+SOL 전송
+{% /edge %}
+{% edge from="mint-candy-guard" to="mint-candy-machine" /%}
+
+{% /diagram %}
+
+## 가드 설정
+
+Sol Payment 가드는 다음 설정들을 포함합니다:
+
+- **Lamports**: 지불자에게 청구할 SOL(또는 lamports) 금액입니다.
+- **Destination**: 이 가드와 관련된 모든 결제를 받을 지갑의 주소입니다.
+
+{% dialect-switcher title="Sol Payment 가드를 사용하여 Candy Machine 설정" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+이 예시에서는 현재 identity를 대상 지갑으로 사용하고 있음을 참고하세요.
+
+```ts
+create(umi, {
+  // ...
+  guards: {
+    solPayment: some({
+      lamports: sol(1.5),
+      destination: umi.identity.publicKey,
+    }),
+  },
+});
+```
+
+API 참조: [create](https://mpl-candy-machine.typedoc.metaplex.com/functions/create.html), [SolPayment](https://mpl-candy-machine.typedoc.metaplex.com/types/SolPayment.html)
+
+{% /totem %}
+{% /dialect %}
+{% dialect title="Sugar" id="sugar" %}
+{% totem %}
+
+config.json 파일의 guard 섹션에 다음 객체를 추가하세요:
+
+```json
+"solPayment": {
+    "value": 1,
+    "destination": "<PUBKEY>"
+}
+```
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 민팅 설정
+
+Sol Payment 가드는 다음 민팅 설정들을 포함합니다:
+
+- **Destination**: 이 가드와 관련된 모든 결제를 받을 지갑의 주소입니다.
+
+SDK의 도움 없이 명령어를 구성할 계획이라면, 이러한 민팅 설정들을 명령어 인수와 나머지 계정의 조합으로 제공해야 함을 참고하세요. 자세한 내용은 [Candy Guard의 프로그램 문서](https://github.com/metaplex-foundation/mpl-candy-machine/tree/main/programs/candy-guard#solpayment)를 참조하세요.
+
+{% dialect-switcher title="Sol Payment 가드로 민팅" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+다음과 같이 `mintArgs` 인수를 사용하여 Sol Payment 가드의 민팅 설정을 전달할 수 있습니다.
+
+```ts
+mintV2(umi, {
+  // ...
+  mintArgs: {
+    solPayment: some({ destination: treasury }),
+  },
+});
+```
+
+API 참조: [mintV2](https://mpl-candy-machine.typedoc.metaplex.com/functions/mintV2.html), [SolPaymentMintArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/SolPaymentMintArgs.html)
+
+{% /totem %}
+{% /dialect %}
+{% dialect title="Sugar" id="sugar" %}
+{% totem %}
+
+_가드가 할당되는 즉시 sugar를 사용하여 민팅할 수 없습니다 - 따라서 특정 민팅 설정이 없습니다._
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## Route 명령어
+
+_Sol Payment 가드는 route 명령어를 지원하지 않습니다._

src/pages/kr/candy-machine/guards/start-date.md

@@ -0,0 +1,114 @@
+---
+title: "Start Date 가드"
+metaTitle: Start Date 가드 | Candy Machine
+description: "Start Date 가드는 민팅의 시작 날짜를 결정합니다."
+---
+
+## 개요
+
+**Start Date** 가드는 민팅의 시작 날짜를 결정합니다. 이 날짜 이전에는 민팅이 허용되지 않습니다.
+
+{% diagram  %}
+
+{% node %}
+{% node #candy-machine label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% /node %}
+
+{% node parent="candy-machine" y="100" x="22" %}
+{% node #candy-guard label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node #candy-guard-guards label="가드" theme="mint"/%}
+{% node #startDate label="startDate" /%}
+{% node #date label="- 날짜" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine" #mint-candy-guard x="500" %}
+  {% node theme="pink" %}
+    민팅 from
+
+    _Candy Guard Program_
+  {% /node %}
+{% /node %}
+{% node parent="mint-candy-guard" y="-20" x="100" theme="transparent" %}
+  접근 제어
+{% /node %}
+
+{% node parent="mint-candy-guard" #mint-candy-machine y="150" x="-8" %}
+  {% node theme="pink" %}
+    민팅 from 
+    
+    _Candy Machine Program_
+  {% /node %}
+{% /node %}
+{% node parent="mint-candy-machine" y="-20" x="110" theme="transparent" %}
+  민팅 로직
+{% /node %}
+
+{% node #nft parent="mint-candy-machine" y="120" x="70" theme="blue" %}
+  NFT
+{% /node %}
+{% edge from="mint-candy-machine" to="nft" path="straight" /%}
+
+{% edge from="candy-guard" to="candy-machine" /%}
+{% edge from="date" to="mint-candy-guard" arrow="none" dashed=true %}
+해당 날짜 이전에는
+
+민팅이 실패합니다
+{% /edge %}
+
+{% edge from="candy-guard-guards" to="guards" /%}
+{% edge from="mint-candy-guard" to="mint-candy-machine" path="straight" /%}
+
+{% /diagram %}
+
+## 가드 설정
+
+Start Date 가드는 다음 설정을 포함합니다:
+
+- **Date**: 민팅이 허용되지 않는 기준 날짜입니다.
+
+{% dialect-switcher title="Start Date 가드를 사용하여 Candy Machine 설정" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+import { dateTime } from "@metaplex-foundation/umi";
+
+create(umi, {
+  // ...
+  guards: {
+    startDate: some({ date: dateTime("2022-01-24T15:30:00.000Z") }),
+  },
+});
+```
+
+API 참조: [create](https://mpl-candy-machine.typedoc.metaplex.com/functions/create.html), [StartDate](https://mpl-candy-machine.typedoc.metaplex.com/types/StartDate.html)
+
+{% /totem %}
+{% /dialect %}
+{% dialect title="Sugar" id="sugar" %}
+{% totem %}
+
+config.json 파일의 guard 섹션에 다음 객체를 추가하세요:
+
+```json
+"startDate" : {
+    "date": "string",
+}
+```
+
+날짜는 RFC 3339 표준을 사용하여 지정해야 합니다. 대부분의 경우 사용되는 형식은 "yyyy-mm-ddThh:mm:ssZ"이며, T는 전체 날짜와 전체 시간 사이의 구분자이고 Z는 UTC로부터의 시간대 오프셋입니다(UTC 시간의 경우 Z 또는 +00:00을 사용).
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 민팅 설정
+
+_Start Date 가드는 민팅 설정이 필요하지 않습니다._
+
+## Route 명령어
+
+_Start Date 가드는 route 명령어를 지원하지 않습니다._

src/pages/kr/candy-machine/guides/create-an-nft-collection-on-solana-with-candy-machine.md

@@ -0,0 +1,331 @@
+---
+title: Candy Machine으로 Solana에서 Token Metadata NFT 컬렉션 생성하기
+metaTitle: Candy Machine으로 Solana에서 Token Metadata NFT 컬렉션 생성하기 | Candy Machine
+description: Candy Machine을 사용하여 Solana 블록체인에서 NFT 컬렉션을 생성하는 방법입니다.
+---
+
+Solana에서 NFT 컬렉션을 출시하려는 경우 Sugar CLI 도구 키트가 더 복잡한 설정 및 관리 단계를 추상화하여 Solana 블록체인에서 Candy Machine을 생성할 수 있는 자동화된 출시 시스템을 제공합니다.
+
+## 사전 준비 사항
+
+- Solana CLI가 설치되고 구성되어 있어야 합니다. [설치](https://docs.solanalabs.com/cli/install)
+  - CLI를 사용하여 생성된 파일 시스템 지갑
+  - 메인넷 또는 데브넷 SOL로 지갑에 자금이 있어야 함
+
+## 초기 설정
+
+### Sugar 설치
+
+#### Mac/Linux
+
+```
+bash <(curl -sSf https://sugar.metaplex.com/install.sh)
+```
+
+#### Windows
+
+다음 URL을 사용하여 설치 실행 파일을 다운로드하여 Sugar를 설치할 수 있습니다:
+
+```
+https://github.com/metaplex-foundation/winstaller/releases/latest/download/winstaller.exe
+```
+
+더블 클릭으로 바이너리를 실행해 보세요. 신뢰할 수 없는 바이너리에 대한 팝업 메시지 경고가 나타나면 "추가 정보"를 클릭한 다음 "실행"을 클릭해 보세요.
+
+## 에셋 준비
+
+NFT는 `이미지`와 `메타데이터`라는 두 가지 기본 부분을 가집니다.
+
+이미지는 지갑과 마켓에서 보여지고 표시되는 것이며, `메타데이터`에는 `이름`, `이미지`를 찾을 링크, NFT의 `속성` 등 블록체인에서 해당 NFT에 대한 모든 관련 정보가 포함됩니다.
+
+### Assets 폴더
+
+Sugar에서 명령어를 실행할 때, Sugar는 명령어를 실행하는 디렉터리에서 `assets` 폴더를 찾을 것으로 예상합니다.
+
+이미지와 메타데이터 파일 모두 `assets` 폴더에 있어야 합니다.
+
+### 파일 명명
+
+이미지와 메타데이터 JSON 파일은 0부터 시작하는 증분 인덱스 명명 규칙을 따라야 합니다.
+
+인덱스가 누락되거나 `이미지`와 `메타데이터` 폴더에 동일한 수의 파일이 포함되지 않으면 폴더 검증이 실패합니다.
+
+```
+assets/
+├─ 0.png
+├─ 0.json
+├─ 1.png
+├─ 1.json
+├─ 2.png
+├─ 2.json
+├─ ...
+```
+
+### 메타데이터 JSON
+
+{% partial file="token-standard-full.md" /%}
+
+```json
+{
+  "name": "My NFT #1",
+  "description": "My NFT Collection",
+  "image": "https://arweave.net/26YdhY_eAzv26YdhY1uu9uiA3nmDZYwP8MwZAultcE?ext=jpeg",
+  "external_url": "https://example.com",
+  "attributes": [
+    {
+      "trait_type": "trait1",
+      "value": "value1"
+    },
+    {
+      "trait_type": "trait2",
+      "value": "value2"
+    }
+  ],
+  "properties": {
+    "files": [
+      {
+        "uri": "https://www.arweave.net/abcd5678?ext=png",
+        "type": "image/png"
+      }
+    ],
+    "category": "image"
+  }
+}
+```
+
+### 예시 이미지와 메타데이터
+
+Candy Machine을 생성하기 위해 예시 이미지와 메타데이터를 사용하고 싶다면 여기 GitHub에서 녹색 `code` 버튼을 클릭하고 `zip 형식`을 선택하여 zip 형식으로 다운로드할 수 있습니다.
+
+[https://github.com/metaplex-foundation/example-candy-machine-assets](https://github.com/metaplex-foundation/example-candy-machine-assets)
+
+또는 git이 설치되어 있다면 에셋을 시스템에 복제하거나 제공된 링크에서 압축된 사본을 다운로드할 수 있습니다
+
+```
+git clone https://github.com/metaplex-foundation/example-candy-machine-assets.git
+```
+
+### 이미지와 메타데이터 생성기
+
+레이어에서 아트워크 이미지와 메타데이터를 생성해야 한다면 생성기에 이미지 레이어와 프로젝트에 대한 기본 정보를 제공하면 주어진 매개변수에 따라 x개의 에셋 이미지와 JSON 메타데이터 조합을 생성하는 여러 자동화 스크립트와 웹사이트가 있습니다.
+
+| 이름                                                        | 타입   | 난이도 | 요구사항 | 무료 |
+| ----------------------------------------------------------- | ------ | ---------- | ------------ | ---- |
+| [nftchef](https://github.com/nftchef/art-engine)            | 스크립트 | ⭐⭐⭐⭐   | JS 지식 | ✅   |
+| [hashlips](https://github.com/HashLips/hashlips_art_engine) | 스크립트 | ⭐⭐⭐⭐   | JS 지식 | ✅   |
+| [Nft Art Generator](https://nft-generator.art/)             | 웹 UI | ⭐⭐       |              |      |
+| [bueno](https://bueno.art/generator)                        | 웹 UI | 알 수 없음    |              |      |
+
+### 컬렉션 세부사항
+
+컬렉션 생성을 위해서는 NFT 에셋과 같은 세부사항이 필요한데, 이는 `이미지` 파일과 `메타데이터` json 파일입니다. 이들은 다음과 같이 `assets/` 폴더의 루트에 배치됩니다:
+
+```
+assets/
+├─ collection.jpg
+├─ collection.json
+├─ 0.png
+├─ 0.json
+├─ 1.png
+├─ 1.json
+├─ 2.png
+├─ 2.json
+├─ ...
+```
+
+컬렉션 메타데이터 파일은 NFT 에셋 json 파일과 동일한 형식입니다. 컬렉션의 경우 `attributes` 필드 작성을 생략할 수 있습니다.
+
+```json
+{
+  "name": "My Collection",
+  "description": "This is My Nft Collection",
+  "image": "collection.jpg",
+  "external_url": "https://example.com",
+  "properties": {
+    "files": [
+      {
+        "uri": "https://example.com/1.jpg",
+        "type": "image/jpg"
+      }
+    ],
+    "category": "image"
+  }
+}
+```
+
+## Sugar
+
+기본적으로 **Sugar**는 Solana CLI에서 사용하는 것과 동일한 구성 파일을 사용하여 다음과 같은 기본값을 로드합니다:
+
+- Solana CLI에서 설정한 지갑
+- Solana CLI에서 설정한 RPC URL
+
+### Sugar Launch
+
+에셋 폴더가 준비되면 **Sugar**로 배포 프로세스를 시작할 수 있습니다. 실행할 첫 번째 명령어는
+
+```shell
+sugar launch
+```
+
+이는 Candy Machine 배포와 관련된 정보를 수집하기 위해 **Sugar**의 CLI 프로세스를 시작합니다.
+
+`sugar`가 구성 파일을 찾지 못하면 하나를 생성하라고 요청할 것입니다.
+
+그런 다음 작성할 다음 질문들이 나타날 것입니다
+
+```
+Found xx file pairs in "assets". Is this how many NFTs you will have in your candy machine?
+```
+
+```
+Found symbol "xxxx" in your metadata file. Is this value correct?
+```
+
+```
+Found value xxx for seller fee basis points in your metadata file. Is this value correct?
+```
+
+```
+Do you want to use a sequential mint index generation? We recommend you choose no.
+```
+
+```
+How many creator wallets do you have? (max limit of 4)
+```
+
+창작자 지갑은 로열티를 분배하는 데 사용됩니다. 선택하면 각 지갑에 대한 `주소`와 `지분` 금액을 입력하라는 메시지가 나타납니다.
+
+```
+Which extra features do you want to use? (use [SPACEBAR] to select options you want and hit [ENTER] when done)
+```
+
+이 가이드에서는 `hidden settings`를 선택하지 않은 상태로 두고 `enter`를 눌러 진행하겠습니다.
+
+```
+What upload method do you want to use?
+```
+
+이 가이드에서는 `Bundlr`을 선택하겠습니다.
+
+```
+Do you want your NFTs to remain mutable? We HIGHLY recommend you choose yes.
+```
+
+나중에 필요하면 NFT를 편집할 수 있도록 이 옵션에서 예(y)를 선택하세요.
+
+Sugar는 이제 다음 프로세스를 시작해야 합니다:
+
+- 컬렉션 NFT 생성 및 업로드
+- Irys (이전 Bundlr)를 사용하여 Arweave에 에셋 업로드
+- Candy Machine 생성
+
+성공하면 링크 내에 자신의 Candy Machine 주소가 포함된 다음 메시지가 표시됩니다:
+
+```
+https://www.solaneyes.com/address/Beag81WvAPUCeFpJ2qFnvd2f1CFCpQBf3abTJXA1fH9o?cluster=devnet
+```
+
+축하합니다! Solana에서 Candy Machine을 생성했습니다.
+위 링크를 클릭하면 온체인에서 Candy Machine 세부 정보를 볼 수 있습니다.
+
+### 가드와 그룹으로 Candy Machine 업데이트
+
+현재 Candy Machine에는 가드가 연결되어 있지 않습니다. 기본적으로 Candy Guard가 Candy Machine에 연결되지 않으면 **민트 권한**(당신)만 Candy Machine에서 민팅할 수 있습니다.
+
+이를 해결하기 위해 Candy Machine에 가드를 연결해야 하며, 이를 통해 일련의 규칙에 따라 공개적으로 Candy Machine에서 민팅할 수 있게 됩니다. 예를 들어, 사용자에게 1 SOL을 청구하면서 공개적으로 Candy Machine에서 민팅할 수 있게 하고 싶을 수 있습니다. 이를 위해 **Sol Payment Guard**를 사용할 수 있습니다.
+
+#### 가드 추가 (SOL Payment)
+
+Candy Machine에 Sol Payment Guard를 추가하려면 터미널에서 `sugar launch`를 실행한 폴더의 루트에 Sugar가 생성한 `config.json` 파일을 열어야 합니다.
+
+구성 파일은 다음과 같을 것입니다:
+
+```json
+{
+  "tokenStandard": "nft",
+  "number": 16,
+  "symbol": "NUMBERS",
+  "sellerFeeBasisPoints": 500,
+  "isMutable": true,
+  "isSequential": false,
+  "creators": [
+    {
+      "address": "B1kwbSHRiXFPYvNbuhCX92ibngzxdmfBzfaJYuy9WYp5",
+      "share": 100
+    }
+  ],
+  "uploadMethod": "bundlr",
+  "ruleSet": null,
+  "awsConfig": null,
+  "sdriveApiKey": null,
+  "nftStorageAuthToken": null,
+  "shdwStorageAccount": null,
+  "pinataConfig": null,
+  "hiddenSettings": null,
+  "guards": null,
+  "maxEditionSupply": null
+}
+```
+
+여기서 구성 파일 끝 부분의 `guards` 필드를 편집하고 SOL Payment가 전송될 대상 주소를 작성할 수 있습니다.
+
+```json
+"guards": {
+    "default": {
+        "solPayment": {
+            "value": 1,
+            "destination": "11111111111111111111111111111111"
+        }
+    }
+},
+```
+
+`config.json`에 가드를 추가한 후 파일을 저장하고 다음 명령어를 실행하세요:
+
+```
+sugar guard add
+```
+
+이전에 이미 Candy Guard를 생성했다면 대신 다음 명령어를 실행할 수 있습니다:
+
+```
+sugar guard update
+```
+
+이는 Candy Guard를 생성하고 기본 가드 목록에 **SOL Payment Guard**를 추가합니다.
+
+## Candy Machine 보기
+
+터미널에서 Candy Machine 세부 정보를 보려면 다음 명령어를 실행할 수 있습니다
+
+```shell
+sugar show
+```
+
+이는 삽입된 모든 항목을 제외한 모든 Candy Machine과 가드 세부 정보를 나열합니다.
+
+## Candy Guard 보기
+
+터미널에서 Candy Machine 세부 정보를 보려면 다음 명령어를 실행할 수 있습니다
+
+```shell
+sugar guard show
+```
+
+이는 삽입된 모든 항목을 제외한 모든 Candy Machine과 가드 세부 정보를 나열합니다.
+
+## 다음 단계
+
+이제 작동하는 Candy Machine이 있으므로 사람들이 Candy Machine에서 민팅할 수 있도록 웹 UI에서 Candy Machine을 호스팅해야 합니다.
+
+자체 UI를 생성하고 `umi` 클라이언트 래퍼와 `mpl-candy-machine` SDK를 사용하거나 미리 구축된 커뮤니티 UI를 사용하고 Candy Machine의 세부 정보만 제공할 수 있습니다.
+
+### UI 개발 리소스
+
+- nextJS/React 권장
+- Metaplex Umi - [https://developers.metaplex.com/umi](https://developers.metaplex.com/umi)
+- Metaplex Candy Machine SDK - [https://developers.metaplex.com/candy-machine](https://developers.metaplex.com/candy-machine)
+
+### 추가 읽을거리
+- [Sugar CLI 문서](/kr/candy-machine/sugar)

src/pages/kr/candy-machine/index.md

@@ -0,0 +1,218 @@
+---
+title: 개요
+metaTitle: 개요 | Candy Machine
+description: Candy Machine의 개요를 제공합니다.
+---
+
+Metaplex Protocol **Candy Machine**은 Solana에서 공정한 NFT 컬렉션 출시를 위한 선도적인 민팅 및 배포 프로그램입니다. 이름에서 알 수 있듯이 Candy Machine을 창작자가 먼저 로드하고 구매자가 언로드하는 임시 구조물로 생각할 수 있습니다. 이를 통해 창작자들은 안전하고 사용자 정의 가능한 방식으로 디지털 자산을 온체인으로 가져올 수 있습니다. {% .lead %}
+
+이 이름은 기계적 크랭크를 통해 동전을 넣고 사탕을 나누어주는 자판기를 의미합니다. 이 경우 사탕은 NFT이고 지불은 SOL 또는 SPL 토큰입니다.
+
+{% figure src="/assets/candy-machine/candy-machine-photo.png" alt="전형적인 사탕 자판기의 AI 생성 사진" caption="전형적인 사탕 자판기" /%}
+
+{% quick-links %}
+
+{% quick-link title="시작하기" icon="InboxArrowDown" href="/kr/candy-machine/getting-started" description="원하는 언어나 라이브러리를 찾고 Candy Machine으로 시작하세요." /%}
+{% quick-link title="API 참조" icon="CodeBracketSquare" href="https://mpl-candy-machine.typedoc.metaplex.com/" target="_blank" description="특정한 내용을 찾고 있나요? 여기에 있습니다." /%}
+{% /quick-links %}
+
+{% callout %}
+이 문서는 Metaplex Token Metadata NFT를 민팅하는 데 사용할 수 있는 Candy Machine V3을 참조합니다. Core Asset을 생성하려면 [Core Candy Machine](/kr/core-candy-machine)을 참조하세요.
+{% /callout %}
+
+## 소개
+
+2022년 9월까지 Solana의 모든 NFT 중 78%가 Metaplex의 Candy Machine을 통해 민팅되었습니다. 여기에는 Solana 생태계에서 잘 알려진 대부분의 NFT 프로젝트가 포함됩니다.
+
+다음은 제공하는 기능들입니다.
+
+- SOL, NFT 또는 모든 Solana 토큰으로 지불 받기.
+- 시작/종료 날짜, 민팅 제한, 제3자 서명자 등을 통해 출시를 제한.
+- 구성 가능한 봇 세금과 Captcha와 같은 게이트키퍼를 통해 봇으로부터 출시를 보호.
+- 특정 NFT/토큰 보유자 또는 선별된 지갑 목록으로 민팅 제한.
+- 다양한 규칙 세트로 여러 민팅 그룹 생성.
+- 사용자가 해당 정보를 확인할 수 있도록 하면서 출시 후 NFT 공개.
+- 그리고 훨씬 더 많은 기능!
+
+관심이 있으신가요? Candy Machine이 어떻게 작동하는지 간단히 살펴보겠습니다!
+
+## Candy Machine의 생명주기
+
+첫 번째 단계는 창작자가 새로운 Candy Machine을 생성하고 원하는 대로 구성하는 것입니다.
+
+{% diagram %}
+{% node #action label="1. 생성 및 구성" theme="pink" /%}
+{% node parent="action" x="250" %}
+{% node #candy-machine label="Candy Machine" theme="blue" /%}
+{% node label="설정" /%}
+{% /node %}
+{% edge from="action" to="candy-machine" path="straight" /%}
+{% /diagram %}
+
+생성된 Candy Machine은 자체 설정을 추적하여 모든 NFT가 어떻게 민팅되어야 하는지 이해할 수 있도록 도와줍니다. 예를 들어, 이 Candy Machine에서 민팅된 모든 NFT에 할당될 `creators` 매개변수가 있습니다. 다음 페이지에서 일부 코드 예제를 포함하여 Candy Machine을 생성하고 구성하는 방법에 대한 더 자세한 내용을 확인할 수 있습니다: [Candy Machine 설정](/kr/candy-machine/settings) 및 [Candy Machine 관리](/kr/candy-machine/manage).
+
+그러나 우리는 여전히 해당 Candy Machine에서 어떤 NFT가 민팅되어야 하는지 모릅니다. 다시 말해, Candy Machine이 로드되지 않았습니다. 따라서 다음 단계는 Candy Machine에 아이템을 삽입하는 것입니다.
+
+{% diagram %}
+{% node #action-1 label="1. 생성 및 구성" theme="pink" /%}
+{% node #action-2 label="2. 아이템 삽입" parent="action-1" y="50" theme="pink" /%}
+{% node parent="action-1" x="250" %}
+{% node #candy-machine label="Candy Machine" theme="blue" /%}
+{% node label="설정" /%}
+{% node #item-1 label="아이템 1" /%}
+{% node #item-2 label="아이템 2" /%}
+{% node #item-3 label="아이템 3" /%}
+{% node #item-rest label="..." /%}
+{% /node %}
+{% edge from="action-1" to="candy-machine" path="straight" /%}
+{% edge from="action-2" to="item-1" /%}
+{% edge from="action-2" to="item-2" /%}
+{% edge from="action-2" to="item-3" /%}
+{% edge from="action-2" to="item-rest" /%}
+{% /diagram %}
+
+각 아이템은 두 개의 매개변수로 구성됩니다:
+
+- `name`: NFT의 이름.
+- `uri`: NFT의 [JSON 메타데이터](https://developers.metaplex.com/token-metadata/token-standard#the-non-fungible-standard)를 가리키는 URI. 이는 JSON 메타데이터가 이미 온체인(예: Arweave, IPFS) 또는 오프체인(예: AWS, 자체 서버) 스토리지 제공업체를 통해 업로드되었음을 의미합니다.
+
+다른 모든 매개변수는 모든 NFT 간에 공유되므로 중복을 피하기 위해 Candy Machine의 설정에 직접 보관됩니다. 자세한 내용은 [아이템 삽입](/kr/candy-machine/insert-items)을 참조하세요.
+
+이 시점에서 실제 NFT는 아직 생성되지 않았다는 점에 주목하세요. 우리는 단순히 민팅 시 **온디맨드로 NFT를 생성**하는 데 필요한 모든 데이터로 Candy Machine을 로드하고 있습니다. 이것이 다음 단계로 이어집니다.
+
+{% diagram %}
+{% node #action-1 label="1. 생성 및 구성" theme="pink" /%}
+{% node #action-2 label="2. 아이템 삽입" parent="action-1" y="50" theme="pink" /%}
+
+{% node parent="action-1" x="250" %}
+{% node #candy-machine label="Candy Machine" theme="blue" /%}
+{% node label="설정" /%}
+{% node #item-1 label="아이템 1" /%}
+{% node #item-2 label="아이템 2" /%}
+{% node #item-3 label="아이템 3" /%}
+{% node #item-rest label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine" x="180" y="20" %}
+{% node #mint label="3. 민팅" theme="pink" /%}
+{% node #mint-1 label="민팅 #1" theme="pink" /%}
+{% node #mint-2 label="민팅 #2" theme="pink" /%}
+{% node #mint-3 label="민팅 #3" theme="pink" /%}
+{% /node %}
+
+{% node #nft-1 parent="mint" x="120" label="NFT" theme="blue" /%}
+{% node #nft-2 parent="nft-1" y="50" label="NFT" theme="blue" /%}
+{% node #nft-3 parent="nft-2" y="50" label="NFT" theme="blue" /%}
+
+{% edge from="action-1" to="candy-machine" path="straight" /%}
+{% edge from="action-2" to="item-1" /%}
+{% edge from="action-2" to="item-2" /%}
+{% edge from="action-2" to="item-3" /%}
+{% edge from="action-2" to="item-rest" /%}
+{% edge from="item-1" to="mint-1" /%}
+{% edge from="item-2" to="mint-2" /%}
+{% edge from="item-3" to="mint-3" /%}
+{% edge from="mint-1" to="nft-1" path="bezier" /%}
+{% edge from="mint-2" to="nft-2" path="bezier" /%}
+{% edge from="mint-3" to="nft-3" path="bezier" /%}
+{% /diagram %}
+
+Candy Machine이 로드되고 모든 사전 구성된 조건이 충족되면 사용자가 NFT 민팅을 시작할 수 있습니다. 이 시점에서만 Solana 블록체인에 NFT가 생성됩니다. 민팅 전에 일부 사용자는 Captcha 수행이나 머클 증명 전송과 같은 추가 검증 단계를 수행해야 할 수 있습니다. 자세한 내용은 [민팅](/kr/candy-machine/mint)을 참조하세요.
+
+Candy Machine에서 모든 NFT가 민팅되면 목적을 달성했으므로 안전하게 삭제하여 블록체인에서 일부 저장 공간을 해제하고 일부 임대료를 회수할 수 있습니다. 자세한 내용은 [Candy Machine 관리](/kr/candy-machine/manage)를 참조하세요.
+
+{% diagram %}
+{% node #action-1 label="4. 삭제" theme="pink" /%}
+{% node parent="action-1" x="150" %}
+{% node #candy-machine label="Candy Machine" theme="blue" /%}
+{% node label="설정" /%}
+{% node #item-1 label="아이템 1" /%}
+{% node #item-2 label="아이템 2" /%}
+{% node #item-3 label="아이템 3" /%}
+{% node #item-rest label="..." /%}
+{% /node %}
+{% node #nft-1 parent="candy-machine" x="200" label="NFT" theme="blue" /%}
+{% node #nft-2 parent="nft-1" y="50" label="NFT" theme="blue" /%}
+{% node #nft-3 parent="nft-2" y="50" label="NFT" theme="blue" /%}
+{% edge from="action-1" to="candy-machine" path="straight" /%}
+{% /diagram %}
+
+## Candy Guard
+
+이제 Candy Machine이 어떻게 작동하는지 이해했으므로 창작자가 Candy Machine의 민팅 프로세스를 보호하고 사용자 정의할 수 있는 다양한 방법을 살펴보겠습니다.
+
+창작자는 "**가드**"를 사용하여 Candy Machine에 다양한 기능을 추가할 수 있습니다. Metaplex Candy Machine은 [**총 21개의 기본 가드**](/kr/candy-machine/guards)와 함께 제공되는 **Candy Guard**라는 추가 Solana 프로그램과 함께 제공됩니다. 추가 프로그램을 사용함으로써 고급 개발자가 기본 Candy Guard 프로그램을 포크하여 자체 커스텀 가드를 만들면서도 여전히 메인 Candy Machine 프로그램을 사용할 수 있습니다.
+
+각 가드는 원하는 대로 활성화하고 구성할 수 있으므로 창작자가 필요한 기능을 선택할 수 있습니다. 모든 가드를 비활성화하는 것은 누구나 언제든지 무료로 NFT를 민팅할 수 있도록 허용하는 것과 같으며, 이는 우리가 원하는 것이 아닐 것입니다. 따라서 더 현실적인 예제를 만들기 위해 몇 가지 가드를 살펴보겠습니다.
+
+Candy Machine에 다음과 같은 가드가 있다고 가정해보겠습니다:
+
+- **Sol Payment**: 이 가드는 민팅 지갑이 구성된 목적지 지갑에 구성된 SOL 금액을 지불해야 함을 보장합니다.
+- **Start Date**: 이 가드는 구성된 시간 이후에만 민팅이 시작될 수 있도록 보장합니다.
+- **Mint Limit**: 이 가드는 각 지갑이 구성된 금액보다 많이 민팅할 수 없도록 보장합니다.
+- **Bot Tax**: 이 가드는 조금 특별합니다. 어떤 것도 보호하지 않지만 봇이 Candy Machine을 민팅하는 것을 방지하기 위해 실패한 민팅의 동작을 변경합니다. 이 가드가 활성화되면 다른 활성화된 가드가 민팅 검증에 실패하면 민팅을 시도한 지갑에 작은 구성된 SOL 금액을 청구합니다.
+
+결과적으로 SOL을 청구하고, 특정 시간에 출시되며, 지갑당 제한된 민팅만 허용하는 봇 방지 Candy Machine이 만들어집니다. 다음은 구체적인 예시입니다.
+
+{% diagram %}
+{% node %}
+{% node #candy-machine label="Candy Machine" theme="blue" /%}
+{% node label="설정" /%}
+{% node #items label="아이템" /%}
+{% node #guards %}
+가드:
+
+- Sol Payment (0.1 SOL)
+- Start Date (1월 6일)
+- Mint Limit (1)
+- Bot Tax (0.01 SOL)
+
+{% /node %}
+{% /node %}
+
+{% node parent="candy-machine" x="250" %}
+{% node #mints label="민팅" theme="pink" /%}
+{% node #mint-1 label="#1: 지갑 A (1 SOL) 1월 5일" theme="pink" /%}
+{% node #mint-2 label="#2: 지갑 B (3 SOL) 1월 6일" theme="pink" /%}
+{% node #mint-3 label="#3: 지갑 B (2 SOL) 1월 6일" theme="pink" /%}
+{% node #mint-4 label="#4: 지갑 C (0.5 SOL) 1월 6일" theme="pink" /%}
+{% /node %}
+{% node #fail-1 parent="mints" x="250" theme="red" %}
+너무 이름 {% .text-xs %} \
+봇 세금 청구됨
+{% /node %}
+{% node #nft-2 parent="fail-1" y="50" label="NFT" theme="blue" /%}
+{% node #fail-3 parent="nft-2" y="50" theme="red" %}
+이미 1개 민팅함 {% .text-xs %} \
+봇 세금 청구됨
+{% /node %}
+{% node #fail-4 parent="fail-3" y="50" theme="red" %}
+SOL 부족 {% .text-xs %} \
+봇 세금 청구됨
+{% /node %}
+
+{% edge from="candy-machine" to="mint-1" /%}
+{% edge from="candy-machine" to="mint-2" /%}
+{% edge from="candy-machine" to="mint-3" /%}
+{% edge from="candy-machine" to="mint-4" /%}
+{% edge from="mint-1" to="fail-1" path="bezier" /%}
+{% edge from="mint-2" to="nft-2" path="bezier" /%}
+{% edge from="mint-3" to="fail-3" path="bezier" /%}
+{% edge from="mint-4" to="fail-4" path="bezier" /%}
+{% /diagram %}
+
+보시다시피, 21개 이상의 기본 가드와 커스텀 가드를 생성할 수 있는 기능을 통해 창작자는 중요한 기능을 선별하고 완벽한 Candy Machine을 구성할 수 있습니다. 이는 매우 강력한 기능이므로 많은 페이지를 할애했습니다. 가드에 대해 더 자세히 알아보기 위한 최고의 시작점은 [Candy Guards](/kr/candy-machine/guards) 페이지입니다.
+
+## 다음 단계
+
+이것이 Candy Machine의 좋은 개요를 제공하지만, 발견하고 배울 것이 훨씬 더 많습니다. 이 Candy Machine 문서의 다른 페이지에서 기대할 수 있는 내용은 다음과 같습니다.
+
+- [시작하기](/kr/candy-machine/getting-started). Candy Machine을 관리하는 데 사용할 수 있는 다양한 라이브러리와 SDK를 나열합니다.
+- [Candy Machine 설정](/kr/candy-machine/settings). Candy Machine 설정을 매우 자세히 설명합니다.
+- [Candy Machine 관리](/kr/candy-machine/manage). Candy Machine을 관리하는 방법을 설명합니다.
+- [아이템 삽입](/kr/candy-machine/insert-items). Candy Machine에 아이템을 로드하는 방법을 설명합니다.
+- [Candy Guards](/kr/candy-machine/guards). 가드가 작동하는 방식과 활성화하는 방법을 설명합니다.
+- [가드 그룹](/kr/candy-machine/guard-groups). 여러 가드 그룹을 구성하는 방법을 설명합니다.
+- [특수 가드 명령어](/kr/candy-machine/guard-route). 가드별 명령어를 실행하는 방법을 설명합니다.
+- [민팅](/kr/candy-machine/mint). Candy Machine에서 민팅하는 방법과 민팅 전 요구사항을 처리하는 방법을 설명합니다.
+- [참조](/kr/candy-machine/references). Candy Machine과 관련된 API 참조를 나열합니다.

src/pages/kr/candy-machine/insert-items.md

@@ -0,0 +1,189 @@
+---
+title: 아이템 삽입
+metaTitle: 아이템 삽입 | Candy Machine
+description: Candy Machine에 아이템을 로드하는 방법을 설명합니다.
+---
+
+지금까지 Candy Machine을 생성하고 구성하는 방법을 배웠지만 NFT로 민팅할 수 있는 아이템을 내부에 삽입하는 방법을 보지 못했습니다. 따라서 이 페이지에서 이를 다루어보겠습니다. {% .lead %}
+
+**아이템 삽입은 [구성 라인 설정](/kr/candy-machine/settings#config-line-settings)을 사용하는 Candy Machine에만 적용됩니다**라는 점을 기억하는 것이 중요합니다. 이는 [숨겨진 설정](/kr/candy-machine/settings#hidden-settings)을 사용하는 Candy Machine에서 민팅된 NFT가 모두 동일한 "숨겨진" 이름과 URI를 공유하기 때문입니다.
+
+## JSON 메타데이터 업로드
+
+Candy Machine에 아이템을 삽입하려면 각 아이템에 대해 다음 두 매개변수가 필요합니다:
+
+- **이름**: 이 아이템에서 민팅될 NFT의 이름. 구성 라인 설정에서 이름 접두사가 제공된 경우 해당 접두사 뒤에 오는 이름 부분만 제공해야 합니다.
+- **URI**: 이 아이템에서 민팅될 NFT의 JSON 메타데이터를 가리키는 URI. 여기서도 구성 라인 설정에서 제공되었을 수 있는 URI 접두사는 제외됩니다.
+
+아이템에 대한 URI가 없는 경우 먼저 JSON 메타데이터를 하나씩 업로드해야 합니다. 이는 AWS나 자체 서버와 같은 오프체인 솔루션이나 Arweave나 IPFS와 같은 온체인 솔루션을 사용할 수 있습니다.
+
+테스트를 위한 예시 자산은 이 [Github 저장소](https://github.com/metaplex-foundation/example-candy-machine-assets)에서 찾을 수 있습니다.
+
+다행히 우리의 SDK가 도움을 줄 수 있습니다. JSON 객체를 업로드하고 해당 URI를 검색할 수 있게 해줍니다.
+
+또한 [Sugar](/kr/candy-machine/sugar)와 같은 도구는 병렬 업로드, 프로세스 캐싱 및 실패한 업로드 재시도를 통해 JSON 메타데이터 업로드를 아주 쉽게 만들어 줍니다.
+
+{% dialect-switcher title="아이템 업로드" %}
+{% dialect title="JavaScript" id="js" %}
+
+Umi는 선택한 스토리지 제공업체에 JSON 데이터를 업로드하는 데 사용할 수 있는 `uploader` 인터페이스를 제공합니다. 예를 들어, 다음은 업로더 인터페이스의 NFT.Storage 구현을 선택하는 방법입니다.
+
+```ts
+import { nftStorage } from '@metaplex-foundation/umi-uploader-nft-storage'
+umi.use(nftStorageUploader({ token: 'YOUR_API_TOKEN' }))
+```
+
+그런 다음 `uploader` 인터페이스의 `upload` 및 `uploadJson` 메서드를 사용하여 자산과 해당 JSON 메타데이터를 업로드할 수 있습니다.
+
+```ts
+import { createGenericFileFromBrowserFile } from '@metaplex-foundation/umi'
+
+// 자산 업로드.
+const file = await createGenericFileFromBrowserFile(event.target.files[0])
+const [fileUri] = await umi.uploader.upload([file])
+
+// JSON 메타데이터 업로드.
+const uri = await umi.uploader.uploadJson({
+  name: 'My NFT #1',
+  description: 'My description',
+  image: fileUri,
+})
+```
+
+API 참조: [UploaderInterface](https://umi.typedoc.metaplex.com/interfaces/umi.UploaderInterface.html), [createGenericFileFromBrowserFile](https://umi.typedoc.metaplex.com/functions/umi.createGenericFileFromBrowserFile.html).
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 아이템 삽입
+
+이제 모든 아이템의 이름과 URI가 있으므로 Candy Machine 계정에 삽입하기만 하면 됩니다.
+
+이는 프로세스의 중요한 부분이며, 구성 라인 설정을 사용할 때 **모든 아이템이 삽입될 때까지 민팅이 허용되지 않습니다**.
+
+삽입된 각 아이템의 이름과 URI는 각각 구성 라인 설정의 **이름 길이** 및 **URI 길이** 속성에 의해 제약을 받는다는 점에 주목하세요.
+
+또한 트랜잭션이 특정 크기로 제한되기 때문에 동일한 트랜잭션 내에서 수천 개의 아이템을 삽입할 수 없습니다. 트랜잭션당 삽입할 수 있는 아이템의 수는 구성 라인 설정에서 정의된 **이름 길이** 및 **URI 길이** 속성에 따라 달라집니다. 이름과 URI가 짧을수록 트랜잭션에 더 많이 넣을 수 있습니다.
+
+{% dialect-switcher title="구성 라인 추가" %}
+{% dialect title="JavaScript" id="js" %}
+
+Umi 라이브러리를 사용할 때 `addConfigLines` 함수를 사용하여 Candy Machine에 아이템을 삽입할 수 있습니다. 추가할 구성 라인과 삽입하려는 인덱스가 필요합니다.
+
+```ts
+await addConfigLines(umi, {
+  candyMachine: candyMachine.publicKey,
+  index: 0,
+  configLines: [
+    { name: 'My NFT #1', uri: 'https://example.com/nft1.json' },
+    { name: 'My NFT #2', uri: 'https://example.com/nft2.json' },
+  ],
+}).sendAndConfirm(umi)
+```
+
+현재 로드된 아이템의 끝에 아이템을 간단히 추가하려면 다음과 같이 `candyMachine.itemsLoaded` 속성을 인덱스로 사용할 수 있습니다.
+
+```ts
+await addConfigLines(umi, {
+  candyMachine: candyMachine.publicKey,
+  index: candyMachine.itemsLoaded,
+  configLines: [
+    { name: 'My NFT #3', uri: 'https://example.com/nft3.json' },
+    { name: 'My NFT #4', uri: 'https://example.com/nft4.json' },
+    { name: 'My NFT #5', uri: 'https://example.com/nft5.json' },
+  ],
+}).sendAndConfirm(umi)
+```
+
+API 참조: [addConfigLines](https://mpl-candy-machine.typedoc.metaplex.com/functions/addConfigLines.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 접두사를 사용한 아이템 삽입
+
+이름 및/또는 URI 접두사를 사용할 때는 해당 접두사 뒤에 오는 부분만 삽입하면 됩니다.
+
+접두사를 사용하면 이름 길이와 URI 길이를 크게 줄일 수 있으므로 트랜잭션당 훨씬 더 많은 아이템을 넣는 데 도움이 됩니다.
+
+{% dialect-switcher title="주어진 인덱스에서 구성 라인 추가" %}
+{% dialect title="JavaScript" id="js" %}
+
+접두사를 사용하는 Candy Machine에 구성 라인을 추가할 때 `addConfigLines` 함수를 사용할 때 접두사 뒤에 오는 이름과 URI 부분만 제공하면 됩니다.
+
+예를 들어, 다음과 같은 구성 라인 설정이 있는 Candy Machine이 있다고 가정해보세요.
+
+```ts
+await create(umi, {
+  // ...
+  configLineSettings: some({
+    prefixName: 'My NFT #',
+    nameLength: 4,
+    prefixUri: 'https://example.com/nft',
+    uriLength: 9,
+    isSequential: false,
+  }),
+}).sendAndConfirm(umi)
+```
+
+그러면 다음과 같이 구성 라인을 삽입할 수 있습니다.
+
+```ts
+await addConfigLines(umi, {
+  candyMachine: candyMachine.publicKey,
+  index: candyMachine.itemsLoaded,
+  configLines: [
+    { name: '1', uri: '1.json' },
+    { name: '2', uri: '2.json' },
+    { name: '3', uri: '3.json' },
+  ],
+}).sendAndConfirm(umi)
+```
+
+API 참조: [addConfigLines](https://mpl-candy-machine.typedoc.metaplex.com/functions/addConfigLines.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 기존 아이템 재정의
+
+아이템을 삽입할 때 해당 아이템을 삽입할 위치를 제공할 수 있습니다. 이를 통해 원하는 순서로 아이템을 삽입할 수 있을 뿐만 아니라 이미 삽입된 아이템을 업데이트할 수도 있습니다.
+
+{% dialect-switcher title="구성 라인 재정의" %}
+{% dialect title="JavaScript" id="js" %}
+
+다음 예시는 세 개의 아이템을 삽입하고 나중에 삽입된 두 번째 아이템을 업데이트하는 방법을 보여줍니다.
+
+```ts
+await addConfigLines(umi, {
+  candyMachine: candyMachine.publicKey,
+  index: 0,
+  configLines: [
+    { name: 'My NFT #1', uri: 'https://example.com/nft1.json' },
+    { name: 'My NFT #2', uri: 'https://example.com/nft2.json' },
+    { name: 'My NFT #3', uri: 'https://example.com/nft3.json' },
+  ],
+}).sendAndConfirm(umi)
+
+await addConfigLines(umi, {
+  candyMachine: candyMachine.publicKey,
+  index: 1,
+  configLines: [{ name: 'My NFT #X', uri: 'https://example.com/nftX.json' }],
+}).sendAndConfirm(umi)
+
+candyMachine = await fetchCandyMachine(candyMachine.publicKey)
+candyMachine.items[0].name // "My NFT #1"
+candyMachine.items[1].name // "My NFT #X"
+candyMachine.items[2].name // "My NFT #3"
+```
+
+API 참조: [addConfigLines](https://mpl-candy-machine.typedoc.metaplex.com/functions/addConfigLines.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 결론
+
+바로 이렇게 NFT를 민팅할 준비가 된 로드된 Candy Machine이 완성되었습니다! 그러나 아직 민팅 프로세스에 대한 요구사항을 만들지 않았습니다. 민팅의 가격을 어떻게 구성할 수 있을까요? 구매자가 특정 토큰의 보유자이거나 특정 컬렉션의 NFT 보유자인지 어떻게 확인할 수 있을까요? 민팅의 시작 날짜를 어떻게 설정할까요? 종료 조건은 어떨까요?
+
+[다음 페이지](/kr/candy-machine/guards)에서는 이 모든 것을 가능하게 하는 Candy Guard에 대해 이야기하겠습니다.

src/pages/kr/candy-machine/manage.md

@@ -0,0 +1,426 @@
+---
+title: Candy Machine 관리
+metaTitle: 생성, 업데이트, 가져오기 및 삭제 | Candy Machine
+description: Candy Machine을 관리하는 방법을 설명합니다.
+---
+
+[이전 페이지](/kr/candy-machine/settings)에서 Candy Machine의 다양한 설정을 살펴보았습니다. 이제 이러한 설정을 사용하여 Candy Machine을 생성하고 업데이트하는 방법을 살펴보겠습니다. 또한 기존 Candy Machine을 가져오는 방법과 목적을 달성했을 때 삭제하는 방법에 대해서도 이야기하겠습니다. {% .lead %}
+
+기본적으로 Candy Machine의 생성, 읽기, 업데이트 및 삭제 단계를 거쳐보겠습니다. 시작해보죠!
+
+## Candy Machine 생성
+
+이전 페이지에서 논의한 설정을 사용하여 새로운 Candy Machine 계정을 생성할 수 있습니다.
+
+우리의 SDK는 이를 한 단계 더 발전시켜 모든 새로운 Candy Machine 계정을 민팅 프로세스에 영향을 주는 모든 활성화된 가드를 추적하는 새로운 Candy Guard 계정과 연결합니다. 이 페이지에서는 Candy Machine 계정에 집중하지만 Candy Guard 계정과 이를 통해 할 수 있는 작업에 대해서는 [전용 페이지](/kr/candy-machine/guards)에서 다루겠습니다.
+
+Candy Machine은 [컬렉션 NFT와 연결되어야 하고](/kr/candy-machine/settings#metaplex-certified-collections) 해당 업데이트 권한이 이 작업을 승인해야 한다는 점을 기억하세요. 아직 Candy Machine용 컬렉션 NFT가 없다면 우리의 SDK가 도움을 줄 수 있습니다.
+
+{% callout type="note" title="무작위성" %}
+
+자산의 "무작위" 민팅 프로세스가 완전히 예측할 수 없는 것은 아니며 충분한 리소스와 악의적인 의도로 영향을 받을 수 있으므로 공개 메커니즘을 위해 [숨겨진 설정](/kr/candy-machine/settings#hidden-settings)을 활용하는 것이 바람직할 수 있습니다.
+
+{% /callout %}
+
+{% dialect-switcher title="Candy Machine 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+다음은 Umi 라이브러리를 통해 새로운 컬렉션 NFT를 사용하여 Candy Machine을 생성하는 방법입니다.
+
+```ts
+import {
+  createNft,
+  TokenStandard,
+} from '@metaplex-foundation/mpl-token-metadata'
+import { create } from '@metaplex-foundation/mpl-candy-machine'
+import { generateSigner, percentAmount } from '@metaplex-foundation/umi'
+
+// 컬렉션 NFT 생성.
+const collectionMint = generateSigner(umi)
+await createNft(umi, {
+  mint: collectionMint,
+  authority: umi.identity,
+  name: 'My Collection NFT',
+  uri: 'https://example.com/path/to/some/json/metadata.json',
+  sellerFeeBasisPoints: percentAmount(9.99, 2), // 9.99%
+  isCollection: true,
+    collectionDetails: {
+    __kind: 'V1',
+    size: 0,
+  },
+}).sendAndConfirm(umi)
+
+// Candy Machine 생성.
+const candyMachine = generateSigner(umi)
+await create(umi, {
+  candyMachine,
+  collectionMint: collectionMint.publicKey,
+  collectionUpdateAuthority: umi.identity,
+  tokenStandard: TokenStandard.NonFungible,
+  sellerFeeBasisPoints: percentAmount(9.99, 2), // 9.99%
+  itemsAvailable: 5000,
+  creators: [
+    {
+      address: umi.identity.publicKey,
+      verified: true,
+      percentageShare: 100,
+    },
+  ],
+  configLineSettings: some({
+    prefixName: '',
+    nameLength: 32,
+    prefixUri: '',
+    uriLength: 200,
+    isSequential: false,
+  }),
+}).sendAndConfirm(umi)
+```
+
+위에서 언급했듯이 이 작업은 생성된 Candy Machine과 새로운 Candy Guard 계정을 생성하고 연결하는 것도 처리합니다. 이는 Candy Guard가 없는 Candy Machine은 그다지 유용하지 않고 대부분의 경우 이를 수행하고 싶어하기 때문입니다. 여전히 이 동작을 비활성화하고 싶다면 대신 `createCandyMachineV2` 메서드를 사용할 수 있습니다.
+
+```tsx
+import { createCandyMachineV2 } from '@metaplex-foundation/mpl-candy-machine'
+
+await createCandyMachineV2(umi, {
+  // ...
+}).sendAndConfirm(umi)
+```
+
+이 예시에서는 필수 매개변수에만 집중했지만 이 `create` 함수로 할 수 있는 작업을 보려면 다음 API 참조를 확인하는 것이 좋습니다.
+
+API 참조: [create](https://mpl-candy-machine.typedoc.metaplex.com/functions/create.html), [createCandyMachineV2](https://mpl-candy-machine.typedoc.metaplex.com/functions/createCandyMachineV2.html).
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## Candy Machine 계정
+
+이제 Candy Machine 계정을 생성했으므로 그 안에 어떤 데이터가 저장되는지 살펴보겠습니다.
+
+먼저 계정이 생성될 때 제공된 모든 설정을 저장하고 변경 사항을 추적합니다. 이러한 설정에 대한 자세한 내용은 [이전 페이지](/kr/candy-machine/settings)를 참조하세요.
+
+또한 다음 속성들을 저장합니다:
+
+- **Items Redeemed**. Candy Machine에서 민팅된 NFT의 수를 추적합니다. 이 숫자가 0에서 1로 변하는 순간 대부분의 설정은 더 이상 업데이트할 수 없습니다.
+- **Account Version**. 이 열거형은 Candy Machine의 계정 버전을 추적하는 데 사용됩니다. 사용 가능한 기능과 계정을 해석하는 방법을 결정하는 데 사용됩니다. 이는 Candy Machine 프로그램(Candy Machine Core 및 Candy Guard 프로그램 포함)의 세 번째이자 최신 반복을 의미하는 "Candy Machine V3"과 혼동하지 않도록 주의하세요.
+- **Feature Flags**. 더 많은 기능이 도입됨에 따라 프로그램의 이전 및 이후 호환성을 도와줍니다.
+
+마지막으로 Candy Machine에 삽입된 모든 아이템과 민팅 여부를 저장합니다. 이는 [**숨겨진 설정**](/kr/candy-machine/settings#hidden-settings)은 아이템을 삽입할 수 없으므로 [**구성 라인 설정**](/kr/candy-machine/settings#config-line-settings)을 사용하는 Candy Machine에만 적용됩니다. 이 섹션에는 다음 정보가 포함됩니다:
+
+- 로드된 아이템의 수.
+- 삽입되었거나 삽입될 모든 아이템의 목록. 아이템이 아직 삽입되지 않았을 때 해당 위치의 아이템 이름과 URI는 비어 있습니다.
+- 로드된 아이템을 추적하는 비트맵 — 예 또는 아니오의 목록. 이 비트맵이 모든 예로 가득 찼을 때 모든 아이템이 로드되었습니다.
+- 무작위 순서로 민팅할 때 아직 민팅되지 _않은_ 모든 아이템의 목록. 이를 통해 프로그램이 이미 민팅된 인덱스를 선택하는 것을 걱정하지 않고 무작위로 인덱스를 가져와 다시 시작할 수 있습니다.
+
+이 마지막 섹션은 의도적으로 프로그램에서 역직렬화되지 않지만 우리의 SDK가 사람에게 친숙한 형식으로 모든 데이터를 파싱해 줍니다.
+
+Candy Machine 계정에 대한 더 자세한 정보는 [프로그램의 API 참조](https://github.com/metaplex-foundation/mpl-candy-machine/tree/main/programs/candy-machine-core#account)를 확인하세요.
+
+{% dialect-switcher title="Candy Machine 계정 내부" %}
+{% dialect title="JavaScript" id="js" %}
+
+Umi 라이브러리에서 Candy Machine이 어떻게 모델링되는지 확인하는 가장 좋은 방법은 [`CandyMachine` 계정의 API 참조](https://mpl-candy-machine.typedoc.metaplex.com/types/CandyMachine.html)를 확인하는 것입니다. `create` 함수를 사용할 때 각 Candy Machine에 대해 자동으로 하나가 생성되므로 [`candyGuard` 계정의 API 참조](https://mpl-candy-machine.typedoc.metaplex.com/types/CandyGuard.html)도 확인하는 것이 좋습니다.
+
+다음은 Candy Machine 속성 중 일부를 보여주는 작은 코드 예시입니다.
+
+```tsx
+import {
+  fetchCandyMachine,
+  fetchCandyGuard,
+} from '@metaplex-foundation/mpl-candy-machine'
+
+const candyMachine = await fetchCandyMachine(umi, candyMachineAddress)
+const candyGuard = await fetchCandyGuard(umi, candyMachine.mintAuthority)
+
+candyMachine.publicKey // Candy Machine 계정의 공개 키.
+candyMachine.mintAuthority // 대부분의 경우 Candy Guard 주소인 Candy Machine의 민트 권한.
+candyMachine.data.itemsAvailable // 사용 가능한 총 NFT 수.
+candyMachine.itemsRedeemed // 민팅된 NFT 수.
+candyMachine.items[0].index // 첫 번째 로드된 아이템의 인덱스.
+candyMachine.items[0].name // 첫 번째 로드된 아이템의 이름 (접두사 포함).
+candyMachine.items[0].uri // 첫 번째 로드된 아이템의 URI (접두사 포함).
+candyMachine.items[0].minted // 첫 번째 아이템이 민팅되었는지 여부.
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## Candy Machine 가져오기
+
+기존 Candy Machine을 가져오려면 주소만 제공하면 우리의 SDK가 계정 데이터를 파싱해 줍니다.
+
+{% dialect-switcher title="Candy Machine 가져오기" %}
+{% dialect title="JavaScript" id="js" %}
+
+다음은 주소를 사용하여 Candy Machine과 관련된 Candy Guard 계정(있는 경우)을 가져오는 방법입니다.
+
+```ts
+import { publicKey } from '@metaplex-foundation/umi'
+import {
+  fetchCandyMachine,
+  fetchCandyGuard,
+} from '@metaplex-foundation/mpl-candy-machine'
+
+const candyMachine = await fetchCandyMachine(umi, publicKey('...'))
+const candyGuard = await fetchCandyGuard(umi, candyMachine.mintAuthority)
+```
+
+API 참조: [fetchCandyMachine](https://mpl-candy-machine.typedoc.metaplex.com/functions/fetchCandyMachine.html), [fetchCandyGuard](https://mpl-candy-machine.typedoc.metaplex.com/functions/fetchCandyGuard.html).
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 권한 업데이트
+
+Candy Machine이 생성되면 Candy Machine의 권한인 한 나중에 대부분의 설정을 업데이트할 수 있습니다. 다음 몇 섹션에서 이러한 설정을 업데이트하는 방법을 살펴보겠지만 먼저 Candy Machine의 **권한**과 **민트 권한**을 업데이트하는 방법을 살펴보겠습니다.
+
+- 권한을 업데이트하려면 현재 권한을 서명자로 전달하고 새 권한의 주소를 전달해야 합니다.
+- 민트 권한을 업데이트하려면 현재 권한과 새 민트 권한을 모두 서명자로 전달해야 합니다. 이는 민트 권한이 주로 Candy Guard를 Candy Machine과 연결하는 데 사용되기 때문입니다. 민트 권한을 서명자로 만들면 누구나 다른 사람의 Candy Guard를 사용하는 것을 방지할 수 있으며, 이는 원래 Candy Machine에 부작용을 일으킬 수 있습니다.
+
+{% dialect-switcher title="Candy Machine의 권한 업데이트" %}
+{% dialect title="JavaScript" id="js" %}
+
+다음은 Umi 라이브러리를 사용하여 Candy Machine의 권한을 업데이트하는 방법입니다. 대부분의 경우 관련된 Candy Guard 계정의 권한도 업데이트하고 싶을 것입니다.
+
+```ts
+import { generateSigner } from '@metaplex-foundation/umi'
+import {
+  setCandyMachineAuthority,
+  setCandyGuardAuthority,
+} from '@metaplex-foundation/mpl-candy-machine'
+
+const newAuthority = generateSigner(umi)
+await setCandyMachineAuthority(umi, {
+  candyMachine: candyMachine.publicKey,
+  authority: currentAuthority,
+  newAuthority: newAuthority.publicKey,
+})
+  .add(
+    setCandyGuardAuthority(umi, {
+      candyGuard: candyMachine.mintAuthority,
+      authority: currentAuthority,
+      newAuthority: newAuthority.publicKey,
+    })
+  )
+  .sendAndConfirm(umi)
+```
+
+관련된 Candy Guard 계정을 재정의하기 때문에 `mintAuthority`를 직접 업데이트하고 싶지는 않을 것이지만, 방법은 다음과 같습니다.
+
+```ts
+import { generateSigner } from '@metaplex-foundation/umi'
+import { setMintAuthority } from '@metaplex-foundation/mpl-candy-machine'
+
+const newMintAuthority = generateSigner(umi)
+await setMintAuthority(umi, {
+  candyMachine: candyMachine.publicKey,
+  authority: currentAuthority,
+  mintAuthority: newMintAuthority,
+}).sendAndConfirm(umi)
+```
+
+API 참조: [setCandyMachineAuthority](https://mpl-candy-machine.typedoc.metaplex.com/functions/setCandyMachineAuthority.html), [setCandyGuardAuthority](https://mpl-candy-machine.typedoc.metaplex.com/functions/setCandyGuardAuthority.html), [setMintAuthority](https://mpl-candy-machine.typedoc.metaplex.com/functions/setMintAuthority.html).
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 공유 NFT 데이터 업데이트
+
+Candy Machine의 모든 민팅된 NFT 간에 공유되는 속성도 업데이트할 수 있습니다. [이전 페이지](/kr/candy-machine/settings#settings-shared-by-all-nf-ts)에서 언급했듯이 이러한 속성은: 판매자 수수료 베이시스 포인트, 심볼, 최대 에디션 공급량, 변경 가능 여부 및 창작자입니다.
+
+첫 번째 NFT가 민팅되면 이러한 속성은 더 이상 업데이트할 수 없다는 점에 주목하세요.
+
+{% dialect-switcher title="Candy Machine의 NFT 데이터 업데이트" %}
+{% dialect title="JavaScript" id="js" %}
+
+다음은 Candy Machine에서 일부 공유 NFT 데이터를 업데이트하는 예시입니다.
+
+```tsx
+import { percentAmount } from '@metaplex-foundation/umi'
+import {
+  updateCandyMachine,
+  fetchCandyMachine,
+} from '@metaplex-foundation/mpl-candy-machine'
+
+const candyMachine = await fetchCandyMachine(umi, candyMachineAddress)
+await updateCandyMachine(umi, {
+  candyMachine: candyMachine.publicKey,
+  data: {
+    ...candyMachine.data,
+    symbol: 'NEW',
+    sellerFeeBasisPoints: percentAmount(5.5, 2),
+    creators: [{ address: newCreator, verified: false, percentageShare: 100 }],
+  },
+}).sendAndConfirm(umi)
+```
+
+API 참조: [updateCandyMachine](https://mpl-candy-machine.typedoc.metaplex.com/functions/updateCandyMachine.html).
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 토큰 표준 업데이트
+
+토큰 표준 및 규칙 세트 속성도 "토큰 표준 설정" 명령어를 사용하여 Candy Machine에서 업데이트할 수 있습니다. 이를 통해 일반 NFT에서 프로그래머블 NFT로 또는 그 반대로 전환할 수 있습니다. 프로그래머블 NFT로 전환할 때 민팅된 NFT가 준수해야 하는 규칙 세트를 선택적으로 지정하거나 업데이트할 수 있습니다.
+
+Candy Machine이 이전 계정 버전을 사용하는 경우 이 명령어는 자동으로 프로그래머블 NFT와 일반 NFT를 모두 지원하는 최신 계정 버전으로 업그레이드합니다. 업그레이드되면 Candy Machine 또는 Candy Guard에서 민팅하기 위해 최신 명령어를 사용해야 합니다.
+
+{% dialect-switcher title="Candy Machine의 토큰 표준 업데이트" %}
+{% dialect title="JavaScript" id="js" %}
+
+다음은 Umi를 사용하여 Candy Machine의 토큰 표준과 규칙 세트를 업데이트하는 예시입니다.
+
+```ts
+import { TokenStandard } from '@metaplex-foundation/mpl-token-metadata'
+import { setTokenStandard } from '@metaplex-foundation/mpl-candy-machine'
+
+await setTokenStandard(umi, {
+  candyMachine: candyMachine.publicKey,
+  collectionMint: candyMachine.collectionMint,
+  collectionUpdateAuthority,
+  tokenStandard: TokenStandard.ProgrammableNonFungible,
+  ruleSet: newRuleSetAccount,
+}).sendAndConfirm(umi)
+```
+
+Candy Machine이 계정 버전 `V1`을 사용하는 경우 레거시 컬렉션 위임 권한 레코드 계정을 사용하므로 `collectionAuthorityRecord` 계정을 명시적으로 설정해야 합니다.
+
+```ts
+import { findCollectionAuthorityRecordPda } from '@metaplex-foundation/mpl-token-metadata'
+import { findCandyMachineAuthorityPda } from '@metaplex-foundation/mpl-candy-machine'
+
+await setTokenStandard(umi, {
+  // ...
+  collectionAuthorityRecord: findCollectionAuthorityRecordPda(umi, {
+    mint: candyMachine.collectionMint,
+    collectionAuthority: findCandyMachineAuthorityPda(umi, {
+      candyMachine: candyMachine.publicKey,
+    }),
+  }),
+}).sendAndConfirm(umi)
+```
+
+API 참조: [setTokenStandard](https://mpl-candy-machine.typedoc.metaplex.com/functions/setTokenStandard.html).
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 컬렉션 업데이트
+
+Candy Machine과 연결된 컬렉션 NFT를 변경하는 것도 가능합니다. 이 변경을 승인하기 위해 컬렉션 NFT의 민트 계정 주소와 해당 업데이트 권한을 서명자로 제공해야 합니다.
+
+여기서도 첫 번째 NFT가 민팅되면 컬렉션을 변경할 수 없다는 점에 주목하세요.
+
+{% dialect-switcher title="Candy Machine의 컬렉션 업데이트" %}
+{% dialect title="JavaScript" id="js" %}
+
+Umi 라이브러리를 사용하여 Candy Machine의 컬렉션 NFT를 업데이트하려면 다음과 같이 `setCollectionV2` 메서드를 사용할 수 있습니다.
+
+```ts
+await setCollectionV2(umi, {
+  candyMachine: candyMachine.publicKey,
+  collectionMint: candyMachine.collectionMint,
+  collectionUpdateAuthority: collectionUpdateAuthority.publicKey,
+  newCollectionMint: newCollectionMint.publicKey,
+  newCollectionUpdateAuthority,
+}).sendAndConfirm(umi)
+```
+
+Candy Machine이 계정 버전 `V1`을 사용하는 경우 레거시 컬렉션 위임 권한 레코드 계정을 사용하므로 `collectionDelegateRecord` 계정을 명시적으로 설정해야 합니다.
+
+```ts
+import { findCollectionAuthorityRecordPda } from '@metaplex-foundation/mpl-token-metadata'
+import { findCandyMachineAuthorityPda } from '@metaplex-foundation/mpl-candy-machine'
+
+await setCollectionV2(umi, {
+  // ...
+  collectionDelegateRecord: findCollectionAuthorityRecordPda(umi, {
+    mint: candyMachine.collectionMint,
+    collectionAuthority: findCandyMachineAuthorityPda(umi, {
+      candyMachine: candyMachine.publicKey,
+    }),
+  }),
+}).sendAndConfirm(umi)
+```
+
+API 참조: [setCollectionV2](https://mpl-candy-machine.typedoc.metaplex.com/functions/setCollectionV2.html).
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 아이템 설정 업데이트
+
+Candy Machine의 아이템 설정도 업데이트할 수 있지만 몇 가지 제한 사항이 있습니다.
+
+- 아이템 설정은 **구성 라인 설정**과 **숨겨진 설정** 간에 모드를 교체하도록 업데이트할 수 없습니다. 그러나 모드를 교체하지 않는 경우 이러한 설정 내의 속성을 업데이트할 수 있습니다.
+- **구성 라인 설정**을 사용할 때:
+  - **사용 가능한 아이템** 속성은 업데이트할 수 없습니다.
+  - **이름 길이** 및 **URI 길이** 속성은 프로그램이 업데이트 중에 Candy Machine 계정의 크기를 조정하지 않으므로 더 작은 값으로만 업데이트할 수 있습니다.
+- 첫 번째 NFT가 민팅되면 이러한 설정은 더 이상 업데이트할 수 없습니다.
+
+{% dialect-switcher title="Candy Machine의 아이템 설정 업데이트" %}
+{% dialect title="JavaScript" id="js" %}
+
+다음 예시는 Umi 라이브러리를 사용하여 Candy Machine의 구성 라인 설정을 업데이트하는 방법을 보여줍니다. 동일한 작업을 숨겨진 설정과 사용 가능한 아이템 속성(숨겨진 설정 사용 시)에 대해서도 수행할 수 있습니다.
+
+```ts
+import {
+  updateCandyMachine,
+  fetchCandyMachine,
+} from '@metaplex-foundation/mpl-candy-machine'
+
+const candyMachine = await fetchCandyMachine(umi, candyMachineAddress)
+await updateCandyMachine(umi, {
+  candyMachine: candyMachine.publicKey,
+  data: {
+    ...candyMachine.data,
+    hiddenSettings: none(),
+    configLineSettings: some({
+      type: 'configLines',
+      prefixName: 'My New NFT #$ID+1$',
+      nameLength: 0,
+      prefixUri: 'https://arweave.net/',
+      uriLength: 43,
+      isSequential: true,
+    }),
+  },
+}).sendAndConfirm(umi)
+```
+
+API 참조: [updateCandyMachine](https://mpl-candy-machine.typedoc.metaplex.com/functions/updateCandyMachine.html).
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## Candy Machine 삭제
+
+Candy Machine이 완전히 민팅되면 목적을 달성했으므로 안전하게 폐기할 수 있습니다. 이를 통해 창작자는 Candy Machine 계정의 저장 비용과 선택적으로 Candy Guard 계정의 비용도 되돌려 받을 수 있습니다.
+
+{% dialect-switcher title="Candy Machine 삭제" %}
+{% dialect title="JavaScript" id="js" %}
+
+다음과 같이 Umi 라이브러리를 사용하여 Candy Machine 계정 및/또는 관련된 Candy Guard 계정을 삭제할 수 있습니다.
+
+```ts
+import {
+  deleteCandyMachine,
+  deleteCandyGuard,
+} from '@metaplex-foundation/mpl-candy-machine'
+
+await deleteCandyMachine(umi, {
+  candyMachine: candyMachine.publicKey,
+}).sendAndConfirm(umi)
+
+await deleteCandyGuard(umi, {
+  candyGuard: candyMachine.mintAuthority,
+}).sendAndConfirm(umi)
+```
+
+API 참조: [deleteCandyMachine](https://mpl-candy-machine.typedoc.metaplex.com/functions/deleteCandyMachine.html), [deleteCandyGuard](https://mpl-candy-machine.typedoc.metaplex.com/functions/deleteCandyGuard.html).
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 결론
+
+이제 Candy Machine을 생성, 읽기, 업데이트 및 삭제할 수 있지만 아직 아이템으로 로드하는 방법을 모릅니다. [다음 페이지](/kr/candy-machine/insert-items)에서 이를 다루어보겠습니다!

src/pages/kr/candy-machine/mint.md

@@ -0,0 +1,579 @@
+---
+title: 민팅
+metaTitle: 민팅 | Candy Machine
+description: Candy Machine에서 민팅하는 방법과 민팅 전 요구사항을 처리하는 방법을 설명합니다.
+---
+
+지금까지 Candy Machine을 생성하고 유지하는 방법을 배웠습니다. 설정하는 방법과 가드 및 가드 그룹을 사용하여 복잡한 민팅 워크플로를 설정하는 방법을 보았습니다. 이제 퍼즐의 마지막 조각인 민팅에 대해 이야기할 때입니다! {% .lead %}
+
+## 기본 민팅
+
+[Candy Guards 페이지](/kr/candy-machine/guards#why-another-program)에서 언급했듯이 Candy Machine에서 NFT를 민팅하는 데 책임이 있는 두 가지 프로그램이 있습니다: NFT 민팅을 담당하는 Candy Machine Core 프로그램과 그 위에 구성 가능한 액세스 제어 계층을 추가하고 커스텀 가드를 제공하기 위해 포크될 수 있는 Candy Guard 프로그램입니다.
+
+따라서 Candy Machine에서 민팅하는 두 가지 방법이 있습니다:
+
+- **Candy Guard 프로그램에서** 민팅을 Candy Machine Core 프로그램에 위임합니다. 대부분의 경우 훨씬 더 복잡한 민팅 워크플로를 허용하므로 이렇게 하고 싶을 것입니다. 계정에 구성된 가드에 따라 민팅 명령어에 추가 나머지 계정과 명령어 데이터를 전달해야 할 수 있습니다. 다행히 우리의 SDK는 몇 가지 추가 매개변수를 요구하고 나머지를 계산해 주어 이를 쉽게 만듭니다.
+
+- **Candy Machine Core 프로그램에서 직접**. 이 경우 구성된 민트 권한만 민팅할 수 있으므로 트랜잭션에 서명해야 합니다.
+
+{% diagram %}
+
+{% node %}
+{% node #candy-machine-1 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% node label="기능" /%}
+{% node label="권한" /%}
+{% node #mint-authority-1 %}
+
+민트 권한 = Candy Guard {% .font-semibold %}
+
+{% /node %}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine-1" y=160 x=20 %}
+{% node #candy-guard-1 label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node label="가드" theme="mint" z=1 /%}
+{% node label="Sol Payment" /%}
+{% node label="Token Payment" /%}
+{% node label="Start Date" /%}
+{% node label="End Date" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine-1" x=350 %}
+{% node #mint-1 label="민팅" theme="pink" /%}
+{% node label="Candy Guard Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-1" x=45 y=-20 label="액세스 제어" theme="transparent" /%}
+{% node parent="mint-1" x=-120 y=-35 theme="transparent" %}
+활성화된 가드를 준수하는 한 \
+누구나 민팅할 수 있습니다.
+{% /node %}
+
+{% node parent="mint-1" x=-22 y=100 %}
+{% node #mint-2 label="민팅" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-2" x=120 y=-20 label="민팅 로직" theme="transparent" /%}
+{% node parent="mint-2" x=200 y=-18 theme="transparent" %}
+Alice만 \
+민팅할 수 있습니다.
+{% /node %}
+
+{% node #nft parent="mint-2" x=62 y=100 label="NFT" /%}
+
+{% node parent="mint-2" x=280 %}
+{% node #candy-machine-2 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% node label="기능" /%}
+{% node label="권한" /%}
+{% node #mint-authority-2 %}
+
+민트 권한 = Alice {% .font-semibold %}
+
+{% /node %}
+{% node label="..." /%}
+{% /node %}
+
+{% edge from="candy-guard-1" to="mint-authority-1" fromPosition="left" toPosition="left" arrow=false dashed=true /%}
+{% edge from="mint-1" to="mint-2" theme="pink" path="straight" /%}
+{% edge from="mint-2" to="nft" theme="pink" path="straight" /%}
+{% edge from="candy-machine-1" to="mint-1" theme="pink" /%}
+{% edge from="candy-guard-1" to="mint-1" theme="pink" /%}
+{% edge from="candy-machine-2" to="mint-2" theme="pink" path="straight" /%}
+
+{% /diagram %}
+
+모든 것이 잘 진행되면 Candy Machine에 구성된 매개변수를 따라 NFT가 생성됩니다. 예를 들어, 주어진 Candy Machine이 **순차적**이 `false`로 설정된 **구성 라인 설정**을 사용하는 경우 다음 아이템을 무작위로 가져올 것입니다.
+
+Candy Guard 프로그램의 버전 `1.0`부터 민팅 명령어는 기존 `payer` 서명자와 다를 수 있는 추가 `minter` 서명자를 받아들입니다. 이를 통해 NFT를 민팅하는 지갑이 더 이상 SOL 수수료(저장 수수료 및 SOL 민팅 결제 등)를 지불할 필요가 없는 민팅 워크플로를 만들 수 있습니다. `payer` 서명자가 해당 수수료를 추상화하기 때문입니다. `minter` 서명자는 여전히 토큰 기반 수수료를 지불해야 하며 구성된 가드를 검증하는 데 사용됩니다.
+
+최신 민팅 명령어는 상당한 양의 컴퓨팅 유닛을 사용하는 최신 토큰 메타데이터 명령어에 의존한다는 점에 주목하세요. 따라서 트랜잭션이 성공하도록 하기 위해 트랜잭션의 컴퓨팅 유닛 한도를 늘려야 할 수 있습니다. 우리의 SDK도 이를 도울 수 있습니다.
+
+{% dialect-switcher title="Candy Machine에서 민팅" %}
+{% dialect title="JavaScript" id="js" %}
+
+구성된 Candy Guard 계정을 통해 Candy Machine에서 민팅하려면 `mintV2` 함수를 사용하고 민팅된 NFT가 속할 컬렉션 NFT의 민트 주소와 업데이트 권한을 제공할 수 있습니다. `minter` 서명자와 `payer` 서명자도 제공할 수 있지만 각각 Umi의 identity와 payer로 기본 설정됩니다.
+
+위에서 언급했듯이 `mintV2` 명령어가 성공하도록 하기 위해 트랜잭션의 컴퓨팅 유닛 한도를 늘려야 할 수 있습니다. 아래 코드 스니펫에서 설명한 대로 `mpl-toolbox` Umi 라이브러리의 `setComputeUnitLimit` 도우미 함수를 사용하여 이를 수행할 수 있습니다.
+
+pNFT를 민팅하고 싶고(예: 로열티 강제를 위해) Candy Machine을 그에 맞게 설정한 경우 `tokenStandard` 필드를 추가해야 합니다. 기본적으로 `NonFungible`이 사용됩니다. 이전에 Candy Machine을 가져온 경우 `candyMachine.tokenStandard`를 사용할 수 있고, 그렇지 않으면 `@metaplex-foundation/mpl-token-metadata`에서 `tokenStandard: TokenStandard.ProgrammableNonFungible`을 사용하여 직접 할당해야 합니다.
+
+```ts
+import { mintV2 } from '@metaplex-foundation/mpl-candy-machine'
+import { setComputeUnitLimit } from '@metaplex-foundation/mpl-toolbox'
+import { transactionBuilder, generateSigner } from '@metaplex-foundation/umi'
+
+const nftMint = generateSigner(umi)
+await transactionBuilder()
+  .add(setComputeUnitLimit(umi, { units: 800_000 }))
+  .add(
+    mintV2(umi, {
+      candyMachine: candyMachine.publicKey,
+      nftMint,
+      collectionMint: collectionNft.publicKey,
+      collectionUpdateAuthority: collectionNft.metadata.updateAuthority,
+      tokenStandard: candyMachine.tokenStandard,
+    })
+  )
+  .sendAndConfirm(umi)
+```
+
+`mintV2` 명령어는 기본적으로 민트 및 토큰 계정을 생성하고 NFT 소유자를 `minter`로 설정합니다. 미리 이를 직접 생성하고 싶다면 서명자 대신 NFT 민트 주소를 공개 키로 제공하면 됩니다. 다음은 `mpl-toolbox` Umi 라이브러리의 `createMintWithAssociatedToken` 함수를 사용한 예시입니다:
+
+```ts
+import { mintV2 } from '@metaplex-foundation/mpl-candy-machine'
+import {
+  createMintWithAssociatedToken,
+  setComputeUnitLimit,
+} from '@metaplex-foundation/mpl-toolbox'
+import { transactionBuilder, generateSigner } from '@metaplex-foundation/umi'
+
+const nftMint = generateSigner(umi)
+const nftOwner = generateSigner(umi).publicKey
+await transactionBuilder()
+  .add(setComputeUnitLimit(umi, { units: 800_000 }))
+  .add(createMintWithAssociatedToken(umi, { mint: nftMint, owner: nftOwner }))
+  .add(
+    mintV2(umi, {
+      candyMachine: candyMachine.publicKey,
+      nftMint: nftMint.publicKey,
+      collectionMint: collectionNft.publicKey,
+      collectionUpdateAuthority: collectionNft.metadata.updateAuthority,
+    })
+  )
+  .sendAndConfirm(umi)
+```
+
+Candy Machine Core 프로그램에서 직접 민팅하고 싶은 드문 경우에는 대신 `mintFromCandyMachineV2` 함수를 사용할 수 있습니다. 이 함수는 Candy Machine의 민트 권한을 서명자로 제공해야 하며 명시적인 `nftOwner` 속성을 허용합니다.
+
+```ts
+import { mintFromCandyMachineV2 } from '@metaplex-foundation/mpl-candy-machine'
+import { setComputeUnitLimit } from '@metaplex-foundation/mpl-toolbox'
+import { transactionBuilder, generateSigner } from '@metaplex-foundation/umi'
+
+const nftMint = generateSigner(umi)
+const nftOwner = generateSigner(umi).publicKey
+await transactionBuilder()
+  .add(setComputeUnitLimit(umi, { units: 800_000 }))
+  .add(
+    mintFromCandyMachineV2(umi, {
+      candyMachine: candyMachine.publicKey,
+      mintAuthority: umi.identity,
+      nftOwner,
+      nftMint,
+      collectionMint: collectionNft.publicKey,
+      collectionUpdateAuthority: collectionNft.metadata.updateAuthority,
+    })
+  )
+  .sendAndConfirm(umi)
+```
+
+API 참조: [mintV2](https://mpl-candy-machine.typedoc.metaplex.com/functions/mintV2.html), [mintFromCandyMachineV2](https://mpl-candy-machine.typedoc.metaplex.com/functions/mintFromCandyMachineV2.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 가드와 함께 민팅
+
+많은 가드를 사용하는 Candy Machine에서 민팅할 때 추가적인 가드별 정보를 제공해야 할 수 있습니다.
+
+민팅 명령어를 수동으로 구축하는 경우 해당 정보는 명령어 데이터와 나머지 계정의 혼합으로 제공됩니다. 그러나 우리의 SDK를 사용하면 민팅 시 추가 정보가 필요한 각 가드는 **민팅 설정**이라고 부르는 설정 세트를 정의합니다. 이러한 민팅 설정은 프로그램이 필요로 하는 모든 것으로 파싱됩니다.
+
+민팅 설정이 필요한 가드의 좋은 예는 **NFT Payment** 가드입니다. 이 가드는 민팅 비용으로 사용해야 하는 NFT의 민트 주소와 기타 정보를 필요로 합니다.
+
+{% diagram %}
+
+{% node %}
+{% node #candy-machine-1 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% /node %}
+
+{% node parent="candy-machine-1" y=80 x=20 %}
+{% node #candy-guard-1 label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node label="가드" theme="mint" z=1 /%}
+{% node #nft-payment-guard label="NFT Payment" /%}
+{% node label="Token Payment" /%}
+{% node label="Start Date" /%}
+{% node #third-party-signer-guard label="Third Party Signer" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine-1" x=700 %}
+{% node #mint-1 label="민팅" theme="pink" /%}
+{% node label="Candy Guard Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-1" x=45 y=-20 label="액세스 제어" theme="transparent" /%}
+
+{% node parent="mint-1" x=-22 y=100 %}
+{% node #mint-2 label="민팅" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-2" x=120 y=-20 label="민팅 로직" theme="transparent" /%}
+
+{% node #nft parent="mint-2" x=62 y=100 label="NFT" /%}
+
+{% node parent="mint-2" x=-400 %}
+{% node #mint-settings label="민팅 설정" /%}
+{% node label="SDK 사용" theme="dimmed" /%}
+{% /node %}
+
+{% node #mint-args label="민팅 인수" parent="mint-settings" x=100 y=80 theme="slate" /%}
+{% node #mint-accounts label="민팅 나머지 계정" parent="mint-args" y=50 theme="slate" /%}
+
+{% edge from="candy-guard-1" to="candy-machine-1" fromPosition="left" toPosition="left" arrow=false /%}
+{% edge from="mint-1" to="mint-2" theme="pink" path="straight" /%}
+{% edge from="mint-2" to="nft" theme="pink" path="straight" /%}
+{% edge from="candy-machine-1" to="mint-1" theme="pink" /%}
+{% edge from="nft-payment-guard" to="mint-settings" theme="slate" /%}
+{% edge from="third-party-signer-guard" to="mint-settings" theme="slate" /%}
+{% edge from="mint-settings" to="mint-args" theme="slate" fromPosition="bottom" /%}
+{% edge from="mint-settings" to="mint-accounts" theme="slate" fromPosition="bottom" /%}
+{% edge from="mint-args" to="mint-1" theme="pink" /%}
+{% edge from="mint-accounts" to="mint-1" theme="pink" /%}
+
+{% /diagram %}
+
+[사용 가능한 각 가드](/kr/candy-machine/guards)에는 자체 문서 페이지가 있으며 해당 가드가 민팅할 때 민팅 설정을 제공해야 하는지 여부를 알려줍니다.
+
+민팅 설정이 필요하지 않은 가드만 사용하는 경우 위의 "기본 민팅" 섹션에서 설명한 것과 같은 방식으로 민팅할 수 있습니다. 그렇지 않으면 필요한 모든 가드의 민팅 설정이 포함된 추가 객체 속성을 제공해야 합니다. SDK를 사용하여 실제로 어떻게 보이는지 살펴보겠습니다.
+
+{% dialect-switcher title="가드와 함께 Candy Machine에서 민팅" %}
+{% dialect title="JavaScript" id="js" %}
+
+Umi 라이브러리를 통해 민팅할 때 `mintArgs` 속성을 사용하여 필요한 **민팅 설정**을 제공할 수 있습니다.
+
+다음은 추가 서명자가 필요한 **Third Party Signer** 가드와 지갑이 Candy Machine에서 몇 번 민팅했는지 추적하는 **Mint Limit** 가드를 사용한 예시입니다.
+
+```ts
+import {
+  some,
+  generateSigner,
+  transactionBuilder,
+} from '@metaplex-foundation/umi'
+import { create, mintV2 } from '@metaplex-foundation/mpl-candy-machine'
+import { setComputeUnitLimit } from '@metaplex-foundation/mpl-toolbox'
+
+// 가드가 있는 Candy Machine 생성.
+const thirdPartySigner = generateSigner()
+await create(umi, {
+  // ...
+  guards: {
+    thirdPartySigner: some({ signer: thirdPartySigner.publicKey }),
+    mintLimit: some({ id: 1, limit: 3 }),
+  },
+}).sendAndConfirm(umi)
+
+// Candy Machine에서 민팅.
+const nftMint = generateSigner(umi)
+await transactionBuilder()
+  .add(setComputeUnitLimit(umi, { units: 800_000 }))
+  .add(
+    mintV2(umi, {
+      candyMachine: candyMachine.publicKey,
+      nftMint,
+      collectionMint: collectionNft.publicKey,
+      collectionUpdateAuthority: collectionNft.metadata.updateAuthority,
+      mintArgs: {
+        thirdPartySigner: some({ signer: thirdPartySigner }),
+        mintLimit: some({ id: 1 }),
+      },
+    })
+  )
+  .sendAndConfirm(umi)
+```
+
+API 참조: [mintV2](https://mpl-candy-machine.typedoc.metaplex.com/functions/mintV2.html), [DefaultGuardSetMintArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/DefaultGuardSetMintArgs.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 가드 그룹과 함께 민팅
+
+가드 그룹을 사용하는 Candy Machine에서 민팅할 때 **레이블을 제공하여 민팅하려는 그룹을 명시적으로 선택해야 합니다**.
+
+또한 [이전 섹션](#minting-with-guards)에서 설명한 대로 민팅 설정도 필요할 수 있습니다. 그러나 **민팅 설정은 선택된 그룹의 "해결된 가드"에 적용됩니다**.
+
+예를 들어 다음과 같은 가드가 있는 Candy Machine을 상상해보세요:
+
+- **기본 가드**:
+  - Bot Tax
+  - Third Party Signer
+  - Start Date
+- **그룹 1**
+  - 레이블: "nft"
+  - 가드:
+    - NFT Payment
+    - Start Date
+- **그룹 2**
+  - 레이블: "public"
+  - 가드:
+    - Sol Payment
+
+그룹 1("nft" 레이블)의 해결된 가드는:
+
+- Bot Tax: **기본 가드**에서.
+- Third Party Signer: **기본 가드**에서.
+- NFT Payment: **그룹 1**에서.
+- Start Date: **그룹 1**에서 (기본 가드를 재정의하므로).
+
+따라서 제공된 민팅 설정은 이러한 해결된 가드와 관련되어야 합니다. 위의 예시에서 Third Party Signer 가드와 NFT Payment 가드에 대한 민팅 설정을 제공해야 합니다.
+
+{% diagram %}
+
+{% node %}
+{% node #candy-machine-1 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% /node %}
+
+{% node parent="candy-machine-1" y=80 x=20 %}
+{% node #candy-guard-1 label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node label="가드 (기본 가드)" theme="mint" z=1 /%}
+{% node label="Bot Tax" /%}
+{% node #third-party-signer-guard label="Third Party Signer" /%}
+{% node label="Start Date" /%}
+{% node #nft-group theme="mint" z=1 %}
+그룹 1: "nft" {% .font-semibold %}
+{% /node %}
+{% node #nft-payment-guard label="NFT Payment" /%}
+{% node label="Start Date" /%}
+{% node theme="mint" z=1 %}
+그룹 2: "public"
+{% /node %}
+{% node label="SOL Payment" /%}
+{% /node %}
+
+{% node parent="candy-machine-1" x=700 %}
+{% node #mint-1 label="민팅" theme="pink" /%}
+{% node label="Candy Guard Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-1" x=45 y=-20 label="액세스 제어" theme="transparent" /%}
+
+{% node parent="mint-1" x=-22 y=100 %}
+{% node #mint-2 label="민팅" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-2" x=120 y=-20 label="민팅 로직" theme="transparent" /%}
+
+{% node #nft parent="mint-2" x=62 y=100 label="NFT" /%}
+
+{% node parent="mint-2" x=-400 y=60 %}
+{% node #mint-settings label="민팅 설정" /%}
+{% node label="SDK 사용" theme="dimmed" /%}
+{% /node %}
+
+{% node #mint-args label="민팅 인수" parent="mint-settings" x=100 y=80 theme="slate" /%}
+{% node #mint-accounts label="민팅 나머지 계정" parent="mint-args" y=50 theme="slate" /%}
+
+{% edge from="candy-guard-1" to="candy-machine-1" fromPosition="left" toPosition="left" arrow=false /%}
+{% edge from="mint-1" to="mint-2" theme="pink" path="straight" /%}
+{% edge from="mint-2" to="nft" theme="pink" path="straight" /%}
+{% edge from="candy-machine-1" to="mint-1" theme="pink" /%}
+{% edge from="nft-payment-guard" to="mint-settings" theme="slate" /%}
+{% edge from="third-party-signer-guard" to="mint-settings" theme="slate" /%}
+{% edge from="mint-settings" to="mint-args" theme="slate" fromPosition="bottom" /%}
+{% edge from="mint-settings" to="mint-accounts" theme="slate" fromPosition="bottom" /%}
+{% edge from="mint-args" to="mint-1" theme="pink" /%}
+{% edge from="mint-accounts" to="mint-1" theme="pink" /%}
+{% edge from="nft-group" to="mint-1" theme="pink" /%}
+
+{% /diagram %}
+
+{% seperator h="6" /%}
+
+{% dialect-switcher title="가드 그룹과 함께 Candy Machine에서 민팅" %}
+{% dialect title="JavaScript" id="js" %}
+
+가드 그룹을 사용하는 Candy Machine에서 민팅할 때 선택하려는 그룹의 레이블을 `group` 속성을 통해 제공해야 합니다.
+
+또한 해당 그룹의 해결된 가드에 대한 민팅 설정을 `mintArgs` 속성을 통해 제공할 수 있습니다.
+
+다음은 위에서 설명한 예시 Candy Machine에서 Umi 라이브러리를 사용하여 민팅하는 방법입니다.
+
+```ts
+// 가드가 있는 Candy Machine 생성.
+const thirdPartySigner = generateSigner()
+await create(umi, {
+  // ...
+  guards: {
+    botTax: some({ lamports: sol(0.001), lastInstruction: true }),
+    thirdPartySigner: some({ signer: thirdPartySigner.publicKey }),
+    startDate: some({ date: dateTime('2022-10-18T17:00:00Z') }),
+  },
+  groups: [
+    {
+      label: 'nft',
+      guards: {
+        nftPayment: some({ requiredCollection, destination: nftTreasury }),
+        startDate: some({ date: dateTime('2022-10-18T16:00:00Z') }),
+      },
+    },
+    {
+      label: 'public',
+      guards: {
+        solPayment: some({ lamports: sol(1), destination: solTreasury }),
+      },
+    },
+  ],
+}).sendAndConfirm(umi)
+
+// Candy Machine에서 민팅.
+const nftMint = generateSigner(umi)
+await transactionBuilder()
+  .add(setComputeUnitLimit(umi, { units: 800_000 }))
+  .add(
+    mintV2(umi, {
+      candyMachine: candyMachine.publicKey,
+      nftMint,
+      collectionMint: collectionNft.publicKey,
+      collectionUpdateAuthority: collectionNft.metadata.updateAuthority,
+      group: some('nft'),
+      mintArgs: {
+        thirdPartySigner: some({ signer: thirdPartySigner }),
+        nftPayment: some({
+          mint: nftFromRequiredCollection.publicKey,
+          destination: nftTreasury,
+          tokenStandard: TokenStandard.NonFungible,
+        }),
+      },
+    })
+  )
+  .sendAndConfirm(umi)
+```
+
+API 참조: [mintV2](https://mpl-candy-machine.typedoc.metaplex.com/functions/mintV2.html), [DefaultGuardSetMintArgs](https://mpl-candy-machine.typedoc.metaplex.com/types/DefaultGuardSetMintArgs.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 사전 검증과 함께 민팅
+
+일부 가드는 Candy Machine에서 민팅하기 전에 추가 검증 단계가 필요할 수 있다는 점이 중요합니다. 이 사전 검증 단계는 일반적으로 블록체인에 계정을 생성하거나 검증의 증거 역할을 하는 토큰으로 지갑에 보상합니다.
+
+### 라우트 명령어 사용
+
+가드가 사전 검증 단계를 요구할 수 있는 한 가지 방법은 "route" 명령어를 통해 [자체 특수 명령어](/kr/candy-machine/guard-route)를 사용하는 것입니다.
+
+좋은 예는 **Allow List** 가드입니다. 이 가드를 사용할 때 route 명령어를 호출하고 유효한 머클 증명을 제공하여 우리의 지갑이 사전 정의된 지갑 목록에 속한다는 것을 검증해야 합니다. 이 route 명령어가 성공하면 해당 지갑에 대한 Allow List PDA가 생성되며, 민팅 명령어가 이를 읽어 Allow List 가드를 검증할 수 있습니다. [Allow List 가드에 대한 자세한 내용은 전용 페이지를 참조하세요](/kr/candy-machine/guards/allow-list).
+
+{% diagram %}
+
+{% node %}
+{% node #candy-machine-1 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% /node %}
+
+{% node parent="candy-machine-1" y=80 x=20 %}
+{% node #candy-guard-1 label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node label="가드" theme="mint" z=1 /%}
+{% node #allow-list-guard label="Allow List" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine-1" x=550 %}
+{% node #mint-1 label="민팅" theme="pink" /%}
+{% node label="Candy Guard Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-1" x=45 y=-20 label="액세스 제어" theme="transparent" /%}
+
+{% node parent="mint-1" x=-22 y=100 %}
+{% node #mint-2 label="민팅" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-2" x=120 y=-20 label="민팅 로직" theme="transparent" /%}
+
+{% node #nft parent="mint-2" x=62 y=100 label="NFT" /%}
+
+{% node parent="mint-2" x=-250 %}
+{% node #route label="라우트" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="route" x=70 y=-20 label="머클 증명 검증" theme="transparent" /%}
+
+{% node #allow-list-pda parent="route" x=23 y=100 label="Allow List PDA" /%}
+
+{% edge from="candy-guard-1" to="candy-machine-1" fromPosition="left" toPosition="left" arrow=false /%}
+{% edge from="mint-1" to="mint-2" theme="pink" path="straight" /%}
+{% edge from="mint-2" to="nft" theme="pink" path="straight" /%}
+{% edge from="candy-machine-1" to="mint-1" theme="pink" /%}
+{% edge from="allow-list-guard" to="route" theme="pink" /%}
+{% edge from="route" to="allow-list-pda" theme="pink" path="straight" /%}
+{% edge from="allow-list-pda" to="mint-1" theme="pink" /%}
+
+{% /diagram %}
+
+### 외부 서비스 사용
+
+가드가 해당 사전 검증 단계를 수행할 수 있는 또 다른 방법은 외부 솔루션에 의존하는 것입니다.
+
+예를 들어 **Gatekeeper** 가드를 사용할 때 구성된 게이트키퍼 네트워크에 따라 Captcha 완료와 같은 도전을 수행하여 게이트웨이 토큰을 요청해야 합니다. 그러면 Gatekeeper 가드는 해당 게이트웨이 토큰의 존재를 확인하여 민팅을 검증하거나 거부합니다. [Gatekeeper 가드에 대한 자세한 내용은 전용 페이지를 참조하세요](/kr/candy-machine/guards/gatekeeper).
+
+{% diagram %}
+
+{% node %}
+{% node #candy-machine-1 label="Candy Machine" theme="blue" /%}
+{% node label="소유자: Candy Machine Core Program" theme="dimmed" /%}
+{% /node %}
+
+{% node parent="candy-machine-1" y=80 x=20 %}
+{% node #candy-guard-1 label="Candy Guard" theme="blue" /%}
+{% node label="소유자: Candy Guard Program" theme="dimmed" /%}
+{% node label="가드" theme="mint" z=1 /%}
+{% node #gatekeeper-guard label="Gatekeeper" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% node parent="candy-machine-1" x=550 %}
+{% node #mint-1 label="민팅" theme="pink" /%}
+{% node label="Candy Guard Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-1" x=45 y=-20 label="액세스 제어" theme="transparent" /%}
+
+{% node parent="mint-1" x=-22 y=100 %}
+{% node #mint-2 label="민팅" theme="pink" /%}
+{% node label="Candy Machine Core Program" theme="pink" /%}
+{% /node %}
+{% node parent="mint-2" x=120 y=-20 label="민팅 로직" theme="transparent" /%}
+
+{% node #nft parent="mint-2" x=62 y=100 label="NFT" /%}
+
+{% node parent="mint-2" x=-250 y=-40 %}
+{% node #network label="게이트키퍼 네트워크" theme="slate" /%}
+{% node theme="slate" %}
+게이트키퍼 네트워크에서 \
+게이트웨이 토큰 요청, \
+예: Captcha.
+{% /node %}
+{% /node %}
+
+{% node #gateway-token parent="network" x=23 y=140 label="게이트웨이 토큰" /%}
+
+{% edge from="candy-guard-1" to="candy-machine-1" fromPosition="left" toPosition="left" arrow=false /%}
+{% edge from="mint-1" to="mint-2" theme="pink" path="straight" /%}
+{% edge from="mint-2" to="nft" theme="pink" path="straight" /%}
+{% edge from="candy-machine-1" to="mint-1" theme="pink" /%}
+{% edge from="gatekeeper-guard" to="network" theme="slate" /%}
+{% edge from="network" to="gateway-token" theme="slate" path="straight" /%}
+{% edge from="gateway-token" to="mint-1" theme="pink" /%}
+
+{% /diagram %}
+
+## 봇 세금과 함께 민팅
+
+Candy Machine에 포함하고 싶어할 가능성이 높은 가드 중 하나는 실패한 민팅에 구성 가능한 SOL 금액을 청구하여 봇으로부터 Candy Machine을 보호하는 Bot Tax 가드입니다. 이 금액은 일반적으로 실제 사용자의 진정한 실수에는 영향을 주지 않으면서 봇을 해치기 위해 작게 설정됩니다. 모든 봇 세금은 Candy Machine 계정으로 전송되므로 민팅이 끝나면 Candy Machine 계정을 삭제하여 이 자금에 액세스할 수 있습니다.
+
+이 가드는 조금 특별하며 다른 모든 가드의 민팅 동작에 영향을 줍니다. Bot Tax가 활성화되고 다른 가드가 민팅 검증에 실패하면 **트랜잭션이 성공한 것처럼 가장합니다**. 즉, 프로그램에서 오류가 반환되지 않지만 NFT도 민팅되지 않습니다. 이는 자금이 봇에서 Candy Machine 계정으로 전송되려면 트랜잭션이 성공해야 하기 때문입니다. [Bot Tax 가드에 대한 자세한 내용은 전용 페이지를 참조하세요](/kr/candy-machine/guards/bot-tax).
+
+## 결론
+
+축하합니다! 이제 Candy Machine이 A부터 Z까지 어떻게 작동하는지 알게 되었습니다!
+
+관심이 있을 수 있는 추가 읽기 자료는 다음과 같습니다:
+
+- [사용 가능한 모든 가드](/kr/candy-machine/guards): 사용할 수 있는 모든 가드를 살펴보고 필요한 것을 선별하세요.
+- [첫 번째 Candy Machine 만들기](/kr/candy-machine/guides/create-an-nft-collection-on-solana-with-candy-machine): 이 가이드는 자산을 업로드하고 "[Sugar](/kr/candy-machine/sugar)"라는 CLI 도구를 사용하여 처음부터 새로운 Candy Machine을 만드는 데 도움을 줍니다.

src/pages/kr/candy-machine/pnfts.md

@@ -0,0 +1,138 @@
+---
+title: 프로그래밍 가능한 NFT
+metaTitle: 프로그래밍 가능한 NFT | Candy Machine
+description: candy machine에서 프로그래밍 가능한 NFT를 민팅하는 방법을 설명합니다.
+---
+
+Token Metadata의 버전 `1.7`에서 [프로그래밍 가능한 NFT라고 불리는 새로운 에셋 클래스](/kr/token-metadata/pnfts)가 도입되어 다른 기능들 중에서도 창작자가 2차 판매에 대한 로열티를 강제할 수 있게 되었습니다.
+
+Candy Machine Core의 버전 `1.0`과 Candy Guard의 버전 `1.0`부터 **candy machine에서 프로그래밍 가능한 NFT를 민팅**할 수 있게 되었고 기존 candy machine의 토큰 표준을 업데이트하는 것도 가능해졌습니다.
+
+## 새로운 candy machine의 경우
+
+`initializeV2`라는 새로운 명령어가 Candy Machine Core 프로그램에 추가되었습니다. 이 명령어는 `initialize` 명령어와 유사하지만 candy machine에 사용할 토큰 표준을 지정할 수 있습니다. 이 명령어는 토큰 표준을 저장하지 않는 `V1` Candy Machine과 구별하기 위해 새로 생성된 Candy Machine을 `V2`로 표시합니다. 이러한 새로운 필드들은 Candy Machine 직렬화 로직에서 중단 변경을 피하기 위해 Candy Machine 계정 데이터의 기존 패딩을 사용합니다.
+
+`initializeV2` 명령어는 일반 NFT를 민팅하는 Candy Machine을 생성하는 데에도 사용할 수 있으므로 `initialize` 명령어는 이제 더 이상 사용되지 않습니다. NFT를 민팅할 때 Candy Machine Core에 위임하므로 여기서는 Candy Guard 프로그램에 대한 변경이 필요하지 않음을 참고하세요.
+
+또한 선택하는 토큰 표준에 따라 일부 선택적 계정이 필요할 수 있음을 참고하세요. 예를 들어, 모든 민팅된 프로그래밍 가능한 NFT에 특정 규칙 집합을 할당하기 위해 `ruleSet` 계정을 제공할 수 있습니다. `ruleSet` 계정이 제공되지 않으면 컬렉션 NFT의 규칙 집합이 있는 경우 이를 사용합니다. 그렇지 않으면 민팅된 프로그래밍 가능한 NFT에는 할당된 규칙 집합이 없습니다. 반면에 일반 NFT를 민팅할 때는 `ruleSet` 계정이 무시됩니다.
+
+추가적으로, `collectionDelegateRecord` 계정은 이제 Token Metadata의 새로운 [Metadata Delegate Record](https://docs.rs/mpl-token-metadata/latest/mpl_token_metadata/accounts/struct.MetadataDelegateRecord.html)를 참조해야 합니다.
+
+자세한 내용은 이 문서의 "[Candy Machine 생성](/kr/candy-machine/manage#create-candy-machines)" 섹션을 읽어보실 수 있지만, 프로그래밍 가능한 NFT를 민팅하는 새로운 Candy Machine을 생성하기 위해 SDK를 사용하는 방법에 대한 몇 가지 예시가 있습니다.
+
+{% dialect-switcher title="새로운 PNFT Candy Machine 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { TokenStandard } from '@metaplex-foundation/mpl-token-metadata'
+import { create } from '@metaplex-foundation/mpl-candy-machine'
+import { generateSigner } from '@metaplex-foundation/umi'
+
+await create(umi, {
+  // ...
+  tokenStandard: TokenStandard.ProgrammableNonFungible,
+}).sendAndConfirm(umi)
+```
+
+API 참조: [create](https://mpl-candy-machine.typedoc.metaplex.com/functions/create.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 기존 candy machine의 경우
+
+새로운 `setTokenStandard` 명령어를 통해 기존 Candy Machine의 토큰 표준을 업데이트하는 것이 가능합니다. Candy Machine `V1`에서 이 명령어를 호출하면 Candy Machine을 `V2`로 업그레이드하고 토큰 표준을 계정 데이터에 저장합니다.
+
+자세한 내용은 이 문서의 "[토큰 표준 업데이트](/kr/candy-machine/manage#update-token-standard)" 섹션을 읽어보실 수 있지만, 기존 Candy Machine의 토큰 표준을 프로그래밍 가능한 NFT로 업데이트하기 위해 SDK를 사용하는 방법에 대한 몇 가지 예시가 있습니다.
+
+{% dialect-switcher title="Candy Machine의 토큰 표준 변경" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { TokenStandard } from '@metaplex-foundation/mpl-token-metadata'
+import { setTokenStandard } from '@metaplex-foundation/mpl-candy-machine'
+
+await setTokenStandard(umi, {
+  candyMachine: candyMachine.publicKey,
+  collectionMint: candyMachine.collectionMint,
+  collectionUpdateAuthority,
+  tokenStandard: TokenStandard.ProgrammableNonFungible,
+}).sendAndConfirm(umi)
+```
+
+API 참조: [setTokenStandard](https://mpl-candy-machine.typedoc.metaplex.com/functions/setTokenStandard.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+추가로, 프로그래밍 가능한 NFT와 호환되는 컬렉션 설정을 지원하기 위해 새로운 `setCollectionV2` 명령어가 추가되었습니다. 이 명령어는 일반 NFT와도 작동하며 `setCollection` 명령어를 대체합니다.
+
+여기서도 이 문서의 "[컬렉션 업데이트](/kr/candy-machine/manage#update-collection)" 섹션에서 더 자세히 읽어볼 수 있습니다.
+
+{% dialect-switcher title="Candy Machine의 컬렉션 업데이트" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { setCollectionV2 } from '@metaplex-foundation/mpl-candy-machine'
+
+await setCollectionV2(umi, {
+  candyMachine: candyMachine.publicKey,
+  collectionMint: candyMachine.collectionMint,
+  collectionUpdateAuthority: collectionUpdateAuthority.publicKey,
+  newCollectionMint: newCollectionMint.publicKey,
+  newCollectionUpdateAuthority,
+}).sendAndConfirm(umi)
+```
+
+API 참조: [setCollectionV2](https://mpl-candy-machine.typedoc.metaplex.com/functions/setCollectionV2.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 새로운 민팅 명령어
+
+Candy Machine Core와 Candy Guard 프로그램 모두의 `mint` 명령어가 프로그래밍 가능한 NFT 민팅을 지원하도록 업데이트되었습니다. 이 새로운 명령어는 `mintV2`라고 불리며 `mint` 명령어와 유사하지만 추가 계정들이 전달되어야 합니다. 여기서도 새로운 `mintV2` 명령어는 일반 NFT를 민팅하는 데 사용할 수 있으므로 기존 `mint` 명령어들을 대체합니다.
+
+전체 "[민팅](/kr/candy-machine/mint)" 페이지가 새로운 `mintV2` 명령어를 사용하도록 업데이트되었지만 프로그래밍 가능한 NFT와 함께 사용하는 방법에 대한 간단한 예시가 있습니다.
+
+{% dialect-switcher title="Candy Machine에서 민팅" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { mintV2 } from '@metaplex-foundation/mpl-candy-machine'
+import { setComputeUnitLimit } from '@metaplex-foundation/mpl-toolbox'
+import { transactionBuilder, generateSigner } from '@metaplex-foundation/umi'
+
+const nftMint = generateSigner(umi)
+await transactionBuilder()
+  .add(setComputeUnitLimit(umi, { units: 800_000 }))
+  .add(
+    mintV2(umi, {
+      candyMachine: candyMachine.publicKey,
+      nftMint,
+      collectionMint: collectionNft.publicKey,
+      collectionUpdateAuthority: collectionNft.metadata.updateAuthority,
+    })
+  )
+  .sendAndConfirm(umi)
+```
+
+API 참조: [mintV2](https://mpl-candy-machine.typedoc.metaplex.com/functions/mintV2.html)
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+Candy Guard 프로그램에서 제공하는 일부 가드도 프로그래밍 가능한 NFT를 지원하도록 업데이트되었음을 참고하세요. 업데이트가 일반 NFT를 민팅할 때 중단 변경을 도입하지는 않지만, 토큰 표준에 따라 민팅할 때 더 많은 나머지 계정을 기대할 수 있습니다.
+
+이러한 변경 사항의 영향을 받는 가드들은:
+
+- `nftBurn`과 `nftPayment` 가드는 이제 소각/전송되는 NFT가 프로그래밍 가능한 NFT일 수 있습니다.
+- `FreezeSolPayment`와 `FreezeTokenPayment` 가드. 프로그래밍 가능한 NFT는 정의상 항상 동결되어 있으므로, Utility delegate를 통해 민팅될 때 잠금(Locked)되고 해동 조건이 충족되면 잠금 해제(Unlocked)됩니다.
+
+## 추가 자료
+
+프로그래밍 가능한 NFT와 Candy Machine에 대한 다음 리소스들이 유용할 수 있습니다:
+
+- [프로그래밍 가능한 NFT 가이드](/kr/token-metadata/pnfts)
+- [Candy Machine Core Program](https://github.com/metaplex-foundation/mpl-candy-machine/tree/main/programs/candy-machine-core)
+- [Candy Guard Program](https://github.com/metaplex-foundation/mpl-candy-machine/tree/main/programs/candy-guard)

src/pages/kr/candy-machine/references/index.md

@@ -0,0 +1,11 @@
+---
+title: API 참조
+metaTitle: API 참조 | Candy Machine
+description: Metaplex의 Candy Machine 제품에 대한 참조 및 코드 스니펫입니다.
+---
+
+- 📦 JavaScript:
+    * [Candy Machine](https://mpl-candy-machine.typedoc.metaplex.com/)
+- 🦀 Rust 프로그램:
+    * [Candy Machine Core](https://docs.rs/mpl-candy-machine-core/0.1.0/mpl_candy_machine_core/)
+    * [Candy Guard](https://docs.rs/mpl-candy-guard/0.1.0/mpl_candy_guard/)

src/pages/kr/candy-machine/settings.md

@@ -0,0 +1,302 @@
+---
+title: Candy Machine 설정
+metaTitle: 설정 | Candy Machine
+description: Candy Machine 설정에 대해 자세히 설명합니다.
+---
+
+이 페이지에서는 Candy Machine에서 사용할 수 있는 모든 설정을 자세히 살펴보겠습니다. 가드로 알려진 민팅 프로세스에 영향을 주는 설정보다는 Candy Machine 자체와 생성되는 NFT에 영향을 주는 설정에 집중하겠습니다. 후자는 전용 페이지에서 다루겠습니다. {% .lead %}
+
+## 권한
+
+Solana에서 계정을 생성할 때 가장 중요한 정보 중 하나는 계정을 관리할 수 있는 지갑으로, 이를 **권한**이라고 합니다. 따라서 새로운 Candy Machine을 생성할 때는 나중에 업데이트, 아이템 삽입, 삭제 등을 할 수 있는 권한의 주소를 제공해야 합니다.
+
+민팅 프로세스를 위한 추가 권한인 **민트 권한**이 있습니다. Candy Machine이 Candy Guard 없이 생성되면 이 권한이 Candy Machine에서 민팅할 수 있는 유일한 지갑입니다. 다른 누구도 민팅할 수 없습니다. 그러나 실제로는 이 민트 권한이 **가드**로 알려진 사전 구성된 규칙 세트를 기반으로 민팅 프로세스를 제어하는 Candy Guard의 주소로 설정됩니다.
+
+중요한 점은 SDK를 사용할 때 Candy Machine이 기본적으로 관련된 Candy Guard와 함께 항상 생성되므로 이 민트 권한에 대해 걱정할 필요가 없다는 것입니다.
+
+{% dialect-switcher title="권한 설정" %}
+{% dialect title="JavaScript" id="js" %}
+
+새로운 Candy Machine을 생성할 때 권한은 기본적으로 Umi identity로 설정됩니다. `authority` 속성에 유효한 서명자를 제공하여 이 권한을 명시적으로 설정할 수 있습니다.
+
+```tsx
+import { generateSigner } from '@metaplex-foundation/umi'
+
+const myCustomAuthority = generateSigner(umi)
+const candyMachineSettings = {
+  authority: myCustomAuthority,
+}
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 모든 NFT가 공유하는 설정
+
+Candy Machine 설정의 큰 부분은 해당 Candy Machine에서 민팅될 NFT를 정의하는 데 사용됩니다. 이는 많은 NFT 속성이 모든 민팅된 NFT에 대해 동일하기 때문입니다. 따라서 Candy Machine에 아이템을 로드할 때마다 이러한 속성을 반복해야 하는 대신 Candy Machine 설정에서 한 번 설정합니다.
+
+민팅된 NFT를 서로 구별할 수 있는 유일한 속성은 NFT의 **이름**과 JSON 메타데이터를 가리키는 **URI**라는 점에 주목하세요. 자세한 내용은 [아이템 삽입](/kr/candy-machine/insert-items)을 참조하세요.
+
+다음은 모든 민팅된 NFT 간에 공유되는 속성 목록입니다.
+
+- **판매자 수수료 베이시스 포인트**: 민팅된 NFT에 설정되어야 하는 2차 판매 로열티를 베이시스 포인트로 표시. 예를 들어 `250`은 `2.50%` 로열티를 의미합니다.
+- **심볼**: 민팅된 NFT에 사용할 심볼 — 예: "MYPROJECT". 이는 최대 10자까지의 텍스트가 될 수 있으며 빈 텍스트를 제공하여 선택 사항으로 만들 수 있습니다.
+- **최대 에디션 공급량**: 민팅된 NFT에서 인쇄할 수 있는 최대 에디션 수. 대부분의 사용 사례에서는 민팅된 NFT가 여러 번 인쇄되는 것을 방지하기 위해 이를 `0`으로 설정하려고 할 것입니다. 이를 `null`로 설정할 수 없다는 점에 주목하세요. 즉, Candy Machine에서는 무제한 에디션이 지원되지 않습니다.
+- **변경 가능**: 민팅된 NFT가 변경 가능해야 하는지 여부. 특별한 이유가 없다면 이를 `true`로 설정하는 것을 권장합니다. 나중에 NFT를 불변으로 만들 수는 있지만 불변 NFT를 다시 변경 가능하게 만들 수는 없습니다.
+- **창작자**: 민팅된 NFT에 설정되어야 하는 창작자 목록. 여기에는 주소와 로열티의 백분율 지분이 포함됩니다 — 즉, `5`는 `5%`입니다. Candy Machine 주소는 항상 모든 민팅된 NFT의 첫 번째 창작자로 설정되고 자동으로 검증됩니다. 이를 통해 누구나 NFT가 신뢰할 수 있는 Candy Machine에서 민팅되었음을 확인할 수 있습니다. 제공된 다른 모든 창작자는 그 이후에 설정되며 해당 창작자가 수동으로 검증해야 합니다.
+- **토큰 표준**: 민팅된 NFT에 사용할 [토큰 표준](/kr/token-metadata/token-standard). 지금까지 두 가지 토큰 표준만 지원됩니다: "[NonFungible](/kr/token-metadata/token-standard#the-non-fungible-standard)" 및 "[ProgrammableNonFungible](/kr/token-metadata/token-standard#the-programmable-non-fungible-standard)". 이는 _계정 버전_이 2 이상인 Candy Machine에서만 사용할 수 있습니다.
+- **규칙 세트**: Candy Machine이 "ProgrammableNonFungible" 토큰 표준을 사용하는 경우, 모든 민팅된 프로그래머블 NFT에 할당될 명시적 규칙 세트를 제공할 수 있습니다. 규칙 세트가 제공되지 않으면 컬렉션 NFT의 규칙 세트를 기본으로 사용합니다(있는 경우). 그렇지 않으면 프로그래머블 NFT는 규칙 세트 없이 민팅됩니다. 이는 _계정 버전_이 2 이상인 Candy Machine에서만 사용할 수 있습니다.
+
+{% dialect-switcher title="공유 NFT 설정" %}
+{% dialect title="JavaScript" id="js" %}
+
+위에 나열된 속성 중 `sellerFeeBasisPoints`, `creators`, `tokenStandard` 속성만 필수입니다. 다른 속성들은 다음과 같은 기본값을 가집니다:
+
+- `symbol`은 빈 문자열로 기본 설정됩니다 — 즉, 민팅된 NFT는 심볼을 사용하지 않습니다.
+- `maxEditionSupply`는 0으로 기본 설정됩니다 — 즉, 민팅된 NFT는 인쇄할 수 없습니다.
+- `isMutable`은 `true`로 기본 설정됩니다.
+
+다음과 같이 이러한 속성을 명시적으로 제공할 수 있습니다.
+
+```tsx
+import { percentAmount, generateSigner, some } from '@metaplex-foundation/umi'
+import { TokenStandard } from '@metaplex-foundation/mpl-token-metadata'
+
+const creatorA = generateSigner(umi).publicKey
+const creatorB = generateSigner(umi).publicKey
+const candyMachineSettings = {
+  tokenStandard: TokenStandard.NonFungible,
+  sellerFeeBasisPoints: percentAmount(33.3, 2),
+  symbol: 'MYPROJECT',
+  maxEditionSupply: 0,
+  isMutable: true,
+  creators: [
+    { address: creatorA, percentageShare: 50, verified: false },
+    { address: creatorB, percentageShare: 50, verified: false },
+  ],
+}
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## Metaplex 인증 컬렉션
+
+각 Candy Machine은 [Metaplex 인증 컬렉션(MCC)](/kr/token-metadata/collections)으로 알려진 특별한 NFT와 연결되어야 합니다. 이 **컬렉션 NFT**는 민팅된 NFT를 함께 그룹화하고 해당 정보가 온체인에서 검증될 수 있도록 합니다.
+
+다른 사람이 자신의 Candy Machine에서 귀하의 컬렉션 NFT를 사용할 수 없도록 하기 위해 **컬렉션의 업데이트 권한**이 Candy Machine의 컬렉션을 변경하는 모든 트랜잭션에 서명해야 합니다. 결과적으로 Candy Machine은 모든 민팅된 NFT의 컬렉션을 자동으로 안전하게 검증할 수 있습니다.
+
+{% dialect-switcher title="컬렉션 NFT 설정" %}
+{% dialect title="JavaScript" id="js" %}
+
+새로운 Candy Machine을 생성하거나 컬렉션 NFT를 업데이트할 때 다음 속성을 제공해야 합니다:
+
+- `collectionMint`: 컬렉션 NFT의 민트 계정 주소.
+- `collectionUpdateAuthority`: 서명자로서의 컬렉션 NFT의 업데이트 권한.
+
+다음은 예시입니다.
+
+```tsx
+import { generateSigner, percentAmount } from '@metaplex-foundation/umi'
+import { createNft } from '@metaplex-foundation/mpl-token-metadata'
+
+// 컬렉션 NFT 생성.
+const collectionUpdateAuthority = generateSigner(umi)
+const collectionMint = generateSigner(umi)
+await createNft(umi, {
+  mint: collectionMint,
+  authority: collectionUpdateAuthority,
+  name: 'My Collection NFT',
+  uri: 'https://example.com/path/to/some/json/metadata.json',
+  sellerFeeBasisPoints: percentAmount(9.99, 2), // 9.99%
+  isCollection: true,
+    collectionDetails: {
+    __kind: 'V1',
+    size: 0,
+  },
+}).sendAndConfirm(umi)
+
+// 설정에 컬렉션 주소와 권한 전달.
+const candyMachineSettings = {
+  collectionMint: collectionMint.publicKey,
+  collectionUpdateAuthority,
+}
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 아이템 설정
+
+Candy Machine 설정에는 내부에 로드되어 있거나 로드될 아이템에 관한 정보도 포함되어 있습니다. **사용 가능한 아이템** 속성이 이 범주에 속하며 Candy Machine에서 민팅될 NFT의 최대 수를 저장합니다.
+
+{% dialect-switcher title="아이템 수 설정" %}
+{% dialect title="JavaScript" id="js" %}
+
+새로운 Candy Machine을 생성할 때 `itemsAvailable` 속성은 필수이며 큰 정수의 경우 숫자 또는 네이티브 `bigint`일 수 있습니다.
+
+```tsx
+const candyMachineSettings = {
+  itemsAvailable: 500,
+}
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+**사용 가능한 아이템** 속성 외에도 아이템이 Candy Machine에 로드되는 방법을 정의하는 두 가지 다른 속성이 있습니다. 이러한 속성 중 정확히 하나를 선택하고 다른 하나는 비워두어야 합니다. 이러한 속성은:
+
+- **구성 라인 설정**.
+- **숨겨진 설정**.
+
+Candy Machine이 이 두 모드 중 하나를 사용하여 생성되면 다른 모드를 사용하도록 업데이트할 수 없다는 점에 주목하세요. 또한 **구성 라인 설정**이 사용되면 더 이상 **사용 가능한 아이템** 속성을 업데이트할 수 없습니다.
+
+두 가지 모두에 대해 좀 더 자세히 살펴보겠습니다.
+
+{% callout type="note" title="무작위성" %}
+
+자산의 "무작위" 민팅 프로세스가 완전히 예측할 수 없는 것은 아니며 충분한 리소스와 악의적인 의도로 영향을 받을 수 있으므로 공개 메커니즘을 위해 [숨겨진 설정](#hidden-settings)을 활용하는 것이 바람직할 수 있습니다.
+
+{% /callout %}
+
+### 구성 라인 설정
+
+**구성 라인 설정** 속성을 사용하면 Candy Machine 내부에 있거나 삽입될 아이템을 설명할 수 있습니다. 아이템의 **이름**과 **URI**에 대한 정확한 길이를 제공하고 해당 길이를 줄이기 위해 일부 공유 접두사를 제공하여 Candy Machine의 크기를 최소로 유지할 수 있습니다. **구성 라인 설정** 속성은 다음 속성을 포함하는 객체입니다:
+
+- **이름 접두사**: 모든 삽입된 아이템이 공유하는 이름 접두사. 이 접두사는 최대 32자를 가질 수 있습니다.
+- **이름 길이**: 이름 접두사를 제외한 각 삽입된 아이템의 이름에 대한 최대 길이.
+- **URI 접두사**: 모든 삽입된 아이템이 공유하는 URI 접두사. 이 접두사는 최대 200자를 가질 수 있습니다.
+- **URI 길이**: URI 접두사를 제외한 각 삽입된 아이템의 URI에 대한 최대 길이.
+- **순차적**: NFT를 순차적으로 — `true` — 또는 무작위 순서로 — `false` — 민팅할지 여부를 나타냅니다. 구매자가 다음에 어떤 NFT가 민팅될지 예측하는 것을 방지하기 위해 이를 `false`로 설정하는 것을 권장합니다. SDK는 새로운 Candy Machine을 생성할 때 순차적을 `false`로 설정한 구성 라인 설정을 기본으로 사용합니다.
+
+이러한 **이름**과 **URI** 속성을 더 잘 이해하기 위해 예시를 살펴보겠습니다. 다음과 같은 특성을 가진 Candy Machine을 생성하려고 한다고 가정해보겠습니다:
+
+- `1000`개의 아이템을 포함합니다.
+- 각 아이템의 이름은 "My NFT Project #X"이며, 여기서 X는 1부터 시작하는 아이템의 인덱스입니다.
+- 각 아이템의 JSON 메타데이터는 Arweave에 업로드되었으므로 URI는 "https://arweave.net/"로 시작하고 최대 43자 길이의 고유 식별자로 끝납니다.
+
+이 예시에서 접두사 없이는 다음과 같이 됩니다:
+
+- 이름 길이 = 20. "My NFT Project #"에 16자, 가장 큰 숫자인 "1000"에 4자.
+- URI 길이 = 63. "https://arweave.net/"에 20자, 고유 식별자에 43자.
+
+1000개의 아이템을 삽입할 때 아이템을 저장하는 데만 총 83,000자가 필요합니다. 그러나 접두사를 사용하면 Candy Machine을 생성하는 데 필요한 공간과 따라서 블록체인에서 생성하는 비용을 크게 줄일 수 있습니다.
+
+- 이름 접두사 = "My NFT Project #"
+- 이름 길이 = 4
+- URI 접두사 = "https://arweave.net/"
+- URI 길이 = 43
+
+1000개의 아이템으로 이제 아이템을 저장하는 데 47,000자만 필요합니다.
+
+하지만 그게 전부가 아닙니다! 이름 또는 URI 접두사 내에서 **두 개의 특수 변수**를 사용하여 크기를 더욱 줄일 수 있습니다. 이러한 변수는:
+
+- `$ID$`: 0부터 시작하는 아이템의 인덱스로 교체됩니다.
+- `$ID+1$`: 1부터 시작하는 아이템의 인덱스로 교체됩니다.
+
+위의 예시에서 이름 접두사에 `$ID+1$` 변수를 활용하여 모든 아이템에 삽입할 필요가 없도록 할 수 있습니다. 다음과 같은 구성 라인 설정이 됩니다:
+
+- 이름 접두사 = "My NFT Project #$ID+1$"
+- 이름 길이 = 0
+- URI 접두사 = "https://arweave.net/"
+- URI 길이 = 43
+
+맞습니다, **이름 길이가 이제 0**이고 필요한 문자를 43,000자로 줄였습니다.
+
+{% dialect-switcher title="구성 라인 설정" %}
+{% dialect title="JavaScript" id="js" %}
+
+Umi를 사용할 때 `some` 및 `none` 도우미 함수를 사용하여 라이브러리에 `configLineSettings` 및 `hiddenSettings` 속성을 통해 구성 라인 설정 또는 숨겨진 설정을 사용할지 여부를 알릴 수 있습니다. 이러한 설정 중 하나만 사용해야 하므로 하나는 구성되고 다른 하나는 `none()`으로 설정되어야 합니다.
+
+다음은 Umi 라이브러리를 사용하여 위의 예시를 설정하는 방법을 보여주는 코드 스니펫입니다.
+
+```tsx
+import { some, none } from '@metaplex-foundation/umi'
+
+const candyMachineSettings = {
+  hiddenSettings: none(),
+  configLineSettings: some({
+    prefixName: 'My NFT Project #$ID+1$',
+    nameLength: 0,
+    prefixUri: 'https://arweave.net/',
+    uriLength: 43,
+    isSequential: false,
+  }),
+}
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+### 숨겨진 설정
+
+아이템을 준비하는 다른 방법은 **숨겨진 설정**을 사용하는 것입니다. 이는 구성 라인 설정과는 완전히 다른 접근 방식으로, 숨겨진 설정을 사용하면 민팅된 모든 NFT가 동일한 이름과 동일한 URI를 공유하므로 Candy Machine에 아이템을 삽입할 필요가 없습니다. 왜 누군가 그렇게 하고 싶어 할까요? 그 이유는 민팅 후 모든 NFT를 공개하는 **숨기고 공개하는 NFT 드롭**을 만들기 위해서입니다. 그렇다면 어떻게 작동할까요?
+
+- 먼저 창작자는 숨겨진 설정을 사용하여 모든 민팅된 NFT의 이름과 URI를 구성합니다. URI는 일반적으로 공개가 곧 일어날 것임을 명확히 하는 "티저" JSON 메타데이터를 가리킵니다.
+- 그다음 구매자는 동일한 URI와 따라서 동일한 "티저" JSON 메타데이터로 이러한 모든 NFT를 민팅합니다.
+- 마지막으로 모든 NFT가 민팅되면 창작자는 모든 민팅된 NFT의 URI를 해당 NFT에 특정한 실제 URI를 가리키도록 업데이트합니다.
+
+마지막 단계의 문제는 창작자가 어떤 구매자가 어떤 NFT를 받는지 조작할 수 있다는 것입니다. 이를 방지하고 구매자가 NFT와 JSON 메타데이터 간의 매핑이 변조되지 않았음을 확인할 수 있도록 하기 위해 숨겨진 설정에는 NFT 인덱스를 실제 JSON 메타데이터와 매핑하는 파일의 32자 해시로 채워져야 하는 **해시** 속성이 있습니다. 이렇게 하면 공개 후 창작자가 해당 파일을 공개할 수 있고 구매자는 해당 해시가 숨겨진 설정에 제공된 해시와 일치하는지 확인할 수 있습니다.
+
+따라서 숨겨진 설정 속성에 다음 속성들이 있게 됩니다:
+
+- **이름**: 모든 민팅된 NFT의 "숨겨진" 이름. 최대 32자를 가질 수 있습니다.
+- **URI**: 모든 민팅된 NFT의 "숨겨진" URI. 최대 200자를 가질 수 있습니다.
+- **해시**: NFT 인덱스를 실제 JSON 메타데이터와 매핑하는 파일의 32자 해시로 구매자가 변조되지 않았음을 확인할 수 있도록 합니다.
+
+구성 라인 설정의 접두사와 마찬가지로 숨겨진 설정의 **이름**과 **URI**에도 특수 변수를 사용할 수 있다는 점에 주목하세요. 다시 말해, 이러한 변수는:
+
+- `$ID$`: 0부터 시작하는 민팅된 NFT의 인덱스로 교체됩니다.
+- `$ID+1$`: 1부터 시작하는 민팅된 NFT의 인덱스로 교체됩니다.
+
+또한 Candy Machine에 아이템을 삽입하지 않으므로 숨겨진 설정을 사용하면 매우 큰 드롭을 만들 수 있다는 점에도 주목하세요. 유일한 주의사항은 민팅 후 각 NFT의 이름과 URI를 업데이트하는 오프체인 프로세스가 필요하다는 것입니다.
+
+{% dialect-switcher title="숨겨진 설정" %}
+{% dialect title="JavaScript" id="js" %}
+
+해시를 계산하려면 다음 함수를 사용할 수 있습니다:
+
+```ts
+import crypto from 'crypto'
+
+const revealData = [
+  { name: 'Nft #1', uri: 'http://example.com/1.json' },
+  { name: 'Nft #2', uri: 'http://example.com/2.json' },
+  { name: 'Nft #3', uri: 'http://example.com/3.json' },
+]
+
+const string = JSON.stringify(revealData)
+const hash = crypto.createHash('sha256').update(string).digest()
+
+console.log(hash)
+```
+
+Umi를 사용할 때 `some` 및 `none` 도우미 함수를 사용하여 라이브러리에 `configLineSettings` 및 `hiddenSettings` 속성을 통해 구성 라인 설정 또는 숨겨진 설정을 사용할지 여부를 알릴 수 있습니다. 이러한 설정 중 하나만 사용해야 하므로 하나는 구성되고 다른 하나는 `none()`으로 설정되어야 합니다.
+
+다음은 Umi 라이브러리를 사용하여 위의 예시를 설정하는 방법을 보여주는 코드 스니펫입니다.
+
+```tsx
+import { some, none } from '@metaplex-foundation/umi'
+
+const candyMachineSettings = {
+  configLineSettings: none(),
+  hiddenSettings: some({
+    name: 'My NFT Project #$ID+1$',
+    uri: 'https://example.com/path/to/teaser.json',
+    hash: hashOfTheFileThatMapsUris,
+  }),
+}
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 가드와 그룹
+
+소개에서 언급했듯이 이 페이지는 주요 Candy Machine 설정에 중점을 두지만 가드를 사용하여 Candy Machine에서 구성할 수 있는 것이 훨씬 더 많습니다.
+
+이는 설명할 많은 사용 가능한 기본 가드가 있는 광범위한 주제이므로 이 문서의 전체 섹션을 할애했습니다. 시작하기 가장 좋은 곳은 [Candy Guards](/kr/candy-machine/guards) 페이지입니다.
+
+## 결론
+
+이제 주요 Candy Machine 설정에 대해 알았으므로 [다음 페이지](/kr/candy-machine/manage)에서 자체 Candy Machine을 생성하고 업데이트하는 방법을 살펴보겠습니다.

src/pages/kr/candy-machine/sugar/configuration.md

@@ -0,0 +1,232 @@
+---
+title: 구성 파일
+metaTitle: 구성 파일 | Sugar
+description: Sugar 구성 파일의 자세한 개요입니다.
+---
+
+Sugar는 에셋을 업로드하고 Candy Machine을 구성하기 위해 JSON 구성 파일을 사용합니다. 대부분의 경우 파일 이름은 `config.json`입니다. 구성에는 Candy Machine을 초기화하고 업데이트하는 데 사용되는 설정과 민팅할 에셋을 업로드하는 설정이 포함됩니다. 또한 민팅에 대한 접근 제어를 제공할 가드의 구성도 포함됩니다.
+
+기본 구성 파일은 아래와 같습니다:
+
+```json
+{
+  "tokenStandard": "pnft",
+  "number": 10,
+  "symbol": "TEST",
+  "sellerFeeBasisPoints": 500,
+  "isMutable": true,
+  "isSequential": false,
+  "ruleSet": "eBJLFYPxJmMGKuFwpDWkzxZeUrad92kZRC5BJLpzyT9",
+  "creators": [
+    {
+      "address": "PanbgtcTiZ2PveV96t2FHSffiLHXXjMuhvoabUUKKm8",
+      "share": 50
+    },
+    {
+      "address": "PanbgtcTiZ2PveV96t2FHSffiLHXXjMuhvoabUUKKm8",
+      "share": 50
+    }
+  ],
+  "hiddenSettings": null,
+  "uploadMethod": "bundlr",
+  "awsConfig": null,
+  "nftStorageAuthToken": null,
+  "shdwStorageAccount": null,
+  "pinataConfig": null,
+  "sdriveApiKey": null,
+  "guards": {
+    "default": {
+      "botTax": {
+        "value": 0.01,
+        "lastInstruction": true
+      }
+    },
+    "groups": [
+      {
+        "label": "OGs",
+        "guards": {
+          "startDate": {
+            "date": "2022-10-20 12:00:00 +0000"
+          },
+          "tokenGate": {
+            "amount": 1,
+            "mint": "7nE1GmnMmDKiycFkpHF7mKtxt356FQzVonZqBWsTWZNf"
+          },
+          "solPayment": {
+            "value": 1,
+            "destination": "PanbgtcTiZ2PveV96t2FHSffiLHXXjMuhvoabUUKKm8"
+          }
+        }
+      },
+      {
+        "label": "Public",
+        "guards": {
+          "startDate": {
+            "date": "2022-10-20 18:00:00 +0000"
+          },
+          "solPayment": {
+            "value": 2,
+            "destination": "PanbgtcTiZ2PveV96t2FHSffiLHXXjMuhvoabUUKKm8"
+          }
+        }
+      }
+    ]
+  }
+}
+```
+
+구성 파일은 세 가지 주요 부분으로 볼 수 있습니다: Candy Machine 설정(`"tokenStandard"`부터 `"hiddenSettings"`까지), 업로드 설정(`"uploadMethod"`부터 `"sdriveApiKey"`까지) 및 가드 설정(`"guards"`).
+
+## Candy Machine 설정
+
+Candy Machine 설정은 에셋의 유형, 사용 가능한 에셋 수 및 메타데이터 정보를 결정합니다.
+
+| 설정 | 옵션 | 값/타입 | 설명               |
+| ------- | ------- | --------------- | ------------------------- |
+| tokenStandard |   |                 |                           |
+|         |         | "nft"           | 대체 불가능한 에셋 (`NFT`)        |
+|         |         | "pnft"           | 프로그래밍 가능한 대체 불가능한 에셋 (`pNFT`) |
+| number  |         | Integer         | 사용 가능한 항목 수 |
+| symbol  |         | String          | NFT의 심볼을 나타내는 문자열 |
+| sellerFeeBasisPoint  |         | Integer          | 창작자가 공유하는 로열티(베이시스 포인트, 즉 550은 5.5%를 의미)  |
+| isMutable |       | Boolean         | NFT 메타데이터 계정을 업데이트할 수 있는지를 나타내는 불린 값 |
+| isSequential |    | Boolean         | 민팅 중에 순차적 인덱스 생성을 사용할지를 나타내는 불린 값 |
+| ruleSet  |        | Public Key | *(선택사항)* 민팅된 `pNFT`가 사용하는 규칙 세트 |
+
+`creators` 설정을 사용하면 최대 4개의 주소와 그들의 백분율 지분을 지정할 수 있습니다.
+
+| 설정 | 옵션 | 값/타입 | 설명               |
+| ------- | ------- | --------------- | ------------------------- |
+| creators |        | 최대 4명의 창작자 | 창작자 목록 및 로열티의 백분율 지분 |
+|          | address | Public Key | 창작자 공개 키 |
+|          | share | Integer | `0`과 `100` 사이의 값 |
+
+{% callout %}
+
+온체인 메타데이터는 최대 5명의 창작자를 저장하지만, Candy Machine은 창작자 중 하나로 설정됩니다. 따라서 최대 4명의 창작자만 허용됩니다.
+
+지분 값의 합계는 100이 되어야 하며, 그렇지 않으면 오류가 발생합니다.
+
+{% /callout %}
+
+Candy Machine은 NFT가 민팅될 때 최종 메타데이터를 갖지 않도록 구성할 수 있습니다. 이는 민팅이 완료된 후 공개 단계를 계획할 때 유용합니다. 이 경우 *숨겨진* NFT에 대한 "플레이스홀더" 메타데이터 값을 지정할 수 있습니다:
+
+| 설정 | 옵션 | 값/타입 | 설명               |
+| ------- | ------- | --------------- | ------------------------- |
+| hiddenSettings | | | |
+| | name | String | 민트의 이름(`$ID$` 또는 `$ID+1$` 민트 인덱스 교체 변수를 사용해야 하므로 `sugar reveal`이 작동할 수 있음) |
+| | uri | String | 민트의 URI(`$ID$` 또는 `$ID+1$` 민트 인덱스 교체 변수를 사용할 수 있음) |
+| | hash | String | 32자 해시(대부분의 경우 민트 번호와 메타데이터 간의 매핑이 있는 캐시 파일의 해시로, 민트가 완료될 때 순서를 확인할 수 있음. `sugar hash`를 사용하여 찾을 수 있음)
+
+{% totem %}
+{% totem-accordion title="hiddenSettings 예시" %}
+구성 파일의 `hiddenSettings` 섹션은 다음과 같을 수 있습니다:
+```json
+"hiddenSettings": {
+    "name": "Name $ID+1$",
+    "uri": "https://arweave.net/IM4NByHrEzG87g2AhFY4pY7lk7YNriUVUUbZWhZ0HHY/26.png",
+    "hash": "49Bj8ZVSvSvAQwziKEts3iAeUhi27ATH"
+}
+```
+{% /totem-accordion %}
+{% /totem %}
+
+## 업로드 설정
+
+Sugar는 다양한 스토리지 공급자를 지원하며, 사용할 공급자는 `uploadMethod` 설정으로 정의됩니다. 공급자에 따라 추가 구성이 필요할 수 있습니다.
+
+아래 표는 사용 가능한 설정에 대한 개요를 제공합니다:
+
+| 설정 | 옵션 | 허용되는 값 | 설명               |
+| ------- | ------- | --------------- | ------------------------- |
+| uploadMethod |   |  | 이미지와 메타데이터를 업로드할 스토리지 구성 |  
+|  |   | "bundlr" |  [Bundlr](https://bundlr.network)을 사용하여 Arweave에 업로드하고 SOL로 결제 (메인넷과 데브넷 모두에서 작동; 데브넷에서는 7일 동안만 파일이 저장됨)
+|  |   | "aws" | Amazon Web Services (AWS)에 업로드 |
+|  |   | "nftStorage" | [NFT.Storage](https://nft.storage)에 업로드 (모든 네트워크에서 작동) |
+|  |   | "shdw" | GenesysGo [Shadow Drive](https://docs.shadow.cloud)에 업로드 (메인넷에서만 작동)
+|  |   | "pinata" | [Pinata](https://www.pinata.cloud)에 업로드 (모든 네트워크에서 작동; 무료 및 계층화된 구독) |
+|  |   | "sdrive" | [SDrive Cloud Storage](https://sdrive.app)를 사용하여 Shadow Drive에 업로드 |
+|awsConfig | | | *("aws"가 사용될 때 필수)* |
+| | bucket | String | AWS 버킷 이름
+| | profile | String | 자격 증명 파일에서 사용할 AWS 프로필 이름 |
+| | directory | String | 항목을 업로드할 버킷 내의 디렉터리. 빈 문자열은 버킷 루트 디렉터리에 파일을 업로드함을 의미. |
+| nftStorageAuthToken | | String | NFT.Storage API 키 *("nftStorage"가 사용될 때 필수)* |
+| pinataConfig | | | *("pinata"가 사용될 때 필수)* |
+| | JWT | String | JWT 인증 토큰 |
+| | apiGateway | String | Pinata API에 연결할 URL |
+| | apiContent | String | 에셋 링크 생성의 기반으로 사용할 URL |
+| | parallelLimit | Integer | 동시 업로드 수; 속도 제한을 피하기 위해 이 설정 사용 |
+| shadowStorageAccount | | String | Shadow Drive 스토리지 pubkey *("shdw"가 사용될 때 필수)* |
+| sdriveApiKey | | String | SDrive API 키 *("sdrive"가 사용될 때 필수)* |
+
+특정 업로드 방법 설정:
+
+{% totem %}
+{% totem-accordion title="Bundlr" %}
+
+`"bundlr"` 업로드 방법은 추가 구성이 필요하지 않습니다. 업로드와 관련된 모든 수수료는 구성된 키페어를 사용하여 `SOL`로 지불됩니다.
+
+{% /totem-accordion %}
+{% totem-accordion title="AWS" %}
+
+`"aws"` 방법은 파일을 Amazon S3 스토리지에 업로드합니다. 이는 추가 구성이 필요하며, 구성 파일의 `"awsConfig"` 하에 `bucket`, `profile`, `directory` 및 `domain` 값을 지정하고 시스템에 자격 증명을 설정해야 합니다. 대부분의 경우 다음 속성으로 `~/.aws/credentials` 파일을 생성하는 것이 포함됩니다:
+
+```
+[default]
+aws_access_key_id=<ACCESS KEY ID>
+aws_secret_access_key=<SECRET ACCESS KEY>
+region=<REGION>
+```
+
+또한 `"public-read"`를 활성화하고 다른 출처에서 요청된 콘텐츠 액세스를 가능하게 하는 Cross-Origin Resource Sharing (CORS) 규칙을 적용하여 버킷의 ACL 권한을 올바르게 설정하는 것이 중요합니다(지갑과 블록체인 탐색기가 메타데이터/미디어 파일을 로드할 수 있게 하기 위해 필요). 이러한 구성에 대한 더 많은 정보는 다음에서 찾을 수 있습니다:
+
+* [버킷 정책 예시](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html)
+* [CORS 구성](https://aws.amazon.com/premiumsupport/knowledge-center/s3-configure-cors/)
+
+`profile` 값을 사용하면 자격 증명 파일에서 읽을 프로필을 지정할 수 있습니다. `directory` 값은 파일이 업로드될 버킷 내 디렉터리의 이름으로, 서로 다른 디렉터리로 구분된 단일 버킷에 여러 candy machine 또는 컬렉션을 가질 수 있게 합니다. 이를 빈 문자열로 두면 파일이 버킷의 루트에 업로드됩니다. (선택사항인) `domain`을 사용하면 AWS에서 데이터를 제공할 커스텀 도메인을 지정할 수 있습니다 — 예를 들어, 도메인을 `https://mydomain.com`으로 사용하면 `https://mydomain.com/0.json` 형식의 파일 링크를 생성합니다. 도메인을 지정하지 않으면 기본 AWS S3 도메인(`https://<BUCKET_NAME>.s3.amazonaws.com`)이 사용됩니다.
+
+{% /totem-accordion %}
+{% totem-accordion title="NFT.Storage" %}
+
+NFT.Storage는 공개 IPFS 네트워크에 데이터를 업로드하는 인기 있는 서비스입니다. API 키(토큰)를 얻기 위해 계정을 등록해야 하며, 이는 구성 파일에서 `"nftStorageAuthToken"`으로 지정해야 합니다.
+
+{% /totem-accordion %}
+{% totem-accordion title="Pinata" %}
+
+`"pinata"` 방법은 파일을 Pinata 스토리지에 업로드합니다. 구성 파일의 `"pinataConfig"` 하에 `jwt`, `apiGateway`, `contentGateway` 및 `parallelLimit` 값을 지정해야 합니다:
+
+* `jwt`: JWT 인증 토큰
+* `apiGateway`: Pinata API에 연결할 URL (공개 API 엔드포인트의 경우 `https://api.pinata.cloud` 사용)
+* `contentGateway`: 에셋 링크 생성의 기반으로 사용할 URL (공개 게이트웨이의 경우 `https://gateway.pinata.cloud` 사용)
+* `parallelLimit`: (선택사항) 동시 업로드 수, 속도 제한을 피하기 위해 이 값을 조정
+
+{% callout %}
+
+공개 게이트웨이는 프로덕션에서 사용하기 위한 것이 아닙니다 — 심하게 속도 제한이 있고 속도를 위해 설계되지 않았으므로 테스트에 사용하기에 좋습니다.
+
+{% /callout %}
+
+{% /totem-accordion %}
+{% totem-accordion title="Shadow Drive" %}
+
+Shadow Drive는 Solana 블록체인을 위해 특별히 구축된 분산 스토리지 네트워크입니다. Shadow Drive에 데이터를 업로드하려면 먼저 스토리지 계정을 생성해야 합니다. 이는 [Shadow Drive CLI](https://docs.shadow.cloud/build)를 사용하여 수행할 수 있습니다. 스토리지 계정을 생성한 후 구성 파일에서 `"shdwStorageAccount"` 속성을 사용하여 해당 pubkey 주소를 지정하세요.
+
+{% callout %}
+
+Shadow Drive 업로드 방법은 `mainnet-beta`에서만 사용할 수 있습니다.
+
+{% /callout %}
+
+{% /totem-accordion %}
+{% totem-accordion title="SDrive" %}
+
+SDrive는 GenesysGo Shadow Drive 위에 구축된 스토리지 앱입니다. API 키(토큰)를 얻기 위해 계정을 등록해야 하며, 이는 구성 파일에서 `"sdriveApiKey"`로 지정해야 합니다.
+
+{% /totem-accordion %}
+{% /totem %}
+
+## 가드 설정
+
+`guards` 설정을 사용하면 Candy Machine에서 활성화될 가드를 지정할 수 있습니다.
+
+Candy Machine은 민팅에 대한 접근 제어를 제공하는 여러 가드를 지원합니다. [가드](/kr/candy-machine/guards)는 "기본" [가드 그룹](/kr/candy-machine/guard-groups)으로 구성되거나 여러 가드 그룹에 나타날 수 있습니다.

src/pages/kr/candy-machine/sugar/index.md

@@ -0,0 +1,101 @@
+---
+title: 개요
+metaTitle: 개요 | Sugar
+description: Candy Machine 관리를 위한 CLI 도구인 Sugar의 자세한 개요입니다.
+---
+
+Sugar는 Candy Machine과 상호작용하기 위한 명령줄 도구입니다. Candy Machine의 전체 생명주기를 관리할 수 있게 해주며 다음과 같은 장점을 가집니다:
+
+- 모든 Candy Machine 설정을 포함하는 단일 구성 파일;
+- 미디어/메타데이터 파일 업로드 및 Candy Machine 배포의 향상된 성능 — 이러한 작업은 멀티스레드 시스템을 활용하여 필요한 계산 시간을 현저히 단축합니다;
+- 정보 제공적인 오류 메시지와 함께 견고한 오류 처리 및 입력 검증;
+- 명령이 중단되어도 상태가 유지됩니다 – 예를 들어, 업로드가 실패하면 업로드를 다시 실행할 수 있고 실패한 것들만 재시도됩니다.
+
+Sugar 설정은 좋아하는 터미널 애플리케이션을 열고 바이너리 파일을 다운로드하는 것만큼 간단합니다.
+
+{% callout %}
+Sugar를 사용하여 Candy Machine을 생성하는 방법에 대한 전체 가이드는 [여기](/kr/candy-machine/guides/create-an-nft-collection-on-solana-with-candy-machine)에서 찾을 수 있습니다.
+
+{% /callout %}
+
+Sugar는 Candy Machine 생성 및 관리를 위한 명령어 모음을 포함합니다. 명령줄에서 다음을 실행하여 전체 명령어 목록을 볼 수 있습니다:
+
+```bash
+sugar
+```
+
+이는 명령어 목록과 그 간단한 설명을 표시합니다:
+```
+sugar-cli 2.7.1
+Metaplex Candy Machine 생성 및 관리를 위한 명령줄 도구입니다.
+
+USAGE:
+    sugar [OPTIONS] <SUBCOMMAND>
+
+OPTIONS:
+    -h, --help                     도움말 정보 출력
+    -l, --log-level <LOG_LEVEL>    로그 레벨: trace, debug, info, warn, error, off
+    -V, --version                  버전 정보 출력
+
+SUBCOMMANDS:
+    airdrop       candy machine에서 NFT 에어드랍
+    bundlr        bundlr 네트워크와 상호작용
+    collection    candy machine의 컬렉션 관리
+    config        candy machine 구성 관리
+    deploy        캐시 항목을 온체인 candy machine 구성에 배포
+    freeze        freeze guard 작업 관리
+    guard         candy machine의 가드 관리
+    hash          숨겨진 설정을 위한 캐시 파일 해시 생성
+    help          이 메시지 또는 주어진 하위 명령의 도움말 출력
+    launch        에셋으로부터 candy machine 배포 생성
+    mint          candy machine에서 NFT 하나 민팅
+    reveal        숨겨진 설정 candy machine에서 NFT 공개
+    show          기존 candy machine의 온체인 구성 표시
+    sign          candy machine에서 NFT 하나 또는 전체에 서명
+    upload        에셋을 스토리지에 업로드하고 캐시 구성 생성
+    validate      JSON 메타데이터 파일 검증
+    verify        업로드된 데이터 확인
+    withdraw      candy machine 계정에서 자금을 인출하여 계정을 닫음
+```
+
+특정 명령어(예: `deploy`)에 대한 더 많은 정보를 얻으려면 help 명령어를 사용하세요:
+
+```
+sugar help deploy
+```
+
+이는 간단한 설명과 함께 옵션 목록을 표시합니다:
+
+```
+캐시 항목을 온체인 candy machine 구성에 배포
+
+USAGE:
+    sugar deploy [OPTIONS]
+
+OPTIONS:
+    -c, --config <CONFIG>
+            구성 파일 경로, 기본값은 "config.json" [default: config.json]
+
+        --cache <CACHE>
+            캐시 파일 경로, 기본값은 "cache.json" [default: cache.json]
+
+        --collection-mint <COLLECTION_MINT>
+            candy machine이 토큰을 민팅할 선택적 컬렉션 주소
+
+    -h, --help
+            도움말 정보 출력
+
+    -k, --keypair <KEYPAIR>
+            키페어 파일 경로, Sol config를 사용하거나 기본값은 "~/.config/solana/id.json"
+
+    -l, --log-level <LOG_LEVEL>
+            로그 레벨: trace, debug, info, warn, error, off
+
+    -p, --priority-fee <PRIORITY_FEE>
+            우선순위 수수료 값 [default: 500]
+
+    -r, --rpc-url <RPC_URL>
+            RPC Url
+```
+
+Ape16Z가 의뢰한 OtterSec의 Sugar 감사 보고서는 [여기](https://docsend.com/view/is7963h8tbbvp2g9)에서 확인할 수 있습니다.

src/pages/kr/cli/config/explorer.md

@@ -0,0 +1,50 @@
+---
+title: 탐색기 구성
+description: 선호하는 블록체인 탐색기 설정
+---
+
+`mplx config explorer` 명령어를 사용하여 거래와 계정을 조회할 때 사용할 선호 블록체인 탐색기를 설정할 수 있습니다.
+
+## 기본 사용법
+
+### 탐색기 설정
+```bash
+mplx config explorer set
+```
+
+## 명령어
+
+### 탐색기 설정
+사용 가능한 옵션 목록에서 선호하는 블록체인 탐색기를 설정합니다.
+
+#### 예시
+```bash
+mplx config explorer set
+```
+
+#### 참고사항
+- 사용 가능한 탐색기에서 선택할 수 있는 대화형 프롬프트가 열립니다
+- 구성에서 활성 탐색기를 업데이트합니다
+- 선택한 탐색기가 거래와 계정 조회에 사용됩니다
+- 사용 가능한 탐색기:
+  - Solana Explorer (https://explorer.solana.com)
+  - Solscan (https://solscan.io)
+  - Solana FM (https://solana.fm)
+
+## 구성 파일
+
+탐색기 구성은 구성 파일(기본값: `~/.mplx/config.json`)에 저장됩니다. 구조는 다음과 같습니다:
+
+```json
+{
+  "explorer": "https://explorer.solana.com"
+}
+```
+
+## 참고사항
+
+- 탐색기 설정은 거래와 계정에 대한 링크를 표시할 때 사용됩니다
+- 구성 파일이 존재하지 않으면 자동으로 생성됩니다
+- 언제든지 선호 탐색기를 변경할 수 있습니다
+- 선택한 탐색기가 명령어 출력의 모든 탐색기 링크에 사용됩니다
+- 각 탐색기는 블록체인 데이터를 조회하기 위한 다양한 기능과 인터페이스를 제공합니다

src/pages/kr/cli/config/rpcs.md

@@ -0,0 +1,141 @@
+---
+title: RPC
+description: 구성에서 RPC 엔드포인트 관리
+---
+
+구성에서 RPC 엔드포인트를 관리합니다. 다양한 네트워크에 대해 RPC를 추가, 나열, 제거 및 활성화할 수 있습니다.
+
+## 기본 사용법
+
+```bash
+# 새 RPC 엔드포인트 추가
+mplx config rpcs add <name> <endpoint>
+
+# 모든 RPC 엔드포인트 나열
+mplx config rpcs list
+
+# RPC 엔드포인트 제거
+mplx config rpcs remove <name>
+
+# 활성 RPC 엔드포인트 설정
+mplx config rpcs set <name>
+```
+
+## 명령어
+
+### RPC 추가
+
+구성에 새 RPC 엔드포인트를 추가합니다.
+
+```bash
+mplx config rpcs add <name> <endpoint>
+```
+
+#### 인수
+
+| 인수 | 설명 |
+|----------|-------------|
+| `name` | RPC 엔드포인트의 고유한 이름 (예: 'mainnet', 'devnet') |
+| `endpoint` | RPC 엔드포인트 URL |
+
+#### 예시
+
+```bash
+mplx config rpcs add mainnet https://api.mainnet-beta.solana.com
+```
+
+### RPC 나열
+
+구성된 모든 RPC 엔드포인트를 표시합니다.
+
+```bash
+mplx config rpcs list
+```
+
+#### 출력
+
+```
+--------------------------------
+RPC Endpoints
+--------------------------------
+Name: mainnet
+Endpoint: https://api.mainnet-beta.solana.com
+Active: true
+
+Name: devnet
+Endpoint: https://api.devnet.solana.com
+Active: false
+--------------------------------
+```
+
+### RPC 제거
+
+구성에서 RPC 엔드포인트를 제거합니다.
+
+```bash
+mplx config rpcs remove <name>
+```
+
+#### 인수
+
+| 인수 | 설명 |
+|----------|-------------|
+| `name` | 제거할 RPC 엔드포인트의 이름 |
+
+#### 예시
+
+```bash
+mplx config rpcs remove devnet
+```
+
+### 활성 RPC 설정
+
+구성에서 활성 RPC 엔드포인트를 설정합니다.
+
+```bash
+mplx config rpcs set <name>
+```
+
+#### 인수
+
+| 인수 | 설명 |
+|----------|-------------|
+| `name` | 활성으로 설정할 RPC 엔드포인트의 이름 |
+
+#### 예시
+
+```bash
+mplx config rpcs set mainnet
+```
+
+## 구성 파일
+
+RPC는 `~/.mplx/config.json`의 구성 파일에 저장됩니다:
+
+```json
+{
+  "rpcs": {
+    "mainnet": {
+      "endpoint": "https://api.mainnet-beta.solana.com",
+      "active": true
+    },
+    "devnet": {
+      "endpoint": "https://api.devnet.solana.com",
+      "active": false
+    }
+  }
+}
+```
+
+## 참고사항
+
+- RPC 이름은 대소문자를 구분합니다
+- 한 번에 하나의 RPC만 활성화할 수 있습니다
+- 활성 RPC는 모든 네트워크 작업에 사용됩니다
+- 다양한 네트워크에 대해 여러 RPC를 추가할 수 있습니다
+- 활성 RPC를 제거하면 사용 가능한 경우 다른 RPC가 자동으로 활성으로 설정됩니다
+
+## 관련 명령어
+
+- [지갑](/cli/config/wallets) - 지갑 구성 관리
+- [탐색기](/cli/config/explorer) - 선호하는 블록체인 탐색기 설정

src/pages/kr/cli/config/wallets.md

@@ -0,0 +1,167 @@
+---
+title: 지갑
+description: 지갑 구성 관리
+---
+
+CLI에서 지갑 구성을 관리합니다. 다양한 용도로 지갑을 추가, 나열, 제거 및 활성화할 수 있습니다.
+
+## 기본 사용법
+
+```bash
+# 새 지갑 생성
+mplx config wallets new --name <name>
+
+# 기존 지갑 추가
+mplx config wallets add <name> <keypairPath>
+
+# 모든 지갑 나열
+mplx config wallets list
+
+# 지갑 제거
+mplx config wallets remove <name>
+
+# 활성 지갑 설정
+mplx config wallets set <name>
+```
+
+## 명령어
+
+### 새 지갑
+
+새 지갑을 생성하고 구성에 추가합니다.
+
+```bash
+mplx config wallets new --name <name>
+```
+
+#### 인수
+
+| 인수 | 설명 |
+|----------|-------------|
+| `--name` | 지갑의 고유한 이름 |
+
+#### 예시
+
+```bash
+mplx config wallets new --name dev1
+```
+
+### 지갑 추가
+
+기존 지갑을 구성에 추가합니다.
+
+```bash
+mplx config wallets add <name> <keypairPath>
+```
+
+#### 인수
+
+| 인수 | 설명 |
+|----------|-------------|
+| `name` | 지갑의 고유한 이름 |
+| `keypairPath` | 키페어 파일 경로 |
+
+#### 예시
+
+```bash
+mplx config wallets add dev1 ~/.config/solana/devnet/dev1.json
+```
+
+### 지갑 나열
+
+구성된 모든 지갑을 표시합니다.
+
+```bash
+mplx config wallets list
+```
+
+#### 출력
+
+```
+--------------------------------
+Wallets
+--------------------------------
+Name: dev1
+Public Key: 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU
+Active: true
+
+Name: dev2
+Public Key: 9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM
+Active: false
+--------------------------------
+```
+
+### 지갑 제거
+
+구성에서 지갑을 제거합니다.
+
+```bash
+mplx config wallets remove <name>
+```
+
+#### 인수
+
+| 인수 | 설명 |
+|----------|-------------|
+| `name` | 제거할 지갑의 이름 |
+
+#### 예시
+
+```bash
+mplx config wallets remove dev2
+```
+
+### 활성 지갑 설정
+
+구성에서 활성 지갑을 설정합니다.
+
+```bash
+mplx config wallets set <name>
+```
+
+#### 인수
+
+| 인수 | 설명 |
+|----------|-------------|
+| `name` | 활성으로 설정할 지갑의 이름 |
+
+#### 예시
+
+```bash
+mplx config wallets set dev1
+```
+
+## 구성 파일
+
+지갑은 `~/.mplx/config.json`의 구성 파일에 저장됩니다:
+
+```json
+{
+  "wallets": {
+    "dev1": {
+      "publicKey": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU",
+      "keypairPath": "~/.config/solana/devnet/dev1.json",
+      "active": true
+    },
+    "dev2": {
+      "publicKey": "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
+      "keypairPath": "~/.config/solana/devnet/dev2.json",
+      "active": false
+    }
+  }
+}
+```
+
+## 참고사항
+
+- 지갑 이름은 대소문자를 구분합니다
+- 한 번에 하나의 지갑만 활성화할 수 있습니다
+- 활성 지갑은 모든 거래에 사용됩니다
+- 다양한 용도로 여러 지갑을 추가할 수 있습니다
+- 활성 지갑을 제거하면 사용 가능한 경우 다른 지갑이 자동으로 활성으로 설정됩니다
+- 키페어 파일을 안전하게 보관하고 절대 공유하지 마세요
+
+## 관련 명령어
+
+- [RPC](/cli/config/rpcs) - RPC 엔드포인트 관리
+- [탐색기](/cli/config/explorer) - 선호하는 블록체인 탐색기 설정

src/pages/kr/cli/core/create-asset.md

@@ -0,0 +1,84 @@
+---
+title: 자산 생성
+description: 다양한 방법을 사용하여 MPL Core 자산 생성
+---
+
+`mplx core asset create` 명령어를 사용하면 세 가지 다른 방법으로 MPL Core 자산을 생성할 수 있습니다: 간단한 생성, 파일 기반 생성 또는 대화형 마법사. 이 명령어는 일관된 출력 형식을 유지하면서 자산을 생성하는 방법의 유연성을 제공합니다.
+
+## 방법
+
+### 1. 간단한 생성
+명령줄 인수를 통해 메타데이터의 이름과 URI를 직접 제공하여 단일 자산을 생성합니다.
+
+```bash
+mplx core asset create --name "My NFT" --uri "https://example.com/metadata.json"
+```
+
+### 2. 파일 기반 생성
+이미지 파일과 JSON 메타데이터 파일을 제공하여 단일 자산을 생성합니다. 명령어가 두 파일 업로드 및 자산 생성을 처리합니다.
+
+```bash
+mplx core asset create --files --image "./my-nft.png" --json "./metadata.json"
+```
+
+### 3. 대화형 마법사
+파일 업로드 및 메타데이터 생성을 포함한 전체 프로세스를 안내하는 대화형 마법사를 사용하여 자산을 생성합니다.
+
+```bash
+mplx core asset create --wizard
+```
+
+## 옵션
+
+### 기본 옵션
+- `--name <string>`: 자산 이름 (간단한 생성에 필수)
+- `--uri <string>`: 자산 메타데이터의 URI (간단한 생성에 필수)
+- `--collection <string>`: 자산의 컬렉션 ID
+
+### 파일 기반 옵션
+- `--files`: 파일 기반 생성을 나타내는 플래그
+- `--image <path>`: 업로드하고 자산에 할당할 이미지 파일 경로
+- `--json <path>`: JSON 메타데이터 파일 경로
+
+### 플러그인 옵션
+- `--plugins`: 대화형 플러그인 선택 사용
+- `--pluginsFile <path>`: 플러그인 데이터가 포함된 JSON 파일 경로
+
+## 예시
+
+1. 대화형 마법사를 사용하여 자산 생성:
+```bash
+mplx core asset create --wizard
+```
+
+2. 이름과 URI로 자산 생성:
+```bash
+mplx core asset create --name "My NFT" --uri "https://example.com/metadata.json"
+```
+
+3. 파일에서 자산 생성:
+```bash
+mplx core asset create --files --image "./my-nft.png" --json "./metadata.json"
+```
+
+4. 컬렉션과 함께 자산 생성:
+```bash
+mplx core asset create --name "My NFT" --uri "https://example.com/metadata.json" --collection "collection_id_here"
+```
+
+5. 파일과 컬렉션으로 자산 생성:
+```bash
+mplx core asset create --files --image "./my-nft.png" --json "./metadata.json" --collection "collection_id_here"
+```
+
+## 출력
+
+명령어는 성공적으로 생성되면 다음 정보를 출력합니다:
+```
+--------------------------------
+  Asset: <asset_address>
+  Signature: <transaction_signature>
+  Explorer: <explorer_url>
+  Core Explorer: https://core.metaplex.com/explorer/<asset_address>
+--------------------------------
+```

src/pages/kr/cli/core/create-collection.md

@@ -0,0 +1,82 @@
+---
+title: 컬렉션 생성
+description: 다양한 방법을 사용하여 MPL Core 컬렉션 생성
+---
+
+`mplx core collection create` 명령어를 사용하면 세 가지 다른 방법으로 MPL Core 컬렉션을 생성할 수 있습니다: 간단한 생성, 파일 기반 생성 또는 대화형 마법사. 이 명령어는 일관된 출력 형식을 유지하면서 컬렉션을 생성하는 방법의 유연성을 제공합니다.
+
+## 방법
+
+### 1. 간단한 생성
+명령줄 인수를 통해 메타데이터의 이름과 URI를 직접 제공하여 단일 컬렉션을 생성합니다.
+
+```bash
+mplx core collection create --name "My Collection" --uri "https://example.com/metadata.json"
+```
+
+### 2. 파일 기반 생성
+이미지 파일과 JSON 메타데이터 파일을 제공하여 단일 컬렉션을 생성합니다. 명령어가 두 파일 업로드 및 컬렉션 생성을 처리합니다.
+
+```bash
+mplx core collection create --files --image "./my-collection.png" --json "./metadata.json"
+```
+
+### 3. 대화형 마법사
+파일 업로드 및 메타데이터 생성을 포함한 전체 프로세스를 안내하는 대화형 마법사를 사용하여 컬렉션을 생성합니다.
+
+```bash
+mplx core collection create --wizard
+```
+
+## 옵션
+
+### 기본 옵션
+- `--name <string>`: 컬렉션 이름 (간단한 생성에 필수)
+- `--uri <string>`: 컬렉션 메타데이터의 URI (간단한 생성에 필수)
+
+### 파일 기반 옵션
+- `--files`: 파일 기반 생성을 나타내는 플래그
+- `--image <path>`: 업로드하고 컬렉션에 할당할 이미지 파일 경로
+- `--json <path>`: JSON 메타데이터 파일 경로
+
+### 플러그인 옵션
+- `--plugins`: 대화형 플러그인 선택 사용
+- `--pluginsFile <path>`: 플러그인 데이터가 포함된 JSON 파일 경로
+
+## 예시
+
+1. 대화형 마법사를 사용하여 컬렉션 생성:
+```bash
+mplx core collection create --wizard
+```
+
+2. 이름과 URI로 컬렉션 생성:
+```bash
+mplx core collection create --name "My Collection" --uri "https://example.com/metadata.json"
+```
+
+3. 파일에서 컬렉션 생성:
+```bash
+mplx core collection create --files --image "./my-collection.png" --json "./metadata.json"
+```
+
+## 출력
+
+명령어는 성공적으로 생성되면 다음 정보를 출력합니다:
+```
+--------------------------------
+  Collection: <collection_address>
+  Signature: <transaction_signature>
+  Explorer: <explorer_url>
+  Core Explorer: https://core.metaplex.com/explorer/<collection_address>
+--------------------------------
+```
+
+## 참고사항
+
+- 파일 기반 생성 방법을 사용할 때는 `--image`와 `--json` 플래그가 모두 필요합니다
+- 마법사 방법은 파일 업로드 및 메타데이터 생성을 포함하여 컬렉션 생성을 위한 가이드 경험을 제공합니다
+- 플러그인 구성은 대화형으로 또는 JSON 파일을 통해 수행할 수 있습니다
+- JSON 메타데이터 파일은 컬렉션에 대한 `name` 필드를 포함해야 합니다
+- 명령어는 파일 기반 또는 마법사 방법을 사용할 때 파일 업로드 및 메타데이터 생성을 자동으로 처리합니다
+- 컬렉션 메타데이터는 컬렉션별 필드가 추가된 표준 NFT 메타데이터 형식을 따릅니다

src/pages/kr/cli/core/fetch.md

@@ -0,0 +1,103 @@
+---
+title: 자산 또는 컬렉션 가져오기
+description: 민트 주소로 MPL Core 자산 또는 컬렉션 가져오기
+---
+
+`mplx core fetch` 명령어를 사용하면 민트 주소로 MPL Core 자산이나 컬렉션을 가져올 수 있습니다. 메타데이터를 보고 선택적으로 관련 파일을 다운로드할 수 있습니다.
+
+## 자산 가져오기
+
+### 기본 사용법
+```bash
+mplx core fetch asset <assetId>
+```
+
+### 다운로드 옵션
+```bash
+mplx core fetch asset <assetId> --download --output ./assets
+mplx core fetch asset <assetId> --download --image
+mplx core fetch asset <assetId> --download --metadata
+```
+
+### 자산 가져오기 옵션
+- `--download`: 자산 파일을 디스크에 다운로드 (추가 플래그로 개별 파일 선택 가능)
+- `--output <path>`: 다운로드한 자산을 저장할 디렉토리 경로 (--download 필요)
+- `--image`: 이미지 파일 다운로드 (--download 필요)
+- `--metadata`: 메타데이터 파일 다운로드 (--download 필요)
+- `--asset`: 자산 데이터 파일 다운로드 (--download 필요)
+
+## 컬렉션 가져오기
+
+### 기본 사용법
+```bash
+mplx core fetch collection <collectionId>
+```
+
+### 다운로드 옵션
+```bash
+mplx core fetch collection <collectionId> --output ./collections
+```
+
+### 컬렉션 가져오기 옵션
+- `-o, --output <path>`: 다운로드한 컬렉션 파일의 출력 디렉토리. 지정하지 않으면 현재 폴더가 사용됩니다.
+
+## 예시
+
+### 자산 가져오기 예시
+1. 단일 자산 가져오기:
+```bash
+mplx core fetch asset 5avjMVza8SuMhgTfzEGNWJskDELMCQk9juAAc8zeQoNa
+```
+
+2. 자산 파일을 특정 디렉토리에 다운로드:
+```bash
+mplx core fetch asset 5avjMVza8SuMhgTfzEGNWJskDELMCQk9juAAc8zeQoNa --download --output ./assets
+```
+
+3. 이미지만 다운로드:
+```bash
+mplx core fetch asset 5avjMVza8SuMhgTfzEGNWJskDELMCQk9juAAc8zeQoNa --download --image
+```
+
+### 컬렉션 가져오기 예시
+1. 컬렉션 가져오기:
+```bash
+mplx core fetch collection HaKyubAWuTS9AZkpUHtFkTKAHs1KKAJ3onZPmaP9zBpe
+```
+
+2. 컬렉션 파일을 특정 디렉토리에 다운로드:
+```bash
+mplx core fetch collection HaKyubAWuTS9AZkpUHtFkTKAHs1KKAJ3onZPmaP9zBpe --output ./collections
+```
+
+## 출력
+
+### 자산 가져오기 출력
+파일을 다운로드할 때 다음 구조가 생성됩니다:
+```
+<output_directory>/
+  <assetId>/
+    metadata.json
+    image.<extension>
+    asset.json
+```
+
+### 컬렉션 가져오기 출력
+파일을 다운로드할 때 다음 구조가 생성됩니다:
+```
+<output_directory>/
+  <collectionId>/
+    metadata.json
+    image.<extension>
+    collection.json
+```
+
+## 참고사항
+
+- 가져오기 명령어는 파일 유형을 자동으로 감지하고 적절한 확장자를 사용합니다
+- 컬렉션에 대해 출력 디렉토리를 지정하지 않으면 현재 디렉토리에 파일이 저장됩니다
+- 메타데이터 JSON 파일은 가독성을 위해 예쁘게 인쇄됩니다
+- 이미지 파일은 원래 형식과 품질을 유지합니다
+- 명령어는 존재하지 않는 경우 필요한 디렉토리를 생성합니다
+- 컬렉션의 경우 메타데이터와 이미지 파일이 함께 다운로드됩니다
+- 자산의 경우 특정 구성 요소(이미지, 메타데이터 또는 자산 데이터)를 선택하여 다운로드할 수 있습니다

src/pages/kr/cli/core/plugins.md

@@ -0,0 +1,86 @@
+---
+title: 플러그인
+description: MPL Core 자산 및 컬렉션 플러그인 관리
+---
+
+`mplx core plugins` 명령어를 사용하면 MPL Core 자산과 컬렉션의 플러그인을 관리할 수 있습니다. 플러그인은 추가 기능과 역량으로 자산과 컬렉션의 기능을 확장합니다.
+
+## 플러그인 추가
+
+자산 또는 컬렉션에 플러그인을 추가합니다.
+
+### 기본 사용법
+
+```bash
+mplx core plugins add <assetId> [options]
+```
+
+### 옵션
+- `--wizard`: 플러그인 선택 및 구성을 위한 대화형 마법사 모드
+- `--collection`: 대상이 컬렉션임을 나타내는 플래그 (기본값: false)
+
+### 방법
+
+#### 1. 마법사 모드 사용
+```bash
+mplx core plugins add <assetId> --wizard
+```
+다음과 같은 작업을 수행합니다:
+1. 플러그인 유형을 선택하는 대화형 마법사 실행
+2. 플러그인 구성 안내
+3. 구성된 플러그인을 자산/컬렉션에 추가
+
+#### 2. JSON 파일 사용
+```bash
+mplx core plugins add <assetId> ./plugin.json
+```
+JSON 파일은 다음 형식의 플러그인 구성을 포함해야 합니다:
+```json
+{
+  "pluginType": {
+    "property1": "value1",
+    "property2": "value2"
+  }
+}
+```
+
+### 예시
+
+#### 자산에 플러그인 추가
+```bash
+mplx core plugins add 5avjMVza8SuMhgTfzEGNWJskDELMCQk9juAAc8zeQoNa --wizard
+```
+
+#### 컬렉션에 플러그인 추가
+```bash
+mplx core plugins add 5avjMVza8SuMhgTfzEGNWJskDELMCQk9juAAc8zeQoNa --wizard --collection
+```
+
+#### JSON을 사용하여 플러그인 추가
+```bash
+mplx core plugins add 5avjMVza8SuMhgTfzEGNWJskDELMCQk9juAAc8zeQoNa ./my-plugin.json
+```
+
+## 출력
+
+플러그인 추가가 성공하면 명령어가 다음을 표시합니다:
+```
+--------------------------------
+  Asset: <assetId>
+  Signature: <transactionSignature>
+  Explorer: <explorerUrl>
+  Core Explorer: https://core.metaplex.com/explorer/<assetId>
+--------------------------------
+```
+
+## 참고사항
+
+- 마법사 모드는 플러그인을 선택하고 구성하는 대화형 방법을 제공합니다
+- 자산과 컬렉션에 대해 다양한 플러그인을 사용할 수 있습니다
+- 플러그인 구성은 플러그인 요구 사항에 따라 유효해야 합니다
+- 자산이나 컬렉션에 플러그인을 추가하려면 적절한 권한이 있어야 합니다
+- 명령어는 다음을 자동으로 처리합니다:
+  - 플러그인 유형 검증
+  - 구성 검증
+  - 거래 서명 및 확인
+  - 권한 확인

src/pages/kr/cli/core/update-asset.md

@@ -0,0 +1,82 @@
+---
+title: 자산 업데이트
+description: MPL Core 자산 메타데이터 및 속성 업데이트
+---
+
+`mplx core asset update` 명령어를 사용하면 메타데이터, 이름, URI 또는 이미지를 수정하여 MPL Core 자산을 업데이트할 수 있습니다. 단일 자산 또는 여러 자산을 한 번에 업데이트할 수 있습니다.
+
+## 기본 사용법
+
+### 단일 자산 업데이트
+```bash
+mplx core asset update <assetId> [options]
+```
+
+### 업데이트 옵션
+- `--name <string>`: 자산의 새 이름
+- `--uri <string>`: 자산 메타데이터의 새 URI
+- `--image <path>`: 새 이미지 파일 경로
+- `--json <path>`: 새 메타데이터가 포함된 JSON 파일 경로
+
+## 업데이트 방법
+
+### 1. 이름과 URI 업데이트
+```bash
+mplx core asset update <assetId> --name "Updated Asset" --uri "https://example.com/metadata.json"
+```
+
+### 2. JSON 파일로 업데이트
+```bash
+mplx core asset update <assetId> --json ./asset/metadata.json
+```
+
+### 3. 이미지로 업데이트
+```bash
+mplx core asset update <assetId> --image ./asset/image.jpg
+```
+
+### 4. JSON과 이미지로 업데이트
+```bash
+mplx core asset update <assetId> --json ./asset/metadata.json --image ./asset/image.jpg
+```
+
+## 예시
+
+### 자산 이름 업데이트
+```bash
+mplx core asset update 5avjMVza8SuMhgTfzEGNWJskDELMCQk9juAAc8zeQoNa --name "New Asset Name"
+```
+
+### 새 이미지로 자산 업데이트
+```bash
+mplx core asset update 5avjMVza8SuMhgTfzEGNWJskDELMCQk9juAAc8zeQoNa --image ./images/new-image.png
+```
+
+### 새 메타데이터로 자산 업데이트
+```bash
+mplx core asset update 5avjMVza8SuMhgTfzEGNWJskDELMCQk9juAAc8zeQoNa --json ./metadata/new-metadata.json
+```
+
+## 출력
+
+업데이트가 성공하면 명령어가 다음을 표시합니다:
+```
+--------------------------------
+  Asset: <assetId>
+  Signature: <transactionSignature>
+  Explorer: <explorerUrl>
+  Core Explorer: https://core.metaplex.com/explorer/<assetId>
+--------------------------------
+```
+
+## 참고사항
+
+- 최소한 하나의 업데이트 플래그를 제공해야 합니다: `--name`, `--uri`, `--image`, `--json` 또는 `--edit`
+- `--name` 및 `--uri` 플래그는 `--json` 또는 `--edit`와 함께 사용할 수 없습니다
+- `--json`을 사용할 때 메타데이터 파일은 유효한 `name` 필드를 포함해야 합니다
+- `--image` 플래그는 메타데이터의 이미지 URI와 이미지 파일 참조를 모두 업데이트합니다
+- 명령어는 다음을 자동으로 처리합니다:
+  - 적절한 스토리지에 파일 업로드
+  - 메타데이터 JSON 형식화
+  - 이미지 파일 유형 감지
+  - 컬렉션 권한 확인

src/pages/kr/cli/index.md

@@ -0,0 +1,80 @@
+---
+title: 소개
+description: Metaplex CLI에 오신 것을 환영합니다
+---
+
+# Metaplex CLI
+
+Metaplex CLI는 Solana에서 Metaplex 프로토콜과 상호작용하기 위한 포괄적인 유틸리티 모음을 제공하는 강력한 명령줄 도구입니다. NFT 애플리케이션을 구축하는 개발자이든 디지털 자산을 관리하는 창작자이든, CLI는 워크플로우를 간소화하는 강력한 기능 세트를 제공합니다.
+
+## 주요 기능
+
+### 핵심 기능
+- MPL Core 자산 및 컬렉션 생성 및 관리
+- 자산 메타데이터 업로드 및 업데이트
+- 자산 및 컬렉션 정보 가져오기
+- 자산 속성 및 특성 관리
+
+### 도구상자 유틸리티
+- 대체 가능한 토큰 생성 및 관리
+- 주소 간 SOL 전송
+- SOL 잔액 확인
+- 테스트 목적의 SOL 에어드롭
+
+### 구성 관리
+- 여러 지갑 관리
+- RPC 엔드포인트 구성
+- 선호하는 블록체인 탐색기 설정
+- CLI 동작 사용자 정의
+
+## CLI를 사용해야 하는 이유
+
+1. **개발자 친화적**: 개발자를 염두에 두고 구축되어 간단한 명령과 고급 옵션을 모두 제공
+2. **대화형 모드**: 복잡한 작업을 위한 사용자 친화적인 마법사
+3. **유연한 구성**: 여러 지갑과 RPC 엔드포인트로 환경을 사용자 정의
+4. **포괄적인 도구**: NFT 및 토큰 관리에 필요한 모든 것을 한 곳에서 제공
+5. **크로스 플랫폼**: Windows, macOS, Linux에서 작동
+
+## 시작하기
+
+1. [CLI 설치](/kr/cli/installation)
+2. 환경 구성:
+   - [지갑 설정](/kr/cli/config/wallets)
+   - [RPC 엔드포인트 구성](/kr/cli/config/rpcs)
+   - [선호하는 탐색기 선택](/kr/cli/config/explorer)
+3. 핵심 명령 사용 시작:
+   - [자산 생성](/kr/cli/core/create-asset)
+   - [컬렉션 생성](/kr/cli/core/create-collection)
+   - [자산 업데이트](/kr/cli/core/update-asset)
+   - [자산 가져오기](/kr/cli/core/fetch)
+
+## 명령 구조
+
+CLI는 계층적 명령 구조를 따릅니다:
+
+```bash
+mplx <category> <command> [options]
+```
+
+카테고리에는 다음이 포함됩니다:
+- `core`: MPL Core 자산 관리
+- `toolbox`: 유틸리티 명령
+- `config`: 구성 관리
+
+## 모범 사례
+
+1. **구성 사용**: 더 원활한 경험을 위해 지갑과 RPC 엔드포인트를 설정
+2. **대화형 모드**: 안내식 작업을 위해 `--wizard` 플래그 사용
+3. **잔액 확인**: 트랜잭션 전에 항상 SOL 잔액 확인
+4. **먼저 테스트**: 메인넷 배포 전에 데브넷 사용
+5. **백업**: 지갑 파일과 구성을 안전하게 보관
+
+## 지원 및 리소스
+
+- [GitHub 저장소](https://github.com/metaplex-foundation/cli)
+- [문서](https://developers.metaplex.com)
+- [Discord 커뮤니티](https://discord.gg/metaplex)
+
+## 다음 단계
+
+시작할 준비가 되셨나요? [설치 가이드](/kr/cli/installation)로 이동하여 시스템에 CLI를 설정하세요.

src/pages/kr/cli/installation.md

@@ -0,0 +1,169 @@
+---
+title: 설치
+description: Metaplex CLI 설치 및 설정
+---
+
+# 설치 가이드
+
+이 가이드는 시스템에 Metaplex CLI를 설치하고 설정하는 방법을 안내합니다.
+
+## 사전 요구사항
+
+CLI를 설치하기 전에 다음을 확인하세요:
+
+- Node.js 16.x 이상
+- npm 7.x 이상
+- Solana 지갑 (선택사항, 권장)
+- Git (선택사항, 개발용)
+
+## 설치 방법
+
+### npm 사용 (권장)
+
+```bash
+npm install -g @metaplex-foundation/cli
+```
+
+### yarn 사용
+
+```bash
+yarn global add @metaplex-foundation/cli
+```
+
+### pnpm 사용
+
+```bash
+pnpm add -g @metaplex-foundation/cli
+```
+
+## 설치 확인
+
+설치 후 CLI가 올바르게 설치되었는지 확인:
+
+```bash
+mplx --version
+```
+
+현재 CLI 버전이 표시되어야 합니다.
+
+## 초기 설정
+
+### 1. 구성 디렉토리 생성
+
+CLI는 처음 구성 설정을 할 때 `~/.config/mplx`에 구성 파일을 자동으로 생성합니다. 이 구성은 다음을 저장합니다:
+- 지갑 구성
+- RPC 엔드포인트 설정
+- 탐색기 기본 설정
+- 기타 CLI 설정
+
+### 2. 환경 구성
+
+#### 지갑 설정
+```bash
+# 새 지갑 생성
+mplx config wallets new --name dev1
+
+# 또는 기존 지갑 추가
+mplx config wallets add <name> <path>
+mplx config wallets add dev1 /path/to/keypair.json
+
+# 지갑을 추가한 후 설정해야 합니다
+mplx config wallets set
+```
+
+추가 정보는 참조
+
+#### RPC 엔드포인트 구성
+```bash
+mplx config set rpcUrl  https://api.mainnet-beta.solana.com
+```
+
+#### 선호하는 탐색기 설정
+```bash
+mplx config explorer set
+```
+
+## 개발 설치
+
+CLI에 기여하거나 소스에서 실행하려면:
+
+1. 저장소 복제:
+```bash
+git clone https://github.com/metaplex-foundation/cli.git
+cd cli
+```
+
+2. 종속성 설치:
+```bash
+npm install
+```
+
+3. 프로젝트 빌드:
+```bash
+npm run build
+```
+
+4. CLI 연결:
+```bash
+npm link
+```
+
+## 문제 해결
+
+### 일반적인 문제
+
+1. **명령을 찾을 수 없음**
+   - 전역 npm bin 디렉토리가 PATH에 있는지 확인
+   - 패키지 재설치 시도
+
+2. **권한 오류**
+   - Unix 기반 시스템에서 전역 설치 시 `sudo` 사용
+   - 또는 sudo 없이 전역 패키지를 설치하도록 npm 구성
+
+3. **Node 버전 문제**
+   - nvm을 사용하여 Node.js 버전 관리
+   - 호환되는 Node.js 버전을 사용하는지 확인
+
+### 도움말
+
+문제가 발생한 경우:
+
+1. [문서](https://developers.metaplex.com) 확인
+2. [GitHub 이슈](https://github.com/metaplex-foundation/cli/issues) 검색
+3. [Discord 커뮤니티](https://discord.gg/metaplex) 참여
+
+## 다음 단계
+
+이제 CLI가 설치되었으므로 다음을 수행할 수 있습니다:
+
+1. [핵심 명령에 대해 알아보기](/kr/cli/core/create-asset)
+2. [도구상자 유틸리티 탐색](/kr/cli/toolbox/token-create)
+3. [환경 구성](/kr/cli/config/wallets)
+
+## 업데이트
+
+CLI를 최신 버전으로 업데이트:
+
+```bash
+npm update -g @metaplex-foundation/cli
+```
+
+yarn으로 설치한 경우:
+
+```bash
+yarn global upgrade @metaplex-foundation/cli
+```
+
+## 제거
+
+CLI를 제거하려면:
+
+```bash
+npm uninstall -g @metaplex-foundation/cli
+```
+
+yarn으로 설치한 경우:
+
+```bash
+yarn global remove @metaplex-foundation/cli
+```

src/pages/kr/cli/toolbox/sol-airdrop.md

@@ -0,0 +1,52 @@
+---
+title: SOL 에어드롭
+description: 지정된 주소로 SOL 에어드롭
+---
+
+`mplx toolbox sol airdrop` 명령어를 사용하면 지정된 주소로 SOL을 에어드롭할 수 있습니다. 이는 테스트 및 개발 목적으로 유용합니다.
+
+## 기본 사용법
+
+### 현재 지갑으로 에어드롭
+```bash
+mplx toolbox sol airdrop <amount>
+```
+
+### 특정 주소로 에어드롭
+```bash
+mplx toolbox sol airdrop <amount> <address>
+```
+
+## 인수
+
+- `amount`: 에어드롭할 SOL 양 (필수)
+- `address`: SOL을 에어드롭할 주소 (선택적, 기본값은 현재 지갑)
+
+## 예시
+
+### 현재 지갑으로 1 SOL 에어드롭
+```bash
+mplx toolbox sol airdrop 1
+```
+
+### 특정 주소로 2 SOL 에어드롭
+```bash
+mplx toolbox sol airdrop 2 5avjMVza8SuMhgTfzEGNWJskDELMCQk9juAAc8zeQoNa
+```
+
+## 출력
+
+에어드롭이 성공하면 명령어가 다음을 표시합니다:
+```
+--------------------------------
+    Airdropped <amount> SOL to <address>
+--------------------------------
+```
+
+## 참고사항
+
+- 이 명령어는 주로 테스트 및 개발 목적으로 사용됩니다
+- 에어드롭 양은 SOL로 지정됩니다 (lamports가 아님)
+- 주소가 제공되지 않으면 SOL은 현재 지갑 주소로 에어드롭됩니다
+- 명령어는 개발 네트워크(devnet/testnet) 연결이 필요합니다
+- 에어드롭 작업을 위해 지갑에 충분한 SOL이 있는지 확인하세요

src/pages/kr/cli/toolbox/sol-balance.md

@@ -0,0 +1,59 @@
+---
+title: SOL 잔액
+description: 지갑 주소의 SOL 잔액 확인
+---
+
+지갑 주소의 SOL 잔액을 확인합니다. 이 명령어를 사용하면 네트워크에 있는 모든 지갑의 SOL 잔액을 빠르게 확인할 수 있습니다.
+
+## 기본 사용법
+
+```bash
+mplx toolbox sol-balance <address>
+```
+
+## 인수
+
+| 인수 | 설명 |
+|----------|-------------|
+| `address` | 확인할 지갑 주소 (선택적, 기본값은 활성 지갑) |
+
+## 예시
+
+### 활성 지갑 잔액 확인
+
+```bash
+mplx toolbox sol-balance
+```
+
+### 특정 지갑 잔액 확인
+
+```bash
+mplx toolbox sol-balance 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU
+```
+
+## 출력
+
+명령어는 SOL 잔액을 형식화된 출력으로 표시합니다:
+
+```
+--------------------------------
+SOL Balance
+--------------------------------
+Address: 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU
+Balance: 1.5 SOL
+--------------------------------
+```
+
+## 참고사항
+
+- 주소가 제공되지 않으면 명령어는 활성 지갑의 잔액을 확인합니다
+- 잔액은 SOL로 표시됩니다 (lamports가 아님)
+- 명령어는 활성 RPC 엔드포인트를 사용합니다
+- 거래에 충분한 SOL이 있는지 확인하세요
+- 잔액은 실시간이며 블록체인의 현재 상태를 반영합니다
+
+## 관련 명령어
+
+- [SOL 전송](/cli/toolbox/sol-transfer) - 주소 간 SOL 전송
+- [토큰 전송](/cli/toolbox/token-transfer) - 토큰 전송
+- [에어드롭](/cli/toolbox/sol-airdrop) - SOL 에어드롭 요청 (devnet만)

src/pages/kr/cli/toolbox/sol-transfer.md

@@ -0,0 +1,43 @@
+---
+title: SOL 전송
+description: 지정된 주소로 SOL 전송
+---
+
+`mplx toolbox sol transfer` 명령어를 사용하면 현재 지갑에서 모든 Solana 주소로 SOL을 전송할 수 있습니다.
+
+## 기본 사용법
+
+```bash
+mplx toolbox sol transfer <amount> <address>
+```
+
+## 인수
+
+- `amount`: 전송할 SOL 양 (필수)
+- `address`: SOL을 전송할 Solana 주소 (필수)
+
+## 예시
+
+### 주소로 1 SOL 전송
+```bash
+mplx toolbox sol transfer 1 5avjMVza8SuMhgTfzEGNWJskDELMCQk9juAAc8zeQoNa
+```
+
+## 출력
+
+전송이 성공하면 명령어가 다음을 표시합니다:
+```
+--------------------------------
+    Transferred <amount> SOL to <address>
+    Signature: <transactionSignature>
+--------------------------------
+```
+
+## 참고사항
+
+- 전송 양은 SOL로 지정됩니다 (lamports가 아님)
+- 대상 주소는 유효한 Solana 공개 키여야 합니다
+- 명령어는 Solana 네트워크(mainnet/devnet/testnet)에 대한 연결이 필요합니다
+- 전송을 위해 지갑에 충분한 SOL이 있는지 확인하세요
+- 거래 서명은 확인 목적으로 제공됩니다
+- 전송은 블록체인에서 확인되면 되돌릴 수 없습니다

src/pages/kr/cli/toolbox/token-create.md

@@ -0,0 +1,91 @@
+---
+title: 토큰 생성
+description: Solana에서 새 대체 가능 토큰 생성
+---
+
+`mplx toolbox token create` 명령어를 사용하면 Solana에서 새로운 대체 가능 토큰을 생성할 수 있습니다. 대화형 마법사를 사용하거나 필요한 모든 정보를 직접 제공하는 두 가지 방법으로 토큰을 생성할 수 있습니다.
+
+## 기본 사용법
+
+### 대화형 마법사
+```bash
+mplx toolbox token create --wizard
+```
+
+### 직접 생성
+```bash
+mplx toolbox token create --name "My Token" --symbol "TOKEN" --mint-amount 1000000
+```
+
+## 옵션
+
+### 필수 옵션 (마법사를 사용하지 않을 때)
+- `--name <string>`: 토큰 이름 (예: "My Awesome Token")
+- `--symbol <string>`: 토큰 심볼 (2-6자, 예: "MAT")
+- `--mint-amount <number>`: 발행할 토큰의 초기 양 (0보다 커야 함)
+
+### 선택적 옵션
+- `--decimals <number>`: 소수점 자릿수 (0-9, 기본값: 0)
+- `--description <string>`: 토큰과 그 목적에 대한 설명
+- `--image <path>`: 토큰 이미지 파일 경로 (PNG, JPG 또는 GIF)
+- `--speed-run`: 실행 시간을 측정하기 위한 스피드런 모드 활성화
+
+## 예시
+
+### 기본 정보로 토큰 생성
+```bash
+mplx toolbox token create --name "My Token" --symbol "TOKEN" --mint-amount 1000000
+```
+
+### 모든 옵션으로 토큰 생성
+```bash
+mplx toolbox token create \
+  --name "My Awesome Token" \
+  --symbol "MAT" \
+  --description "A token for awesome things" \
+  --image ./token-image.png \
+  --decimals 2 \
+  --mint-amount 1000000
+```
+
+### 마법사를 사용하여 토큰 생성
+```bash
+mplx toolbox token create --wizard
+```
+
+## 출력
+
+토큰 생성이 성공하면 명령어가 다음을 표시합니다:
+```
+--------------------------------
+Token created successfully!
+
+Token Details:
+Name: <name>
+Symbol: <symbol>
+Decimals: <decimals>
+Initial Supply: <formattedAmount>
+
+Mint Address: <mintAddress>
+Explorer: <explorerUrl>
+
+Transaction Signature: <signature>
+Explorer: <transactionExplorerUrl>
+Execution Time: <time> seconds
+--------------------------------
+```
+
+## 참고사항
+
+- 토큰 심볼은 2-6자 길이여야 합니다
+- 발행 양은 0보다 커야 합니다
+- 소수점은 토큰의 최소 단위를 결정합니다 (예: 소수점 2자리는 100 토큰 = 100_00을 의미)
+- 이미지 파일은 PNG, JPG 또는 GIF 형식이어야 합니다
+- 마법사는 필요한 모든 필드를 대화형으로 안내합니다
+- 명령어는 자동으로 다음을 처리합니다:
+  - 토큰 이미지 업로드 (제공된 경우)
+  - 토큰 메타데이터 생성 및 업로드
+  - 블록체인에서 토큰 생성
+  - 초기 공급량 발행
+- 거래 서명과 발행 주소는 확인을 위해 제공됩니다
+- 스피드런 모드는 실행 시간을 측정하는 데 사용할 수 있습니다

src/pages/kr/cli/toolbox/token-transfer.md

@@ -0,0 +1,66 @@
+---
+title: 토큰 전송
+description: 대상 주소로 토큰 전송
+---
+
+지갑에서 대상 주소로 토큰을 전송합니다. 대상 지갑에 토큰 계정이 없으면 자동으로 생성됩니다.
+
+## 기본 사용법
+
+```bash
+mplx toolbox token transfer <mintAddress> <amount> <destination>
+```
+
+## 인수
+
+| 인수 | 설명 |
+|----------|-------------|
+| `mintAddress` | 전송할 토큰의 발행 주소 |
+| `amount` | 베이시스 포인트로 전송할 토큰 양 |
+| `destination` | 대상 지갑 주소 |
+
+## 예시
+
+### 대상 주소로 100 토큰 전송
+
+```bash
+mplx toolbox token transfer 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU 10000000000 9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM
+```
+
+## 출력
+
+명령어는 토큰을 전송하는 동안 진행률 스피너를 표시하고 성공 시 거래 서명을 보여줍니다:
+
+```
+--------------------------------
+Token Transfer         
+--------------------------------
+⠋ Transferring tokens...
+✔ Tokens Transferred Successfully!
+--------------------------------
+'Tokens Transferred Successfully!'
+Signature: 2xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU
+--------------------------------
+```
+
+## 참고사항
+
+- 명령어는 대상 주소에 토큰 계정이 없으면 자동으로 생성합니다
+- 양은 베이시스 포인트로 지정됩니다 (토큰 1개 = 베이시스 포인트 1,000,000,000개)
+- 새 토큰 계정을 생성하는 경우 임대 면제를 위해 SOL이 필요합니다
+- 전송하기 전에 지갑에 충분한 토큰이 있는지 확인하세요
+
+## 오류 처리
+
+전송이 실패하면 명령어가 오류 메시지를 표시하고 예외를 발생시킵니다. 일반적인 오류는 다음과 같습니다:
+
+- 토큰 잔액 부족
+- 유효하지 않은 발행 주소
+- 유효하지 않은 대상 주소
+- 네트워크 오류
+
+## 관련 명령어
+
+- [토큰 생성](/cli/toolbox/token-create) - 새 토큰 생성
+- [잔액 확인](/cli/toolbox/sol-balance) - 토큰 잔액 확인
+- [SOL 전송](/cli/toolbox/sol-transfer) - 주소 간 SOL 전송

src/pages/kr/core/collections.md

@@ -0,0 +1,467 @@
+---
+title: 컬렉션 관리
+metaTitle: 검증된 컬렉션 | Core
+description: Metaplex Core 패키지를 사용하여 자산을 컬렉션에 추가하고 제거하는 등 Core 컬렉션을 관리하는 방법을 알아보세요.
+---
+
+## 컬렉션이란 무엇인가요?
+
+컬렉션은 함께 속하는 자산들의 그룹으로, 같은 시리즈나 그룹의 일부입니다. 자산을 함께 그룹화하기 위해서는 먼저 컬렉션 이름과 컬렉션 이미지와 같은 컬렉션과 관련된 메타데이터를 저장하는 목적을 가진 컬렉션 자산을 생성해야 합니다. 컬렉션 자산은 컬렉션의 표지 역할을 하며 컬렉션 전체 플러그인을 저장할 수도 있습니다.
+
+컬렉션 자산에서 저장되고 액세스할 수 있는 데이터는 다음과 같습니다:
+
+| 계정            | 설명                                              |
+| --------------- | ------------------------------------------------- |
+| key             | 계정 키 구분자                                    |
+| updateAuthority | 새 자산의 권한                                    |
+| name            | 컬렉션 이름                                       |
+| uri             | 컬렉션의 오프체인 메타데이터에 대한 URI           |
+| num minted      | 컬렉션에서 민팅된 자산 수                         |
+| current size    | 현재 컬렉션에 있는 자산 수                        |
+
+## 컬렉션 생성
+
+Core 컬렉션을 생성하려면 다음과 같이 `CreateCollection` 명령어를 사용할 수 있습니다:
+
+{% totem %}
+{% totem-accordion title="기술적 명령어 세부사항 - CreateCollectionV1" %}
+
+**명령어 계정 목록**
+
+| 계정            | 설명                                              |
+| --------------- | ------------------------------------------------- |
+| collection      | Core 자산이 속한 컬렉션                           |
+| updateAuthority | 새 자산의 권한                                    |
+| payer           | 저장 수수료를 지불하는 계정                       |
+| systemProgram   | 시스템 프로그램 계정                              |
+
+**명령어 인수**
+
+| 인수    | 설명                                              |
+| ------- | ------------------------------------------------- |
+| name    | Core 자산이 속한 컬렉션                           |
+| uri     | 새 자산의 권한                                    |
+| plugins | 컬렉션이 가져야 할 플러그인                       |
+
+일부 계정과 인수는 사용 편의성을 위해 SDK에서 추상화되거나 선택적일 수 있습니다.
+온체인 명령어에 대한 자세한 내용은 [Github](https://github.com/metaplex-foundation/mpl-core/blob/5a45f7b891f2ca58ad1fc18e0ebdd0556ad59a4b/programs/mpl-core/src/instruction.rs#L30)에서 확인할 수 있습니다.
+
+{% /totem-accordion %}
+{% /totem %}
+
+### 간단한 컬렉션 생성
+
+다음 코드는 플러그인이나 특별한 것 없이 간단한 컬렉션을 생성합니다.
+
+{% dialect-switcher title="MPL Core 컬렉션 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { generateSigner } from '@metaplex-foundation/umi'
+import { createCollection } from '@metaplex-foundation/mpl-core'
+
+const collectionSigner = generateSigner(umi)
+
+await createCollection(umi, {
+  collection: collectionSigner,
+  name: 'My Collection',
+  uri: 'https://example.com/my-collection.json',
+})
+```
+
+{% /dialect %}
+
+{% dialect title="Rust" id="rust" %}
+
+```rust
+use mpl_core::instructions::CreateCollectionV1Builder;
+use solana_client::nonblocking::rpc_client;
+use solana_sdk::{signature::Keypair, signer::Signer, transaction::Transaction};
+
+pub async fn create_collection() {
+    let rpc_client = rpc_client::RpcClient::new("https://api.devnet.solana.com".to_string());
+
+    let payer = Keypair::new();
+    let collection = Keypair::new();
+
+    let create_collection_ix = CreateCollectionV1Builder::new()
+        .collection(collection.pubkey())
+        .payer(payer.pubkey())
+        .name("My Collection".into())
+        .uri("https://example.com/my-collection.json".into())
+        .instruction();
+
+    let signers = vec![&collection, &payer];
+
+    let last_blockhash = rpc_client.get_latest_blockhash().await.unwrap();
+
+    let create_collection_tx = Transaction::new_signed_with_payer(
+        &[create_collection_ix],
+        Some(&payer.pubkey()),
+        &signers,
+        last_blockhash,
+    );
+
+    let res = rpc_client
+        .send_and_confirm_transaction(&create_collection_tx)
+        .await
+        .unwrap();
+
+    println!("Signature: {:?}", res)
+}
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+### 플러그인과 함께 컬렉션 생성
+
+다음 코드는 [로열티 플러그인](/kr/core/plugins/royalties)이 연결된 컬렉션을 생성합니다. [여기](/kr/core/plugins)에 설명된 대로 추가 플러그인을 연결할 수 있습니다.
+
+{% dialect-switcher title="플러그인과 함께 MPL Core 컬렉션 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { generateSigner, publicKey } from '@metaplex-foundation/umi'
+import { createCollection, ruleSet } from '@metaplex-foundation/mpl-core'
+
+const collectionSigner = generateSigner(umi)
+
+const creator1 = publicKey('11111111111111111111111111111111')
+const creator2 = publicKey('22222222222222222222222222222222')
+
+await createCollection(umi, {
+  collection: collectionSigner,
+  name: 'My NFT',
+  uri: 'https://example.com/my-nft.json',
+  plugins: [
+    {
+      type: 'Royalties',
+      basisPoints: 500,
+      creators: [
+        {
+          address: creator1,
+          percentage: 20,
+        },
+        {
+          address: creator2,
+          percentage: 80,
+        },
+      ],
+      ruleSet: ruleSet('None'), // 호환성 규칙 세트
+    },
+  ],
+}).sendAndConfirm(umi)
+```
+
+{% /dialect %}
+
+{% dialect title="Rust" id="rust" %}
+
+```rust
+use mpl_core::{
+    instructions::CreateCollectionV1Builder,
+    types::{Creator, Plugin, PluginAuthority, PluginAuthorityPair, Royalties, RuleSet},
+};
+use solana_client::nonblocking::rpc_client;
+use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer, transaction::Transaction};
+use std::str::FromStr;
+
+pub async fn create_collection_with_plugin() {
+    let rpc_client = rpc_client::RpcClient::new("https://api.devnet.solana.com".to_string());
+
+    let payer = Keypair::new();
+    let collection = Keypair::new();
+
+    let creator = Pubkey::from_str("11111111111111111111111111111111").unwrap();
+
+    let create_collection_ix = CreateCollectionV1Builder::new()
+        .collection(collection.pubkey())
+        .payer(payer.pubkey())
+        .name("My Nft".into())
+        .uri("https://example.com/my-nft.json".into())
+        .plugins(vec![PluginAuthorityPair {
+            plugin: Plugin::Royalties(Royalties {
+                basis_points: 500,
+                creators: vec![Creator {
+                    address: creator,
+                    percentage: 100,
+                }],
+                rule_set: RuleSet::None,
+            }),
+            authority: Some(PluginAuthority::None),
+        }])
+        .instruction();
+
+    let signers = vec![&collection, &payer];
+
+    let last_blockhash = rpc_client.get_latest_blockhash().await.unwrap();
+
+    let create_collection_tx = Transaction::new_signed_with_payer(
+        &[create_collection_ix],
+        Some(&payer.pubkey()),
+        &signers,
+        last_blockhash,
+    );
+
+    let res = rpc_client
+        .send_and_confirm_transaction(&create_collection_tx)
+        .await
+        .unwrap();
+
+    println!("Signature: {:?}", res)
+}
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 컬렉션 가져오기
+
+컬렉션을 가져오려면 다음 함수를 사용할 수 있습니다:
+
+{% dialect-switcher title="컬렉션 가져오기" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { fetchCollectionV1 } from '@metaplex-foundation/mpl-core'
+import { publicKey } from '@metaplex-foundation/umi'
+
+const collectionId = publicKey('11111111111111111111111111111111')
+
+const collection = await fetchCollection(umi, collectionId)
+
+console.log(collection)
+```
+
+{% /dialect %}
+
+{% dialect title="Rust" id="rust" %}
+
+```rust
+use std::str::FromStr;
+use mpl_core::Collection;
+use solana_client::nonblocking::rpc_client;
+use solana_sdk::pubkey::Pubkey;
+
+pub async fn fetch_collection() {
+    let rpc_client = rpc_client::RpcClient::new("https://api.devnet.solana.com".to_string());
+
+    let collection_id = Pubkey::from_str("11111111111111111111111111111111").unwrap();
+
+    let rpc_data = rpc_client.get_account_data(&collection_id).await.unwrap();
+
+    let collection = Collection::from_bytes(&rpc_data).unwrap();
+
+    print!("{:?}", collection)
+}
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 컬렉션 업데이트
+
+Core 컬렉션의 데이터를 업데이트하려면 `UpdateCollection` 명령어를 사용하세요. 예를 들어, 이 명령어를 사용하여 컬렉션의 이름을 변경할 수 있습니다.
+
+{% totem %}
+{% totem-accordion title="기술적 명령어 세부사항 - UpdateCollectionV1" %}
+
+**명령어 계정 목록**
+
+| 계정               | 설명                                              |
+| ------------------ | ------------------------------------------------- |
+| collection         | Core 자산이 속한 컬렉션                           |
+| payer              | 저장 수수료를 지불하는 계정                       |
+| authority          | 새 자산의 권한                                    |
+| newUpdateAuthority | 컬렉션의 새 업데이트 권한                         |
+| systemProgram      | 시스템 프로그램 계정                              |
+| logWrapper         | SPL Noop 프로그램                                 |
+
+**명령어 인수**
+
+| 인수 | 설명                          |
+| ---- | ----------------------------- |
+| name | MPL Core 자산의 이름          |
+| uri  | 오프체인 JSON 메타데이터 URI  |
+
+일부 계정과 인수는 사용 편의성을 위해 SDK에서 추상화되거나 선택적일 수 있습니다.
+온체인 명령어에 대한 자세한 내용은 [Github](https://github.com/metaplex-foundation/mpl-core/blob/5a45f7b891f2ca58ad1fc18e0ebdd0556ad59a4b/programs/mpl-core/src/instruction.rs#L167C4-L167C23)에서 확인할 수 있습니다.
+
+{% /totem-accordion %}
+{% /totem %}
+
+{% seperator h="6" /%}
+
+{% dialect-switcher title="컬렉션 업데이트" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { publicKey } from '@metaplex-foundation/umi'
+import { updateCollection } from '@metaplex-foundation/mpl-core'
+
+const collectionAddress = publicKey('1111111111111111111111111111111')
+
+await updateCollection(umi, {
+  collection: collectionAddress,
+  name: 'my-nft',
+  uri: 'https://exmaple.com/new-uri',
+}).sendAndConfirm(umi)
+```
+
+{% /dialect %}
+{% dialect title="Rust" id="rust" %}
+
+```rust
+use std::str::FromStr;
+
+use mpl_core::instructions::UpdateCollectionV1Builder;
+use solana_client::nonblocking::rpc_client;
+use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer, transaction::Transaction};
+
+pub async fn update_collection() {
+
+    let rpc_client = rpc_client::RpcClient::new("https://api.devnet.solana.com".to_string());
+
+    let authority = Keypair::new();
+    let collection = Pubkey::from_str("11111111111111111111111111111111").unwrap();
+
+    let update_collection_ix = UpdateCollectionV1Builder::new()
+        .collection(collection)
+        .payer(authority.pubkey())
+        .new_name("My Collection".into())
+        .new_uri("https://example.com/my-collection.json".into())
+        .instruction();
+
+    let signers = vec![&authority];
+
+    let last_blockhash = rpc_client.get_latest_blockhash().await.unwrap();
+
+    let update_collection_tx = Transaction::new_signed_with_payer(
+        &[update_collection_ix],
+        Some(&authority.pubkey()),
+        &signers,
+        last_blockhash,
+    );
+
+    let res = rpc_client
+        .send_and_confirm_transaction(&update_collection_tx)
+        .await
+        .unwrap();
+
+    println!("Signature: {:?}", res)
+}
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 컬렉션 플러그인 업데이트
+
+Core 컬렉션에 연결된 플러그인의 동작을 변경하려면 `updateCollectionPlugin` 명령어를 사용할 수 있습니다.
+
+{% totem %}
+{% totem-accordion title="기술적 명령어 세부사항 - UpdateCollectionPluginV1" %}
+
+**명령어 계정 목록**
+
+| 계정          | 설명                                              |
+| ------------- | ------------------------------------------------- |
+| collection    | Core 자산이 속한 컬렉션                           |
+| payer         | 저장 수수료를 지불하는 계정                       |
+| authority     | 새 자산의 권한                                    |
+| systemProgram | 시스템 프로그램 계정                              |
+| logWrapper    | SPL Noop 프로그램                                 |
+
+**명령어 인수**
+
+| 인수   | 설명                        |
+| ------ | --------------------------- |
+| plugin | 업데이트하려는 플러그인     |
+
+일부 계정은 사용 편의성을 위해 SDK에서 추상화되거나 선택적일 수 있습니다.
+온체인 명령어에 대한 자세한 내용은 [Github](https://github.com/metaplex-foundation/mpl-core/blob/5a45f7b891f2ca58ad1fc18e0ebdd0556ad59a4b/programs/mpl-core/src/instruction.rs#L81)에서 확인할 수 있습니다.
+
+{% /totem-accordion %}
+{% /totem %}
+
+{% seperator h="6" /%}
+
+{% dialect-switcher title="컬렉션 플러그인 업데이트" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { publicKey } from '@metaplex-foundation/umi'
+import { updateCollectionPlugin, ruleSet } from '@metaplex-foundation/mpl-core'
+
+const collectionAddress = publicKey('1111111111111111111111111111111')
+
+const newCreator = publicKey('5555555555555555555555555555555')
+
+await updateCollectionPlugin(umi, {
+  collection: collectionAddress,
+  plugin: {
+    type: 'Royalties',
+    basisPoints: 400,
+    creators: [{ address: newCreator, percentage: 100 }],
+    ruleSet: ruleSet('None'),
+  },
+}).sendAndConfirm(umi)
+```
+
+{% /dialect %}
+
+{% dialect title="Rust" id="rust" %}
+
+```rust
+use std::str::FromStr;
+use mpl_core::{
+    instructions::UpdateCollectionPluginV1Builder,
+    types::{Creator, Plugin, Royalties, RuleSet},
+};
+use solana_client::nonblocking::rpc_client;
+use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer, transaction::Transaction};
+
+pub async fn update_collection_plugin() {
+    let rpc_client = rpc_client::RpcClient::new("https://api.devnet.solana.com".to_string());
+
+    let authority = Keypair::new();
+    let collection = Pubkey::from_str("11111111111111111111111111111111").unwrap();
+
+    let new_creator = Pubkey::from_str("22222222222222222222222222222222").unwrap();
+
+    let update_collection_plugin_ix = UpdateCollectionPluginV1Builder::new()
+        .collection(collection)
+        .payer(authority.pubkey())
+        .plugin(Plugin::Royalties(Royalties {
+            basis_points: 500,
+            creators: vec![Creator {
+                address: new_creator,
+                percentage: 100,
+            }],
+            rule_set: RuleSet::None,
+        }))
+        .instruction();
+
+    let signers = vec![&authority];
+
+    let last_blockhash = rpc_client.get_latest_blockhash().await.unwrap();
+
+    let update_collection_plugin_tx = Transaction::new_signed_with_payer(
+        &[update_collection_plugin_ix],
+        Some(&payer.pubkey()),
+        &signers,
+        last_blockhash,
+    );
+
+    let res = rpc_client
+        .send_and_confirm_transaction(&update_collection_plugin_tx)
+        .await
+        .unwrap();
+
+    println!("Signature: {:?}", res)
+}
+```
+
+{% /dialect %}
+{% /dialect-switcher %}

src/pages/kr/core/create-asset.md

@@ -0,0 +1,419 @@
+---
+title: 자산 생성하기
+metaTitle: 자산 생성하기 | Core
+description: Metaplex Core 패키지를 사용하여 Core NFT 자산을 생성하는 방법을 알아보세요.
+---
+
+[Core 개요](/kr/core)에서 논의한 바와 같이, Core의 디지털 자산은 정확히 하나의 온체인 계정과 토큰을 설명하는 오프체인 데이터로 구성됩니다. 이 페이지에서는 이러한 자산을 민팅하는 과정을 살펴보겠습니다. {% .lead %}
+
+## 생성 과정
+
+1. **오프체인 데이터 업로드.** 먼저 오프체인 데이터가 준비되어 있는지 확인해야 합니다. 이는 자산을 설명하는 JSON 파일이 어딘가에 저장되어 있어야 함을 의미합니다. JSON 파일이 **URI**를 통해 액세스할 수 있다면 어떻게, 어디에 저장되는지는 중요하지 않습니다. 오프체인 메타데이터는 [기존 토큰 메타데이터 표준](/kr/token-metadata/token-standard#the-non-fungible-standard)과 유사하게 보일 수 있습니다.
+2. **온체인 자산 계정 생성.** 그런 다음 자산의 데이터를 보관할 온체인 자산 계정을 생성해야 합니다.
+
+구체적인 코드 예제를 제공하면서 이러한 단계를 더 자세히 살펴보겠습니다.
+
+## 오프체인 데이터 업로드
+
+모든 저장 서비스(Arweave, IPFS, AWS 등...)를 사용하여 오프체인 데이터를 업로드하거나 단순히 자체 서버에 저장할 수 있습니다. 사용자에게 이 중 일부를 더 쉽게 만들기 위해 `Umi`는 `Irys(Arweave에 업로드)` 및 `nftStorage(IPFS에 업로드)`와 같은 전용 플러그인을 가지고 있습니다. 플러그인이 선택되면 사용자에게 데이터를 업로드할 수 있는 통합 인터페이스가 제공됩니다.
+
+{% dialect-switcher title="자산과 JSON 데이터 업로드" %}
+{% dialect title="JavaScript" id="js" %}
+{% totem %}
+
+```ts
+const [imageUri] = await umi.uploader.upload([imageFile])
+const uri = await umi.uploader.uploadJson({
+  name: 'My NFT',
+  description: 'This is my NFT',
+  image: imageUri,
+  // ...
+})
+```
+
+{% totem-accordion title="업로더 선택" %}
+
+Umi를 사용하여 원하는 업로더를 선택하려면 업로더에서 제공하는 플러그인을 설치하기만 하면 됩니다.
+
+예를 들어, Irys 플러그인을 설치하는 방법은 다음과 같습니다:
+
+```ts
+import { irysUploader } from '@metaplex-foundation/umi-uploader-irys'
+
+umi.use(irysUploader())
+```
+
+{% /totem-accordion %}
+
+{% /totem %}
+{% /dialect %}
+{% /dialect-switcher %}
+
+이제 **URI**가 있으므로 다음 단계로 넘어갈 수 있습니다.
+
+## 자산 생성
+
+자산을 생성하려면 `createV1` 명령어를 사용하세요. `createV1` 명령어는 자산의 기본 메타데이터를 설정하는 것 외에도 자산을 컬렉션에 추가하고 플러그인을 할당하는 것을 포함합니다. 이는 [나중에](#create-an-asset-with-plugins) 설명됩니다.
+
+다음은 간단한 예시입니다:
+
+{% totem %}
+{% totem-accordion title="기술적 명령어 세부사항" %}
+**명령어 계정 목록**
+
+| 계정          | 설명                                                   |
+| ------------- | ------------------------------------------------------ |
+| asset         | MPL Core 자산의 주소                                   |
+| collection    | Core 자산이 속한 컬렉션                               |
+| authority     | 새 자산의 권한                                         |
+| payer         | 저장 수수료를 지불하는 계정                            |
+| new owner     | 자산을 받을 소유자                                     |
+| systemProgram | 시스템 프로그램 계정                                   |
+| logWrapper    | SPL Noop 프로그램                                      |
+
+**명령어 인수**
+
+| 인수      | 설명                                                        |
+| --------- | ----------------------------------------------------------- |
+| dataState | 데이터가 계정 상태에 저장되는지 장부 상태에 저장되는지      |
+| name      | MPL Core 자산의 이름                                        |
+| uri       | 오프체인 JSON 메타데이터 URI                                |
+| plugins   | 자산이 가져야 할 플러그인                                   |
+
+일부 계정/인수는 사용 편의성을 위해 SDK에서 추상화되거나 선택적일 수 있습니다.
+온체인 명령어에 대한 자세한 내용은 [Github](https://github.com/metaplex-foundation/mpl-core/blob/5a45f7b891f2ca58ad1fc18e0ebdd0556ad59a4b/programs/mpl-core/src/instruction.rs#L18)에서 확인할 수 있습니다.
+
+{% /totem-accordion %}
+{% /totem %}
+
+{% seperator h="6" /%}
+
+{% dialect-switcher title="자산 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { generateSigner, publicKey } from '@metaplex-foundation/umi'
+import { create } from '@metaplex-foundation/mpl-core'
+
+const assetSigner = generateSigner(umi)
+
+const result = await create(umi, {
+  asset: assetSigner,
+  name: 'My Asset',
+  uri: 'https://example.com/my-asset.json',
+  //owner: publicKey('11111111111111111111111111111111'), //다른 지갑으로 민팅하기 위한 선택 사항
+}).sendAndConfirm(umi)
+```
+
+{% /dialect %}
+
+{% dialect title="Rust" id="rust" %}
+
+```rust
+use mpl_core::instructions::CreateV1Builder;
+use solana_client::nonblocking::rpc_client;
+use solana_sdk::{signature::Keypair, signer::Signer, transaction::Transaction};
+
+
+pub async fn create_asset() {
+
+    let rpc_client = rpc_client::RpcClient::new("https://api.devnet.solana.com".to_string());
+
+    let payer = Keypair::new();
+    let asset = Keypair::new();
+
+    let create_asset_ix = CreateV1Builder::new()
+        .asset(asset.pubkey())
+        .payer(payer.pubkey())
+        .name("My Nft".into())
+        .uri("https://example.com/my-nft.json".into())
+        .instruction();
+
+    let signers = vec![&asset, &payer];
+
+    let last_blockhash = rpc_client.get_latest_blockhash().await.unwrap();
+
+    let create_asset_tx = Transaction::new_signed_with_payer(
+        &[create_asset_ix],
+        Some(&payer.pubkey()),
+        &signers,
+        last_blockhash,
+    );
+
+    let res = rpc_client.send_and_confirm_transaction(&create_asset_tx).await.unwrap();
+
+    println!("Signature: {:?}", res)
+}
+```
+
+{% /dialect %}
+
+{% dialect title="Rust (CPI)" id="rust-cpi" %}
+
+```rust
+let create_ix = CreateV1CpiBuilder::new()
+        .asset(input.asset.pubkey())
+        .collection(input.collection)
+        .authority(input.authority)
+        .payer(payer)
+        .owner(input.owner)
+        .update_authority(input.update_authority)
+        .system_program(system_program::ID)
+        .data_state(input.data_state.unwrap_or(DataState::AccountState))
+        .name(input.name.unwrap_or(DEFAULT_ASSET_NAME.to_owned()))
+        .uri(input.uri.unwrap_or(DEFAULT_ASSET_URI.to_owned()))
+        .plugins(input.plugins)
+        .invoke();
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 컬렉션에 자산 생성
+
+MPL Core 자산은 MPL Core 컬렉션이 이미 존재하는 경우 컬렉션에 바로 생성할 수 있습니다. 컬렉션 자산을 생성하려면 [여기](/kr/core/collections)를 방문하세요.
+
+{% dialect-switcher title="컬렉션에 자산 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { generateSigner, publicKey } from '@metaplex-foundation/umi'
+import {
+  createCollection,
+  create,
+  fetchCollection,
+} from '@metaplex-foundation/mpl-core'
+
+const collectionSigner = generateSigner(umi)
+
+// 컬렉션 생성
+// 단일 스크립트에서 이를 수행하는 경우
+// sleep 함수를 사용하거나 'finalized' 커밋 레벨을
+// 사용해야 할 수 있습니다. 이렇게 하면 컬렉션이
+// 완전히 작성된 후 변경 사항을 가져올 수 있습니다.
+await createCollection(umi, {
+  collection: collectionSigner,
+  name: 'My Collection',
+  uri: 'https://example.com/my-collection.json',
+}).sendAndConfirm(umi)
+
+// 컬렉션 가져오기
+const collection = await fetchCollection(umi, collectionSigner.publicKey)
+
+
+// assetSigner 생성 후 자산 생성
+const assetSigner = generateSigner(umi)
+
+await create(umi, {
+  asset: assetSigner,
+  collection: collection,
+  name: 'My Asset',
+  uri: 'https://example.com/my-asset.json',
+  //owner: publicKey('11111111111111111111111111111111'), //다른 지갑으로 민팅하기 위한 선택 사항
+}).sendAndConfirm(umi)
+```
+
+{% /dialect %}
+{% dialect title="Rust" id="rust" %}
+
+```rust
+use mpl_core::instructions::{CreateCollectionV1Builder, CreateV1Builder};
+use solana_client::nonblocking::rpc_client;
+use solana_sdk::{signature::Keypair, signer::Signer, transaction::Transaction};
+
+pub async fn create_asset_with_collection() {
+    let rpc_client = rpc_client::RpcClient::new("https://api.devnet.solana.com".to_string());
+
+    let signer = Keypair::new(); // 여기서 키페어 로드
+
+    let collection = Keypair::new();
+
+    let create_collection_ix = CreateCollectionV1Builder::new()
+        .collection(collection.pubkey())
+        .payer(signer.pubkey())
+        .name("My Collection".into())
+        .uri("https://example.com/my-collection.json".into())
+        .instruction();
+
+    let signers = vec![&collection, &signer];
+
+    let last_blockhash = rpc_client.get_latest_blockhash().await.unwrap();
+
+    let create_collection_tx = Transaction::new_signed_with_payer(
+        &[create_collection_ix],
+        Some(&signer.pubkey()),
+        &signers,
+        last_blockhash,
+    );
+
+    let res = rpc_client
+        .send_and_confirm_transaction(&create_collection_tx)
+        .await
+        .unwrap();
+
+    println!("Signature: {:?}", res);
+
+    let asset = Keypair::new();
+
+    let create_asset_ix = CreateV1Builder::new()
+        .asset(asset.pubkey())
+        .collection(Some(collection.pubkey()))
+        .payer(signer.pubkey())
+        .name("My Nft".into())
+        .uri("https://example.com/my-nft.json".into())
+        .instruction();
+
+    let signers = vec![&asset, &signer];
+
+    let last_blockhash = rpc_client.get_latest_blockhash().await.unwrap();
+
+    let create_asset_tx = Transaction::new_signed_with_payer(
+        &[create_asset_ix],
+        Some(&signer.pubkey()),
+        &signers,
+        last_blockhash,
+    );
+
+    let res = rpc_client
+        .send_and_confirm_transaction(&create_asset_tx)
+        .await
+        .unwrap();
+
+    println!("Signature: {:?}", res)
+}
+```
+
+{% /dialect %}
+
+{% dialect title="Rust (CPI)" id="rust-cpi" %}
+
+```rust
+let create_ix = CreateV1CpiBuilder::new(input.program)
+    .asset(input.asset.pubkey())
+    .collection(Some(input.collection))
+    .authority(Some(input.authority))
+    .payer(input.payer)
+    .owner(Some(input.owner))
+    .update_authority(Some(input.update_authority))
+    .system_program(system_program::ID)
+    .data_state(input.data_state.unwrap_or(DataState::AccountState))
+    .name(input.name)
+    .uri(input.uri)
+    .plugins(input.plugins)
+    .invoke();
+```
+
+{% /dialect %}
+
+{% /dialect-switcher %}
+
+## 플러그인과 함께 자산 생성
+
+MPL Core 자산은 컬렉션과 자산 레벨 모두에서 플러그인 사용을 지원합니다. 플러그인과 함께 Core 자산을 생성하려면 생성 중에 `plugins` 배열 인수에 플러그인 타입과 매개변수를 전달합니다. 아래 예시는 `Freeze` 플러그인으로 민트를 생성합니다.
+
+{% dialect-switcher title="플러그인과 함께 자산 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+```ts
+import { generateSigner } from '@metaplex-foundation/umi'
+import { create, ruleSet } from '@metaplex-foundation/mpl-core'
+
+const creator1 = publicKey('11111111111111111111111111111111')
+const creator2 = publicKey('22222222222222222222222222222222')
+
+const assetSigner = generateSigner(umi)
+
+await create(umi, {
+  asset: assetSigner,
+  name: 'My Asset',
+  uri: 'https://example.com/my-asset.json',
+  plugins: [
+    {
+      type: 'Royalties',
+      basisPoints: 500,
+      creators: [
+        {
+          address: creator1,
+          percentage: 20,
+        },
+        {
+          address: creator2,
+          percentage: 80,
+        },
+      ],
+      ruleSet: ruleSet('None'), // 호환성 규칙 세트
+    },
+  ],
+}).sendAndConfirm(umi)
+```
+
+{% /dialect %}
+
+{% dialect title="Rust" id="rust" %}
+
+```rust
+use std::str::FromStr;
+use mpl_core::{
+    instructions::CreateV1Builder,
+    types::{Creator, Plugin, PluginAuthority, PluginAuthorityPair, Royalties, RuleSet},
+};
+use solana_client::nonblocking::rpc_client;
+use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer, transaction::Transaction};
+
+pub async fn create_asset_with_plugin() {
+    let rpc_client = rpc_client::RpcClient::new("https://api.devnet.solana.com".to_string());
+
+    let payer = Keypair::new();
+    let asset = Keypair::new();
+
+    let creator = Pubkey::from_str("11111111111111111111111111111111").unwrap();
+
+    let create_asset_with_plugin_ix = CreateV1Builder::new()
+        .asset(asset.pubkey())
+        .payer(payer.pubkey())
+        .name("My Nft".into())
+        .uri("https://example.com/my-nft.json".into())
+        .plugins(vec![PluginAuthorityPair {
+            plugin: Plugin::Royalties(Royalties {
+                basis_points: 500,
+                creators: vec![Creator {
+                    address: creator,
+                    percentage: 100,
+                }],
+                rule_set: RuleSet::None,
+            }),
+            authority: Some(PluginAuthority::None),
+        }])
+        .instruction();
+
+    let signers = vec![&asset, &payer];
+
+    let last_blockhash = rpc_client.get_latest_blockhash().await.unwrap();
+
+    let create_asset_with_plugin_tx = Transaction::new_signed_with_payer(
+        &[create_asset_with_plugin_ix],
+        Some(&payer.pubkey()),
+        &signers,
+        last_blockhash,
+    );
+
+    let res = rpc_client
+        .send_and_confirm_transaction(&create_asset_with_plugin_tx)
+        .await
+        .unwrap();
+
+    println!("Signature: {:?}", res)
+}
+
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+플러그인 목록에는 다음이 포함되지만 이에 국한되지 않습니다:
+
+- [소각 위임자](/kr/core/plugins/burn-delegate)
+- [동결 위임자](/kr/core/plugins/freeze-delegate)
+- [로열티](/kr/core/plugins/royalties)
+- [전송 위임자](/kr/core/plugins/transfer-delegate)
+- [업데이트 위임자](/kr/core/plugins/update-delegate)

src/pages/kr/core/index.md

@@ -0,0 +1,38 @@
+---
+title: 개요
+metaTitle: 개요 | Core
+description: Metaplex에서 만든 Core라는 새로운 Solana NFT 자산 표준의 개략적인 개요를 제공합니다.
+---
+
+Metaplex Core("Core")는 이전 표준의 복잡성과 기술적 부채를 제거하고 디지털 자산을 위한 깔끔하고 간단한 핵심 사양을 제공합니다. 이 차세대 Solana NFT 표준은 단일 계정 설계를 사용하여 민팅 비용을 줄이고 다른 대안과 비교하여 Solana 네트워크 부하를 개선합니다. 또한 개발자가 자산의 동작과 기능을 수정할 수 있도록 하는 유연한 플러그인 시스템을 가지고 있습니다. {% .lead %}
+
+[https://core.metaplex.com/](https://core.metaplex.com/)에서 Core의 기능을 직접 체험해보고 자산을 민팅해보세요!
+
+{% quick-links %}
+
+{% quick-link title="시작하기" icon="InboxArrowDown" href="/kr/core/getting-started" description="원하는 언어나 라이브러리를 찾고 Solana에서 디지털 자산으로 시작하세요." /%}
+
+{% quick-link title="API 참조" icon="CodeBracketSquare" href="https://mpl-core.typedoc.metaplex.com/" target="_blank" description="특정한 내용을 찾고 있나요? API 참조를 확인하고 답을 찾으세요." /%}
+
+{% quick-link title="MPL Token Metadata와의 차이점 개요" icon="AcademicCap" href="/kr/core/tm-differences" description="Token Metadata에 익숙하고 새로운 기능이나 변경된 동작의 개요를 보고 싶나요?" /%}
+
+{% quick-link title="UI에서 직접 체험해보세요!" icon="Beaker" href="https://core.metaplex.com/" target="_blank" description="사용하기 쉬운 웹사이트를 통해 Core를 직접 체험해보세요!" /%}
+
+{% /quick-links %}
+
+## 소개
+
+Metaplex Core는 Metaplex Protocol의 새로운 NFT 표준입니다. Metaplex Token Metadata Program을 포함한 다른 표준과 비교하여 다음과 같은 장점이 있습니다:
+
+- **전례 없는 비용 효율성**: Metaplex Core는 사용 가능한 대안과 비교하여 가장 낮은 민팅 비용을 제공합니다. 예를 들어, Token Metadata로 .022 SOL 또는 Token Extensions로 .0046 SOL이 드는 NFT를 Core로는 .0029 SOL에 민팅할 수 있습니다.
+- **낮은 컴퓨트**: Core 작업은 작은 Compute Unit 발자국을 가집니다. 이를 통해 더 많은 트랜잭션이 하나의 블록에 포함될 수 있으며, 민팅을 위해 205000 CU 대신 Core는 단지 17000 CU만 필요합니다.
+- **단일 계정 설계**: SPL Token이나 Token Extensions(일명 Token22)와 같은 대체 가능한 토큰 표준에 의존하는 대신 Core는 NFT 표준의 요구사항에 집중합니다. 이를 통해 Core는 소유자를 추적하는 단일 계정만 사용할 수 있습니다.
+- **강제 로열티**: Core는 기본적으로 [로열티 집행](/kr/core/plugins/royalties)을 허용합니다.
+- **일급 컬렉션 지원**: 자산을 [컬렉션](/kr/core/collections)으로 그룹화할 수 있습니다. 이는 Token Metadata에서도 가능하지만, Core에서는 컬렉션이 자체 자산 클래스로서 다음과 같은 추가 기능을 허용합니다:
+- **컬렉션 레벨 작업**: Core는 사용자가 컬렉션 레벨에서 모든 자산에 대한 변경을 할 수 있게 해줍니다. 예를 들어, 모든 컬렉션 자산을 동결하거나 로열티 세부사항을 단일 트랜잭션으로 동시에 변경할 수 있습니다!
+- **고급 플러그인 지원**: 내장된 스테이킹부터 자산 기반 포인트 시스템까지, Metaplex Core의 플러그인 아키텍처는 광범위한 유틸리티와 커스터마이제이션의 환경을 제공합니다. 플러그인을 통해 개발자는 생성, 전송, 소각과 같은 자산 생명 주기 이벤트에 훅을 걸어 커스텀 동작을 추가할 수 있습니다. 자산에 플러그인을 추가할 수 있습니다. 예: 권한 위임 또는 DAS에 의해 자동으로 색인화되는 온체인 속성 추가:
+- **즉석 색인화**: [DAS를 지원하는 많은 RPC 제공업체](/kr/rpc-providers)가 이미 Core를 지원하고 있습니다.
+
+## 다음 단계
+
+Metaplex Core가 무엇인지 개략적으로 살펴보았으므로, Core 자산과 상호 작용하는 데 사용할 수 있는 다양한 언어/프레임워크를 나열하는 [시작하기](/kr/core/getting-started) 페이지를 확인하는 것을 권장합니다. [MPL Token Metadata와의 차이점](/kr/core/tm-differences) 페이지도 살펴보는 것이 좋습니다. 그 이후에 다양한 기능 페이지를 사용하여 cNFT에서 수행할 수 있는 특정 작업에 대해 자세히 알아볼 수 있습니다.

src/pages/kr/core/what-is-an-asset.md

@@ -0,0 +1,300 @@
+---
+title: MPL Core 자산
+metaTitle: Core 자산이란 무엇인가 | Core
+description: MPL Core 자산이 무엇이며 왜 Solana NFT의 미래인지 알아보세요.
+---
+
+## 개요
+
+[Solana의 Token 프로그램](https://spl.solana.com/token)과 같은 기존 자산 프로그램과 구별되는 점은, Metaplex Core와 Core 자산(때때로 Core NFT 자산이라고 불림)은 연관 토큰 계정과 같은 여러 계정에 의존하지 않는다는 것입니다. 대신 Core 자산은 지갑과 "민트" 계정 간의 관계를 자산 자체 내에 저장합니다.
+
+{% diagram %}
+{% node %}
+{% node #wallet label="지갑 계정" theme="indigo" /%}
+{% node label="소유자: 시스템 프로그램" theme="dimmed" /%}
+{% /node %}
+{% node y="70" parent="wallet" label="누군가의 지갑." theme="transparent" /%}
+
+{% node x="200" parent="wallet" %}
+{% node #asset label="자산 계정" theme="blue" /%}
+{% node label="소유자: Core 프로그램" theme="dimmed" /%}
+{% /node %}
+{% node y="70" parent="asset" theme="transparent" %}
+소유자를 포함한 \
+자산에 대한 정보를 저장
+{% /node %}
+
+{% edge from="wallet" to="asset" /%}
+
+{% /diagram %}
+
+## Core 자산 계정
+
+Core 자산 계정은 디지털 자산을 위한 최소한의 데이터를 나타냅니다. 이 구조는 온체인 소유권을 위한 편견 없는 블록체인 원시 요소를 제공합니다.
+
+{% diagram %}
+{% node %}
+{% node #wallet label="지갑 계정" theme="indigo" /%}
+{% node label="소유자: 시스템 프로그램" theme="dimmed" /%}
+{% /node %}
+{% node y="70" parent="wallet" theme="transparent" /%}
+{% node x="200" parent="wallet" %}
+{% node #asset label="자산 계정" theme="blue" /%}
+{% node label="소유자: Core 프로그램" theme="dimmed" /%}
+{% node label="키 = 자산" /%}
+{% node label="소유자" /%}
+{% node label="업데이트 권한" /%}
+{% node label="이름" /%}
+{% node label="URI" /%}
+{% /node %}
+{% node y="70" parent="asset" theme="transparent" %}
+{% /node %}
+
+{% edge from="wallet" to="asset" /%}
+
+{% /diagram %}
+
+{% seperator h="6" /%}
+
+{% totem %}
+{% totem-accordion title="온체인 자산 계정 구조" %}
+
+MPL Core 자산의 온체인 계정 구조입니다. [링크](https://github.com/metaplex-foundation/mpl-core/blob/ce5d16f2de3c0038caae81a8c6496420b1a0462a/programs/mpl-core/src/state/asset.rs#L19)
+
+| 이름             | 타입            | 크기 | 설명                                                      |                                                                                                                            |
+| ---------------- | --------------- | ---- | --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| key              | u8              | 1    | 계정 타입의 구분자                                         |                                                                                                                            |
+| owner            | pubKey          | 32   | 자산의 소유자                                              |                                                                                                                            |
+| update_authority | enum<publicKey> | 33   | 새 자산의 권한 또는 CollectionID                           | [링크](https://github.com/metaplex-foundation/mpl-core/blob/main/clients/rust/src/generated/types/update_authority.rs#L14) |
+| name             | string          | 36   | 자산의 이름                                                |                                                                                                                            |
+| uri              | string          | 204  | 오프체인 데이터를 가리키는 자산의 URI                       |                                                                                                                            |
+| seq              | string          |      | 압축과 함께 색인화에 사용되는 시퀀스 번호                   |                                                                                                                            |
+
+{% /totem-accordion %}
+{% /totem %}
+
+## 내 자산이 컬렉션에 속해 있나요?
+
+MPL Core 자산은 컬렉션에 속할 수 있습니다. MPL Core 자산 데이터의 `updateAuthority` 필드는 두 가지 역할을 제공합니다. 자산의 업데이트 권한을 보고하거나 자산이 속한 MPL Core 컬렉션의 publicKey를 제공합니다.
+
+자산을 통해 직접 또는 MPL Core 자산의 `collectionAddress` 헬퍼를 통해 `updateAuthority` 필드에 액세스할 때, 반환되는 결과는 다음 결과 중 하나가 됩니다:
+
+**컬렉션**
+
+자산이 주어진 주소의 컬렉션에 속합니다.
+{% dialect-switcher title="자산 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+```javascript
+{
+  __kind: 'Collection'
+  fields: [PublicKey]
+}
+import { fetchAssetV1 } from '@metaplex-foundation/mpl-core'
+
+const asset = await fetchAssetV1(umi, assetAddress.publicKey)
+const collectionId = collectionAddress(asset)
+
+console.log({collectionId})
+console.log({asset})
+
+// 로그
+collection: '2222222222222222222222222222222'
+asset: {
+    key: AssetV1,
+    owner: "11111111111111111111111111111111",
+    updateAuthority: {
+      type: 'Collection',
+      address: '2222222222222222222222222222222'
+    },
+    name: "My Core Asset",
+    uri: "https://example.com/metadata.json",
+    ...
+}
+```
+
+{% /dialect %}
+
+{% dialect title="Rust" id="rust" %}
+
+```rust
+Collection(Pubkey)
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+**주소**
+
+자산에 업데이트 권한이 설정되어 있고 컬렉션에 속하지 않습니다.
+{% dialect-switcher title="자산 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+```javascript
+import { fetchAssetV1 } from '@metaplex-foundation/mpl-core'
+
+const asset = await fetchAssetV1(umi, assetAddress.publicKey)
+const collectionId = collectionAddress(asset)
+
+console.log({collectionId})
+console.log({asset})
+
+// 로그
+collectionId: undefined
+asset: {
+    key: AssetV1,
+    owner: "11111111111111111111111111111111",
+    updateAuthority: {
+      type: 'Address',
+      address: '2222222222222222222222222222222'
+    }
+    name: "My Core Asset",
+    uri: "https://example.com/metadata.json",
+    ...
+}
+```
+
+{% /dialect %}
+
+{% dialect title="Rust" id="rust" %}
+
+```rust
+Address(Pubkey)
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+**없음**
+
+자산에 업데이트 권한이 설정되지 않았습니다.
+
+{% dialect-switcher title="자산 생성" %}
+{% dialect title="JavaScript" id="js" %}
+
+```javascript
+import { fetchAssetV1 } from '@metaplex-foundation/mpl-core'
+
+const asset = await fetchAssetV1(umi, assetAddress.publicKey)
+const collectionId = collectionAddress(asset)
+
+console.log({collectionId})
+console.log({asset})
+
+// 로그
+collectionId: undefined
+asset: {
+    key: AssetV1,
+    owner: "11111111111111111111111111111111",
+    updateAuthority: {
+      type: 'None',
+    },
+    name: "My Core Asset",
+    uri: "https://example.com/metadata.json",
+}
+```
+
+{% /dialect %}
+
+{% dialect title="Rust" id="rust" %}
+
+```rust
+None
+```
+
+{% /dialect %}
+{% /dialect-switcher %}
+
+## 오프체인 메타데이터
+
+자산 계정의 중요한 속성 중 하나는 오프체인의 JSON 파일을 가리키는 `URI` 속성입니다. 이는 온체인 데이터 저장과 관련된 수수료의 제약을 받지 않으면서 안전하게 추가 데이터를 제공하는 데 사용됩니다. 그 JSON 파일은 누구나 토큰에서 유용한 정보를 찾는 데 사용할 수 있는 [특정 표준](/kr/token-metadata/token-standard)을 따릅니다.
+
+오프체인 메타데이터는 공개적으로 액세스 가능한 모든 위치에 저장할 수 있습니다. JSON 파일을 호스팅하는 인기 있는 장소는 다음과 같습니다:
+
+- Arweave
+- NFT.Storage/IPFS
+- Amazon AWS S3/Google Cloud
+
+{% diagram %}
+{% node %}
+{% node #wallet label="지갑 계정" theme="indigo" /%}
+{% node label="소유자: 시스템 프로그램" theme="dimmed" /%}
+{% /node %}
+{% node y="70" parent="wallet" theme="transparent" /%}
+{% node x="200" parent="wallet" %}
+{% node #asset label="자산 계정" theme="blue" /%}
+{% node label="소유자: Core 프로그램" theme="dimmed" /%}
+{% node label="키 = 자산" /%}
+{% node label="소유자" /%}
+{% node label="업데이트 권한" /%}
+{% node label="이름" /%}
+{% node #uri label="URI" /%}
+{% /node %}
+{% node y="70" parent="asset" theme="transparent" %}
+{% /node %}
+
+{% node parent="uri" x="-200" y="-23" %}
+{% node #json theme="slate" %}
+오프체인 \
+JSON 메타데이터
+{% /node %}
+{% node label="이름" /%}
+{% node label="설명" /%}
+{% node label="이미지" /%}
+{% node label="애니메이션 URL" /%}
+{% node label="속성" /%}
+{% node label="..." /%}
+{% /node %}
+
+{% edge from="wallet" to="asset" /%}
+{% edge from="uri" to="json" path="straight" /%}
+
+{% /diagram %}
+
+{% partial file="token-standard-full.md" /%}
+
+{% totem %}
+{% totem-accordion title="예시" %}
+
+```json
+{
+  "name": "SolanaArtProject #1",
+  "description": "Generative art on Solana.",
+  "image": "https://arweave.net/26YdhY_eAzv26YdhY1uu9uiA3nmDZYwP8MwZAultcE?ext=jpeg",
+  "animation_url": "https://arweave.net/ZAultcE_eAzv26YdhY1uu9uiA3nmDZYwP8MwuiA3nm?ext=glb",
+  "external_url": "https://example.com",
+  "attributes": [
+    {
+      "trait_type": "trait1",
+      "value": "value1"
+    },
+    {
+      "trait_type": "trait2",
+      "value": "value2"
+    }
+  ],
+  "properties": {
+    "files": [
+      {
+        "uri": "https://www.arweave.net/abcd5678?ext=png",
+        "type": "image/png"
+      },
+      {
+        "uri": "https://watch.videodelivery.net/9876jkl",
+        "type": "unknown",
+        "cdn": true
+      },
+      {
+        "uri": "https://www.arweave.net/efgh1234?ext=mp4",
+        "type": "video/mp4"
+      }
+    ],
+    "category": "video"
+  }
+}
+```
+
+{% /totem-accordion %}
+{% /totem %}
+
+이 JSON 파일은 업데이트할 수 없도록 Arweave와 같은 영구 저장 솔루션을 사용하여 저장할 수 있습니다. 또한 `업데이트 권한` 필드를 None으로 설정하여 불변으로 만들고, 따라서 `URI`와 `Name` 속성이 변경되는 것을 금지할 수 있습니다. 이 조합을 사용하여 오프체인 JSON 파일의 불변성을 보장할 수 있습니다.