8장: 구현 및 인증

"표준은 문서가 아니라 구현을 통해 실현된다. 구축하고, 테스트하고, 인증을 받으며, 수십억 사용자를 위해 배포하라."

— WIA 구현 철학

이 마지막 장에서는 WIA 블록체인 금융 표준의 이론적 지식을 프로덕션 준비 시스템으로 전환합니다. 프로젝트 설정부터 WIA 인증 획득까지, 성공적인 구현에 필요한 모든 단계를 안내합니다. 실전 코드 예제, 테스트 전략, 보안 베스트 프랙티스, 인증 절차, 실제 사례 연구를 다룹니다.

1. 시작 가이드

프로젝트 설정

WIA 호환 블록체인 금융 애플리케이션을 처음부터 설정하는 방법:

# 프로젝트 디렉토리 생성
mkdir wia-defi-app && cd wia-defi-app

# Hardhat 프로젝트 초기화
npm init -y
npm install --save-dev hardhat @nomiclabs/hardhat-ethers ethers

# Hardhat 초기화
npx hardhat init

# WIA 표준 라이브러리 설치
npm install @wia/blockchain-finance @wia/contracts

# 개발 의존성 설치
npm install --save-dev @openzeppelin/contracts
npm install --save-dev @chainlink/contracts
npm install --save-dev chai mocha @typechain/hardhat

# TypeScript 설정
npm install --save-dev typescript ts-node @types/node
npx tsc --init

프로젝트 구조

wia-defi-app/
├── contracts/              # Solidity 스마트 컨트랙트
│   ├── core/
│   │   ├── WIAVault.sol
│   │   └── WIARouter.sol
│   ├── adapters/
│   │   ├── UniswapAdapter.sol
│   │   └── AaveAdapter.sol
│   ├── interfaces/
│   │   └── IWIA*.sol
│   └── libraries/
│       └── WIAMath.sol
├── scripts/               # 배포 스크립트
│   ├── deploy.ts
│   └── verify.ts
├── test/                  # 테스트 파일
│   ├── unit/
│   ├── integration/
│   └── e2e/
├── sdk/                   # TypeScript SDK
│   ├── src/
│   │   ├── client.ts
│   │   ├── vault.ts
│   │   └── types.ts
│   └── package.json
├── hardhat.config.ts
├── package.json
└── README.md

Hardhat 설정

// hardhat.config.ts
import { HardhatUserConfig } from "hardhat/config";
import "@nomiclabs/hardhat-ethers";
import "@typechain/hardhat";
import "hardhat-gas-reporter";
import "solidity-coverage";

const config: HardhatUserConfig = {
  solidity: {
    version: "0.8.20",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200
      },
      viaIR: true  // 더 나은 최적화
    }
  },
  networks: {
    hardhat: {
      forking: {
        url: process.env.MAINNET_RPC_URL || "",
        blockNumber: 18950000
      }
    },
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL,
      accounts: [process.env.PRIVATE_KEY || ""],
      chainId: 11155111
    },
    mainnet: {
      url: process.env.MAINNET_RPC_URL,
      accounts: [process.env.PRIVATE_KEY || ""],
      chainId: 1
    }
  },
  gasReporter: {
    enabled: true,
    currency: "USD",
    coinmarketcap: process.env.COINMARKETCAP_API_KEY
  },
  etherscan: {
    apiKey: process.env.ETHERSCAN_API_KEY
  }
};

export default config;

2. 구현 체크리스트

WIA 인증을 위한 포괄적인 체크리스트:

Phase 1: 데이터 구조 ✅

Phase 2: API 인터페이스 ✅

Phase 3: 프로토콜 ✅

Phase 4: 통합 ✅

3. 샘플 코드: 완전한 구현

핵심 Vault 컨트랙트

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@wia/contracts/interfaces/IWIAVault.sol";

/**
 * @title WIAVault
 * @notice WIA 표준을 준수하는 자동화된 수익률 볼트
 * @dev ERC4626 호환 볼트로 여러 전략 지원
 */
