海马：用 Python 编写 Solana 程序

Python 的易用性与 Rust 的安全性。

Seahorse 允许您使用 Python 编写 Solana 程序。它是一个基于 Anchor 的社区主导项目。

开发者获得 Python 的易用性，同时仍然享有 Solana 链上每个 Rust 程序的安全保证。默认处理低级内存问题，让您关注重要的事情。

特性

• 编译时类型安全
• 与 Rust 代码完全兼容
• 与 Anchor 兼容

Seahorse 编译器生成中间 Rust 艺术品，并使用 Anchor 执行一些繁重的工作。

Seahorse 是 beta 软件很多特性尚未实现，且尚未准备好生产。

开始使用

安装

示例

示例：FizzBuzz

这是一个非常简单的程序，与经典的 FizzBuzz 问题类似。

# fizzbuzz
# Built with Seahorse v0.1.0
#
# On-chain, persistent FizzBuzz!

from seahorse.prelude import *

declare_id('Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS')

class FizzBuzz(Account):
  fizz: bool
  buzz: bool
  n: u64

@instruction
def init(owner: Signer, fizzbuzz: Empty[FizzBuzz]):
  fizzbuzz.init(payer = owner, seeds = ['fizzbuzz', owner])

@instruction
def do_fizzbuzz(fizzbuzz: FizzBuzz, n: u64):
  fizzbuzz.fizz = n % 3 == 0
  fizzbuzz.buzz = n % 5 == 0
  if not fizzbuzz.fizz and not fizzbuzz.buzz:
    fizzbuzz.n = n
  else:
    fizzbuzz.n = 0

这展示了海马的一些基本功能，如账户初始化和创建指令。更多内容，请参阅 计算器：您的第一个海马程序 或其他示例 这里。

编译器架构在 v0.2.0 中完全改变，这里是一个简要概述 - 更多详细信息 这里

SEAHORSE CORE: THE COMPILER (v0.2.0)
┌───────────────────────────────────────────┐
│                                           │
│ ┌───────────────────────────────────────┐ │
│ │ PARSE                                 │ │
│ │                                       │ │
│ │ Turn Seahorse source code into Python │ │
│ │ AST. Handled by rustpython.           │ │
│ └───────────────────┬───────────────────┘ │
│                     │                     │
│                    AST                    │
│                     │                     │
│ ┌───────────────────▼───────────────────┐ │
│ │ CLEAN                                 │ │
│ │                                       │ │
│ │ Remove unsupported parts from the AST │ │
│ │ (like yields statements). Does some   │ │
│ │ minor changes to make compilation     │ │
│ │ easier.                               │ │
│ └───────────────────┬───────────────────┘ │
│                     │                     │
│                    AST                    │
│                     │                     │
│ ┌───────────────────▼───────────────────┐ │
│ │ PREPROCESS                            │ │
│ │                                       │ │
│ │ Find the source files for every       │ │
│ │ import - recursively calls the first  │ │
│ │ two steps as well.                    │ │
│ │                                       │ │
│ │ Outputs a "module registry" which has │ │
│ │ every parsed+cleaned source file.     │ │
│ └───────────────────┬───────────────────┘ │
│                     │                     │
│                  registry                 │
│                     │                     │
│ ┌───────────────────▼───────────────────┐ │
│ │ COMPILE                               │ │
│ │ ┌───────────────────────────────────┐ │ │
│ │ │ NAMESPACE                         │ │ │
│ │ │                                   │ │ │
│ │ │ Resolve the location of every     │ │ │
│ │ │ import/export in each module.     │ │ │
│ │ └─────────────────┬─────────────────┘ │ │
│ │                   │                   │ │
│ │         registry & namespaces         │ │
│ │                   │                   │ │
│ │ ┌─────────────────▼─────────────────┐ │ │
│ │ │ SIGN                              │ │ │
│ │ │                                   │ │ │
│ │ │ Find types of everything outside  │ │ │
│ │ │ function bodies - class fields,   │ │ │
│ │ │ function params/return type.      │ │ │
│ │ └─────────────────┬─────────────────┘ │ │
│ │                   │                   │ │
│ │         registry & signatures         │ │
│ │                   │                   │ │
│ │ ┌─────────────────▼─────────────────┐ │ │
│ │ │ CHECK                             │ │ │
│ │ │                                   │ │ │
│ │ │ Type check function bodies. Also  │ │ │
│ │ │ outputs the type of each expres-  │ │ │
│ │ │ sion, used for doing syntactic    │ │ │
│ │ │ transformations later.            │ │ │
│ │ └─────────────────┬─────────────────┘ │ │
│ │                   │                   │ │
│ │         registry & expr. types        │ │
│ │                   │                   │ │
│ │ ┌─────────────────▼─────────────────┐ │ │
│ │ │ BUILD                             │ │ │
│ │ │                                   │ │ │
│ │ │ Turn the original Python AST into │ │ │
│ │ │ a Rust-like AST, assisted by the  │ │ │
│ │ │ type information from CHECK.      │ │ │
│ │ │                                   │ │ │
│ │ │ The new AST includes special      │ │ │
│ │ │ constructs for things native to   │ │ │
│ │ │ Anchor, like ix contexts.         │ │ │
│ │ └───────────────────────────────────┘ │ │
│ │                                       │ │
│ └───────────────────┬───────────────────┘ │
│                     │                     │
│                    AST                    │
│                     │                     │
│ ┌───────────────────▼───────────────────┐ │
│ │ GENERATE                              │ │
│ │                                       │ │
│ │ Finally, turn the Rust-like AST into  │ │
│ │ Rust source code. Generates code for  │ │
│ │ each source file individually, as     │ │
│ │ well as a lib.rs that contains the    │ │
│ │ "real" instruction entrypoints.       │ │
│ └───────────────────────────────────────┘ │
│                                           │
└───────────────────────────────────────────┘