contract WIAVault is ERC20, ReentrancyGuard, Ownable, IWIAVault {
    IERC20 public immutable asset;

    uint256 public totalAssets;
    uint256 public performanceFee = 1000; // 10% (기본 10000)
    uint256 public managementFee = 200;   // 2% 연간

    address public feeRecipient;
    uint256 public lastFeeCollection;

    mapping(address => bool) public strategies;
    mapping(address => uint256) public strategyAllocations;

    event Deposit(address indexed user, uint256 assets, uint256 shares);
    event Withdraw(address indexed user, uint256 assets, uint256 shares);
    event StrategyAdded(address indexed strategy, uint256 allocation);
    event FeesCollected(uint256 performanceFees, uint256 managementFees);

    constructor(
        address _asset,
        string memory _name,
        string memory _symbol
    ) ERC20(_name, _symbol) {
        asset = IERC20(_asset);
        feeRecipient = msg.sender;
        lastFeeCollection = block.timestamp;
    }

    /**
     * @notice 자산을 예치하고 볼트 주식 받기
     * @param assets 예치할 자산 양
     * @param receiver 주식을 받을 주소
     * @return shares 발행된 주식 양
     */
    function deposit(uint256 assets, address receiver)
        external
        override
        nonReentrant
        returns (uint256 shares)
    {
        require(assets > 0, "Cannot deposit 0");

        // 발행할 주식 계산
        shares = previewDeposit(assets);
        require(shares > 0, "Invalid share amount");

        // 자산 전송
        asset.transferFrom(msg.sender, address(this), assets);

        // 주식 발행
        _mint(receiver, shares);
        totalAssets += assets;

        // 전략에 자산 배분
        _distributeToStrategies(assets);

        emit Deposit(msg.sender, assets, shares);
    }

    /**
     * @notice 주식을 소각하고 자산 인출
     * @param shares 소각할 주식 양
     * @param receiver 자산을 받을 주소
     * @param owner 주식 소유자
     * @return assets 인출된 자산 양
     */
    function withdraw(
        uint256 shares,
        address receiver,
        address owner
    ) external override nonReentrant returns (uint256 assets) {
        require(shares > 0, "Cannot withdraw 0");
        require(shares <= balanceOf(owner), "Insufficient shares");

        if (msg.sender != owner) {
            _spendAllowance(owner, msg.sender, shares);
        }

        // 인출할 자산 계산
        assets = previewWithdraw(shares);
        require(assets > 0, "Invalid asset amount");

        // 필요시 전략에서 자산 인출
        _withdrawFromStrategies(assets);

        // 주식 소각
        _burn(owner, shares);
        totalAssets -= assets;

        // 자산 전송
        asset.transfer(receiver, assets);

        emit Withdraw(owner, assets, shares);
    }

    /**
     * @notice 주어진 자산에 대한 주식 미리보기
     */
    function previewDeposit(uint256 assets)
        public
        view
        returns (uint256)
    {
        uint256 supply = totalSupply();
        return supply == 0
            ? assets
            : (assets * supply) / totalAssets;
    }

    /**
     * @notice 주어진 주식에 대한 자산 미리보기
     */
    function previewWithdraw(uint256 shares)
        public
        view
        returns (uint256)
    {
        uint256 supply = totalSupply();
        return supply == 0
            ? 0
            : (shares * totalAssets) / supply;
    }

    /**
     * @notice 전략에 자산 배분
     */
    function _distributeToStrategies(uint256 amount) internal {
        // 간단화를 위해 구현 생략
        // 실제로는 strategyAllocations에 따라 배분
    }

    /**
     * @notice 전략에서 자산 인출
     */
    function _withdrawFromStrategies(uint256 amount) internal {
        // 간단화를 위해 구현 생략
        // 실제로는 전략에서 자산 인출
    }

    /**
     * @notice 수수료 징수
     */
    function collectFees() external {
        uint256 timePassed = block.timestamp - lastFeeCollection;

        // 관리 수수료 계산 (연간 비율)
        uint256 managementFees = (totalAssets * managementFee * timePassed)
                                 / (10000 * 365 days);

        // 성과 수수료 계산 (이익에서)
        uint256 currentValue = totalAssets;
        uint256 lastValue = totalSupply() > 0
            ? (totalSupply() * totalAssets) / totalSupply()
            : 0;

        uint256 profit = currentValue > lastValue
            ? currentValue - lastValue
            : 0;
        uint256 performanceFees = (profit * performanceFee) / 10000;

        uint256 totalFees = managementFees + performanceFees;

        if (totalFees > 0) {
            // 수수료만큼 주식 발행
            uint256 feeShares = (totalFees * totalSupply()) / totalAssets;
            _mint(feeRecipient, feeShares);

            lastFeeCollection = block.timestamp;

            emit FeesCollected(performanceFees, managementFees);
        }
    }

    /**
     * @notice 전략 추가 (관리자만)
     */
    function addStrategy(address strategy, uint256 allocation)
        external
        onlyOwner
    {
        require(!strategies[strategy], "Strategy already exists");
        require(allocation <= 10000, "Invalid allocation");

        strategies[strategy] = true;
        strategyAllocations[strategy] = allocation;

        emit StrategyAdded(strategy, allocation);
    }
}

TypeScript SDK 구현

// sdk/src/vault.ts
import { ethers, Contract, Signer } from 'ethers';
import { WIAVaultABI } from './abis';

export interface DepositOptions {
  amount: string;
  receiver?: string;
  onStatusChange?: (status: string) => void;
}

export class WIAVaultClient {
  private vault: Contract;
  private signer: Signer;

  constructor(
    vaultAddress: string,
    signer: Signer
  ) {
    this.vault = new ethers.Contract(
      vaultAddress,
      WIAVaultABI,
      signer
    );
    this.signer = signer;
  }

  /**
   * 볼트에 자산 예치
   */
  async deposit(options: DepositOptions): Promise {
    const {
      amount,
      receiver,
      onStatusChange
    } = options;

    const receiverAddress = receiver || await this.signer.getAddress();

    onStatusChange?.('approving');

    // 1. 자산 승인
    const asset = await this.vault.asset();
    const assetContract = new ethers.Contract(
      asset,
      ['function approve(address,uint256) returns (bool)'],
      this.signer
    );

    const approveTx = await assetContract.approve(
      this.vault.address,
      amount
    );
    await approveTx.wait();

    onStatusChange?.('depositing');

    // 2. 예치 실행
    const depositTx = await this.vault.deposit(
      amount,
      receiverAddress
    );

    onStatusChange?.('confirming');

    const receipt = await depositTx.wait();

    onStatusChange?.('confirmed');

    return receipt;
  }

  /**
   * 볼트에서 인출
   */
  async withdraw(
    shares: string,
    receiver?: string
  ): Promise {
    const owner = await this.signer.getAddress();
    const receiverAddress = receiver || owner;

    const tx = await this.vault.withdraw(
      shares,
      receiverAddress,
      owner
    );

    return await tx.wait();
  }

  /**
   * 사용자 잔액 조회
   */
  async getBalance(address?: string): Promise<{
    shares: string;
    assets: string;
  }> {
    const user = address || await this.signer.getAddress();

    const shares = await this.vault.balanceOf(user);
    const assets = await this.vault.previewWithdraw(shares);

    return {
      shares: ethers.utils.formatEther(shares),
      assets: ethers.utils.formatEther(assets)
    };
  }

  /**
   * 볼트 통계 조회
   */
  async getVaultStats(): Promise<{
    totalAssets: string;
    totalSupply: string;
    sharePrice: string;
  }> {
    const [totalAssets, totalSupply] = await Promise.all([
      this.vault.totalAssets(),
      this.vault.totalSupply()
    ]);

    const sharePrice = totalSupply.gt(0)
      ? totalAssets.mul(ethers.utils.parseEther('1')).div(totalSupply)
      : ethers.utils.parseEther('1');

    return {
      totalAssets: ethers.utils.formatEther(totalAssets),
      totalSupply: ethers.utils.formatEther(totalSupply),
      sharePrice: ethers.utils.formatEther(sharePrice)
    };
  }
}

// 사용 예시
const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
const signer = new ethers.Wallet(PRIVATE_KEY, provider);

const vault = new WIAVaultClient(VAULT_ADDRESS, signer);

// 1000 USDC 예치
await vault.deposit({
  amount: ethers.utils.parseUnits('1000', 6),
  onStatusChange: (status) => console.log(`상태: ${status}`)
});

// 잔액 조회
const balance = await vault.getBalance();
console.log(`주식: ${balance.shares}, 자산: ${balance.assets}`);

4. 테스트 및 검증

단위 테스트

// test/unit/WIAVault.test.ts
import { expect } from "chai";
import { ethers } from "hardhat";
import { WIAVault, MockERC20 } from "../typechain";

describe("WIAVault", function() {
  let vault: WIAVault;
  let asset: MockERC20;
  let owner: any;
  let user: any;

  beforeEach(async function() {
    [owner, user] = await ethers.getSigners();

    // Mock ERC20 배포
    const MockERC20Factory = await ethers.getContractFactory("MockERC20");
    asset = await MockERC20Factory.deploy("Test USDC", "USDC", 6);

    // Vault 배포
    const VaultFactory = await ethers.getContractFactory("WIAVault");
    vault = await VaultFactory.deploy(
      asset.address,
      "WIA Vault",
      "wvUSDC"
    );

    // 사용자에게 토큰 민팅
    await asset.mint(user.address, ethers.utils.parseUnits("10000", 6));
  });

  describe("예치", function() {
    it("첫 예치는 1:1 비율이어야 함", async function() {
      const depositAmount = ethers.utils.parseUnits("1000", 6);

      await asset.connect(user).approve(vault.address, depositAmount);
      await vault.connect(user).deposit(depositAmount, user.address);

      const shares = await vault.balanceOf(user.address);
      expect(shares).to.equal(depositAmount);
    });

    it("후속 예치는 현재 비율을 사용해야 함", async function() {
      // 첫 예치
      const firstDeposit = ethers.utils.parseUnits("1000", 6);
      await asset.connect(user).approve(vault.address, firstDeposit);
      await vault.connect(user).deposit(firstDeposit, user.address);

      // 볼트에 이익 시뮬레이션 (10%)
      await asset.mint(vault.address, ethers.utils.parseUnits("100", 6));

      // 두 번째 예치
      const secondDeposit = ethers.utils.parseUnits("1000", 6);
      await asset.connect(owner).approve(vault.address, secondDeposit);
      await vault.connect(owner).deposit(secondDeposit, owner.address);

      const ownerShares = await vault.balanceOf(owner.address);

      // 주식 가치가 10% 증가했으므로 더 적은 주식 받음
      const expectedShares = firstDeposit.mul(1000).div(1100);
      expect(ownerShares).to.be.closeTo(expectedShares, 1000);
    });
  });

  describe("인출", function() {
    it("올바른 자산 양을 인출해야 함", async function() {
      const depositAmount = ethers.utils.parseUnits("1000", 6);

      await asset.connect(user).approve(vault.address, depositAmount);
      await vault.connect(user).deposit(depositAmount, user.address);

      const shares = await vault.balanceOf(user.address);
      const balanceBefore = await asset.balanceOf(user.address);

      await vault.connect(user).withdraw(shares, user.address, user.address);

      const balanceAfter = await asset.balanceOf(user.address);
      expect(balanceAfter.sub(balanceBefore)).to.equal(depositAmount);
    });
  });

  describe("수수료", function() {
    it("관리 수수료를 징수해야 함", async function() {
      const depositAmount = ethers.utils.parseUnits("10000", 6);

      await asset.connect(user).approve(vault.address, depositAmount);
      await vault.connect(user).deposit(depositAmount, user.address);

      // 1년 후 시뮬레이션
      await ethers.provider.send("evm_increaseTime", [365 * 24 * 60 * 60]);
      await ethers.provider.send("evm_mine", []);

      const feeRecipientSharesBefore = await vault.balanceOf(owner.address);

      await vault.collectFees();

      const feeRecipientSharesAfter = await vault.balanceOf(owner.address);
      const feeShares = feeRecipientSharesAfter.sub(feeRecipientSharesBefore);

      // 2% 관리 수수료 확인
      expect(feeShares).to.be.gt(0);
    });
  });
});

통합 테스트

// test/integration/DEXAggregator.test.ts
describe("DEX 집계 통합", function() {
  it("Uniswap과 Sushiswap에서 최고 가격을 찾아야 함", async function() {
    // 메인넷 포크에서 실행
    const aggregator = await deployAggregator();

    const quote = await aggregator.getBestQuote(
      DAI_ADDRESS,
      USDC_ADDRESS,
      ethers.utils.parseEther("1000")
    );

    expect(quote.dex).to.be.oneOf([UNISWAP_ADDRESS, SUSHISWAP_ADDRESS]);
    expect(quote.amountOut).to.be.gt(0);
  });
});

5. WIA 인증 절차

WIA 인증은 구현이 표준을 준수하는지 검증하는 공식 프로세스입니다:

인증 등급

인증 프로세스

1. 신청 제출
   - WIA 인증 포털에서 신청
   - 구현 문서 제출
   - 테스트 결과 업로드

2. 초기 검토 (1-2주)
   - 문서 완전성 확인
   - 체크리스트 검증
   - 테스트 커버리지 검토

3. 기술 평가 (2-4주)
   - 코드 검토
   - 보안 분석
   - 성능 테스트
   - 상호운용성 테스트

4. 보안 감사 (4-6주)
   - 독립 감사 회사
   - 취약점 스캔
   - 침투 테스트

5. 최종 검토 (1주)
   - 모든 발견사항 해결
   - 인증 위원회 승인

6. 인증 발급
   - 디지털 인증서
   - NFT 배지
   - 공개 발표

6. 사례 연구

사례 1: DeFiHub - 크로스체인 수익률 집계

프로젝트: DeFiHub는 Ethereum, Polygon, Arbitrum에서 최고 수익률을 찾는 크로스체인 수익률 최적화 플랫폼입니다.

구현:

• WIA Phase 1-4 완전 구현
• 5개 DEX 통합 (Uniswap, Curve, Balancer, Sushiswap, 1inch)
• 3개 렌딩 프로토콜 (Aave, Compound, Morpho)
• LayerZero 사용 크로스체인 브릿지
• Chainlink + Uniswap TWAP 오라클

결과:

• WIA Gold 인증 획득
• 6개월 내 $50M TVL 달성
• 평균 15% APY (경쟁사 대비 +3%)
• 99.9% 가동 시간
• 보안 사고 0건

사례 2: ChainSwap - NFT 크로스체인 마켓플레이스

프로젝트: ChainSwap은 사용자가 여러 체인에서 NFT를 사고팔 수 있는 크로스체인 NFT 마켓플레이스입니다.

구현:

• WIA Phase 1-3 구현
• OpenSea, Blur, X2Y2 통합
• Wormhole 브릿지
• 여러 소스 NFT 가격 집계

결과:

• WIA Silver 인증 획득
• 월 $10M 거래량
• 5개 체인 지원
• 20,000+ 활성 사용자

7. 미래 로드맵

2025 Q1-Q2: 확장

• Solana, Cosmos, Polkadot 지원
• 계정 추상화 (ERC-4337) 완전 지원
• 가스 최적화 도구
• 더 많은 DEX/렌딩 어댑터

2025 Q3-Q4: 혁신

• AI 기반 수익률 최적화
• 예측 시장 통합
• 실제 자산 (RWA) 토큰화
• 제로 지식 증명 프라이버시

2026+: 대량 채택

• Fiat 온/오프 램프
• 모바일 SDK
• 규제 준수 도구
• 기관 투자자 기능
• 탄소 중립 운영

핵심 요약

5가지 핵심 포인트:

1. 성공적인 WIA 구현은 적절한 프로젝트 설정, Hardhat 구성, 명확한 디렉토리 구조, 포괄적인 의존성 관리로 시작합니다.

2. 구현 체크리스트는 Phase 1-4의 모든 요구사항을 다루며, 필수 및 권장 기능을 명확한 검증 방법과 함께 명시합니다.

3. 프로덕션 준비 코드는 재진입 보호, 적절한 수수료 메커니즘, 이벤트 발생, 포괄적인 오류 처리를 포함한 보안 베스트 프랙티스를 따라야 합니다.

4. 테스트 전략은 60-90% 커버리지의 단위 테스트, 실제 프로토콜과의 통합 테스트, 메인넷 포크 E2E 테스트를 포함해야 합니다.

5. WIA 인증은 Bronze부터 Platinum까지 4가지 등급을 제공하며, 각각 증가하는 요구사항과 혜택을 제공하여 프로젝트가 표준 준수를 달성하고 신뢰를 구축할 수 있도록 합니다.

복습 문제

1. WIA 호환 프로젝트를 설정하는 첫 단계는 무엇인가요?

   프로젝트 디렉토리를 생성하고, Hardhat을 초기화하며, @wia/blockchain-finance 및 @wia/contracts와 같은 WIA 표준 라이브러리를 설치하고, OpenZeppelin 및 Chainlink와 같은 필수 의존성을 추가하고, 테스트 프레임워크(Mocha, Chai)를 설정하고, TypeScript를 구성하고, contracts/, test/, sdk/를 포함한 적절한 디렉토리 구조를 만드는 것입니다.

2. WIA Bronze 인증과 Gold 인증의 차이점은 무엇인가요?

   Bronze는 Phase 1+2 구현, 60% 테스트 커버리지, 1개 보안 감사가 필요하고 $1,000 비용이며 기본 혜택(로고 사용, 디렉토리 등재)을 제공합니다. Gold는 모든 Phase 구현, 90% 테스트 커버리지, 3개 보안 감사, 메인넷 배포가 필요하고 $15,000 비용이며 마케팅 지원, 거버넌스 참여, 기술 지원을 포함한 종합 혜택을 제공합니다.

3. WIAVault 컨트랙트가 재진입 공격을 어떻게 방지하나요?

   OpenZeppelin의 ReentrancyGuard를 상속받고, deposit() 및 withdraw()와 같은 상태 변경 함수에 nonReentrant 수정자를 사용합니다. 이는 함수가 완료되기 전에 재진입되지 않도록 보장합니다. 또한 checks-effects-interactions 패턴을 따릅니다: 조건 확인, 상태 업데이트(_mint/_burn), 그 다음 외부 호출(token.transfer)을 실행합니다.

4. 단위 테스트와 통합 테스트의 차이점은 무엇인가요?

   단위 테스트는 mock 의존성으로 개별 컨트랙트/함수를 격리하여 테스트합니다(예: MockERC20 사용). 특정 로직(1:1 예치 비율, 수수료 계산)을 확인합니다. 통합 테스트는 실제 프로토콜과의 상호작용을 테스트합니다(메인넷 포크의 Uniswap/Aave). 여러 컴포넌트가 함께 작동하는지 확인하고 E2E 시나리오를 검증합니다. 둘 다 포괄적인 검증에 필요합니다.

5. WIA 인증 프로세스의 주요 단계는 무엇인가요?

   프로세스는 (1) 문서 및 테스트 결과와 함께 신청 제출, (2) 완전성에 대한 초기 검토(1-2주), (3) 코드 검토 및 보안 분석 기술 평가(2-4주), (4) 독립 회사의 보안 감사(4-6주), (5) 발견사항 해결 및 위원회 승인 최종 검토(1주), (6) 디지털 인증서 및 NFT 배지 발급입니다.

6. DeFiHub 사례 연구에서 주요 성공 요인은 무엇이었나요?

   DeFiHub는 (1) Phase 1-4 완전 구현, (2) 5개 DEX 및 3개 렌딩 프로토콜과의 광범위한 통합, (3) LayerZero를 사용한 안전한 크로스체인 기능, (4) Chainlink + TWAP를 사용한 강력한 오라클 집계, (5) WIA Gold 인증을 통해 신뢰 구축으로 성공했습니다. 결과는 $50M TVL, 15% APY, 99.9% 가동 시간, 보안 사고 0건입니다.

결론

WIA 블록체인 금융 표준을 통한 여정을 완료한 것을 축하합니다. 이제 데이터 구조와 API에서 크로스체인 프로토콜과 DeFi 통합까지 모든 것을 다루는 프로덕션 준비 블록체인 금융 애플리케이션을 구축할 지식과 도구를 갖추었습니다.

기억하세요:

• 보안 우선: 항상 철저히 테스트하고 감사를 받으세요
• 사용자 중심: 명확한 오류 메시지와 직관적인 인터페이스로 UX를 우선시하세요
• 상호운용 가능: WIA 표준을 따라 생태계와 호환되도록 하세요
• 지속 가능: 가스를 최적화하고 환경 영향을 고려하세요
• 커뮤니티 주도: 오픈소스에 기여하고 지식을 공유하세요

블록체인 금융의 미래는 분산화되어 있고, 접근 가능하며, 모두를 위한 것입니다. 여러분의 구현이 이 비전을 실현하는 데 도움이 되기를 바랍니다.

弘益人間 - 널리 인간을 이롭게 하라.