Как использовать AI для создания приложений на Solana

Сложности разработки на Solana с помощью AI

Уникальная архитектура и требования Solana могут создавать сложности для AI. Если AI их не учитывает, вы потратите время на отладку кода или переписывание программ. Это лишает смысла использование AI для ускорения разработки.

Уникальная архитектура Solana

Solana отличается по трем основным параметрам:

1. Модель на основе аккаунтов

Многие блокчейны, например Ethereum, напрямую связывают данные с внутренним хранилищем смарт-контракта. В отличие от них, модель программирования Solana организует все вокруг «аккаунтов». Эти аккаунты хранят данные, а «программы» — аналог смарт-контрактов в Solana — изменяют эти данные и взаимодействуют с ними. 

Ключевое отличие заключается в том, что в Solana все является аккаунтом, включая сами программы. Программы — это аккаунты, которые хранят исполняемые данные и благодаря этому могут обрабатывать инструкции. В Ethereum, напротив, различаются аккаунты с внешним владельцем (EOA), управляемые приватными ключами, и смарт-контракты, у которых есть код и внутреннее хранилище. 

Это фундаментальное различие может привести к недопониманию, особенно при написании кода для Solana. Как и в случае со смарт-контрактами Ethereum, разработчики, незнакомые с моделью аккаунтов, могут ошибочно предположить, что программа способна владеть своими данными. При развертывании в Solana такие предположения могут привести к ошибкам во время выполнения или уязвимостям безопасности.

2. Адреса, производные от программы (PDA)

Адрес, производный от программы (PDA), создается на основе ID программы и seed. PDA позволяют программам организовывать аккаунты без приватного ключа. Однако модели AI могут не различать обычный адрес и PDA. Если они забудут обработать seeds или проверить владельца, код будет правильным с точки зрения Rust, но неправильным с точки зрения Solana.

3. Параллельное выполнение

Среда выполнения Solana, Sealevel, позволяет обрабатывать транзакции параллельно, в отличие от традиционных блокчейнов, которые выполняют их по одной. Это возможно благодаря тому, что транзакции указывают аккаунты, из которых они будут читать и в которые будут записывать данные. На основе этой информации Solana определяет, какие аккаунты нужно заблокировать, и безопасно выполняет множество транзакций одновременно. 

AI часто неправильно понимает эту модель. Он может предположить, что транзакции выполняются последовательно, как в виртуальной машине Ethereum (EVM). В результате код не будет оптимизирован для параллельного выполнения. Поскольку система блокировки аккаунтов Solana отличается от подхода EVM, AI может написать код с низкой производительностью или плохой масштабируемостью.

Распространенные проблемы

При использовании AI для создания приложений на Solana разработчики регулярно сталкиваются с несколькими проблемами:

1. Некорректный код

AI может предложить функции, которые компилируются в Rust, но не работают после развертывания в Solana. Например, инструменты парного программирования с AI могут не учесть подписантов или неверно интерпретировать ссылки на аккаунты. Результат — ошибки или уязвимости безопасности, которые невозможно обнаружить до запуска тестов, реальных транзакций или полного аудита безопасности.

2. Неоптимальный код

Даже если созданный AI код работает, он может быть не оптимизирован по вычислительным единицам, замедлять обработку транзакций или создавать скрытые узкие места. Представьте, что AI написал функцию, которая обновляет аккаунты по одному. Он не учел, что при правильной реализации Solana может обрабатывать их параллельно.

3. Сложная отладка

Модели AI не знают структуру ваших папок и определения пользовательских типов данных, если вы сами их не предоставите. Поэтому предложенные решения могут конфликтовать с текущей конфигурацией, а их интеграция в проект — доставить много проблем.

Используйте инструменты Helius AI, чтобы быстрее выпускать приложения на Solana

Как мы объяснили выше, правильно создавать решения на Solana с помощью AI непросто. 

Чтобы это изменить, мы разработали набор инструментов AI для разработчиков Solana, который берет сложные задачи на себя: выбирает подходящие инструменты, применяет лучшие практики и предоставляет AI-агенту основу для создания готового к эксплуатации приложения по одному промпту.

Helius MCP Server

Helius MCP Server создан на основе открытого стандарта Anthropic Model Context Protocol (MCP) и предоставляет более 60 структурированных инструментов, включая getBalance, parseTransaction, getAssetsByOwner и createWebhook, любому совместимому с MCP клиенту: Claude Desktop, Cursor, VS Code, Windsurf и другим.

Вместо создания необработанных команд curl и разбора вывода JSON агенты вызывают типизированные инструменты и напрямую получают структурированные ответы. Это ускоряет каждое взаимодействие с API, повышает его надежность и значительно снижает вероятность ошибок.

Добавить его в Claude Code можно одной командой:

claude mcp add helius npx helius-mcp@latest

Helius Skills

Доступ к более чем 60 инструментам бесполезен, если агент не знает, как ими пользоваться.https://www.helius.dev/blog/helius-for-agents#helius-skills-the-brain

Skills — это наборы экспертных инструкций: тщательно составленные промпты с логикой маршрутизации и справочными файлами, которые обучают агента работать как экспертный разработчик Solana.

После загрузки навыка агент знает, что для поиска NFT нужно использовать searchAssets вместо getProgramAccounts, динамически получать приоритетные комиссии и направлять транзакции через Sender для максимальной доли успешного включения. 

Мы выпустили четыре навыка:

• Build – основная разработка на Solana с использованием всех API Helius
• DFlow – торговые приложения, использующие API DFlow
• Phantom – создание интерфейсов для dApp с помощью Phantom Connect SDK
• SVM – глубокое погружение во внутреннее устройство протокола Solana

Skills не зависят от модели и работают с OpenAI API, Claude API, Cursor Rules и пользовательскими инструкциями ChatGPT.

Чтобы добавить навык, заполните эту форму.

Helius CLI

Helius CLI — это полнофункциональный интерфейс командной строки с более чем 95 командами для управления аккаунтами, отправки транзакций, управления webhook, потоковой передачи данных в реальном времени, стейкинга, ZK Compression и других задач. 

Вы можете использовать его напрямую или передать управление агенту — каждая команда поддерживает вывод --json и структурированные коды завершения, поэтому агенты могут легко разбирать ответы и программно обрабатывать ошибки.

Установите Helius CLI следующим образом:

npm install -g helius-cli

Helius Claude Code Plugin

Claude Code Plugin объединяет Helius MCP, DFlow MCP, все четыре навыка и подробные справочные файлы для каждого продукта Helius в одной установке — без ручной настройки MCP и отдельной установки навыков.

Установить его можно так:

/plugin marketplace add helius-labs/core-ai
/plugin install helius@helius-labs

После установки достаточно одного промпта, например «Создай CLI для формирования налоговой отчетности по этому кошельку», чтобы получить полностью рабочее CLI-приложение с пагинацией — без дополнительных промежуточных промптов.

Вместе эти инструменты предоставляют AI-агентам доступ к инструментам и знаниям предметной области, чтобы пропустить этап проб и ошибок и с первого промпта создавать корректный, оптимизированный код для Solana.

Рекомендации по разработке на Solana с помощью AI

Следуйте этим рекомендациям при создании приложений на Solana с помощью AI:

1. Начните с продуманного промпта

Системный промпт похож на должностную инструкцию для AI. Он задает роль AI, например «Вы — эксперт по программированию на Solana с использованием Anchor...», и определяет правила, которым AI должен следовать.

Ниже приведен типичный пример в немного расширенном виде:

# You are an expert in Solana program development.
Specializing in building and deploying smart contracts using Rust and Anchor,
and integrating on-chain data with @solana/web3.js.

---

## General Guidelines
- Write secure, efficient, and maintainable code for Solana programs.
- Thoroughly test and audit all programs before deployment.

## Solana Program Development with Rust and Anchor
- Prioritize Rust's safety and performance.
- Use Anchor macros to simplify account management, error handling, and
  data serialization.
- Keep code modular and maintain a clear separation between logic and data.

## Security and Best Practices
- Enforce strict access controls--ensure only permitted signers can modify data.
- Use PDAs responsibly: validate seeds and ownership checks to prevent conflicts.

## Performance and Optimization
- Minimize transaction costs by bundling operations efficiently.
- Exploit parallelism--don't serialize steps unnecessarily.
- Regularly benchmark your code to spot and remove performance

Почему это работает

Хорошо составленный системный промпт работает как проектный план: он согласует работу AI с архитектурой Solana. Благодаря этому каждый ответ будет точным, безопасным и адаптированным к вашим потребностям.

1. Задает правильный контекст: если объявить AI «экспертом по Solana», он сосредоточится на особенностях Solana, таких как PDA, параллелизм и Anchor, вместо общих предположений о блокчейнах.
2. Обеспечивает единообразный код: лучшие практики, например строгий контроль доступа и параллельное выполнение, помогают AI создавать безопасные, надежные и предсказуемые результаты.
3. Помогает избежать распространенных ошибок: акцент на безопасности Rust, макросах Anchor и сериализации сокращает количество ошибок. Это экономит время на отладке и переписывании кода.
4. Использует сильные стороны Solana: AI должен повышать пропускную способность и сокращать задержку. Это позволит оптимизировать код с учетом высокой производительности и эффективности Solana.

2. Пишите понятные промпты

При генерации кода с помощью AI точность имеет решающее значение. Чем точнее запрос, тем лучше результат. Сравните следующие примеры:

Плохой промпт:

«Напиши функцию для инициализации аккаунта».

Этот промпт слишком расплывчатый. AI не знает язык программирования, фреймворк и даже то, что требуется код для Solana. В результате вы можете получить общий или бесполезный код.

Хороший промпт:

«Напиши на Rust с использованием Anchor функцию для инициализации аккаунта токена Solana. Используй PDA, производный от seed. Проверяй состояние аккаунта и обрабатывай ошибку, если аккаунт уже инициализирован».

Почему хороший промпт работает:

Понятные промпты экономят время и силы. Четко определяя цели AI, вы избегаете последующего исправления небрежного, непонятного или не соответствующего задаче кода. Это также снижает риск неправильной интерпретации и делает работу с AI эффективнее. 

1. Он понятен и конкретен: благодаря прямому упоминанию Rust, Anchor и PDA AI точно знает, какие инструменты и возможности использовать. Ему не придется строить догадки или добавлять ненужные детали.
2. Он учитывает требования Solana: упоминание PDA указывает AI на необходимость добавить специфическую для Solana логику. Без этого в коде могут отсутствовать важные шаги, например безопасное получение адресов.
3. Он добавляет подробности там, где это нужно: инструкции по валидации и обработке ошибок требуют от AI выйти за рамки базовой реализации. Это помогает обеспечить работу кода в реальных сценариях.

Хороший промпт подобен карте: он направляет AI, помогает избежать препятствий и достичь цели.

3. Предоставьте нужный контекст

AI работает лучше, если вы предоставляете ему нужный контекст. Многие инструменты позволяют загружать код или прикреплять файлы. Это помогает AI понять ваш проект и создавать решения, подходящие для вашей кодовой базы. 

Но не перегружайте его. Если предоставить AI слишком много информации, например всю большую кодовую базу, он может начать галлюцинировать или выдавать нерелевантные ответы. 

Вместо этого предоставляйте только релевантные части кода. Так AI сохранит фокус, а качество его предложений повысится.

Например, представьте, что в вашем приложении уже есть файл с определением пользовательской структуры данных:

#[account]
pub struct TokenAccount {
    pub balance: u64,
    pub is_initialized: bool,
    // ... more fields
}

Если загрузить этот файл или включить его во входные данные, AI сможет использовать в сгенерированном коде точные имена ваших полей (balance, is_initialized).

Он также сможет привести свои предложения в соответствие со структурой и соглашениями вашего проекта.

Почему предоставление контекста работает

1. Повышает точность: без контекста AI может угадывать имена полей, вносить ненужные изменения или предполагать неверные типы данных. Например, он может назвать поле баланса amount или использовать f64 вместо u64. Предоставление фактической структуры устраняет необходимость в догадках.
2. Сохраняет единообразие кода: когда AI понимает ваши соглашения об именовании, он создает код, который естественно вписывается в проект. Вам не придется переименовывать переменные или перерабатывать код в соответствии с существующими шаблонами.
3. Сокращает объем интеграционной работы: если AI видит структуры аккаунтов, он может адаптировать результат для прямой интеграции с ними. Это позволяет избежать ситуаций, когда созданный AI код приходится значительно переписывать под существующую логику.

Пример: как добавить контекст и улучшить результаты AI

Без нужного контекста промпт «Напиши функцию для обновления баланса аккаунта токена» может привести к такому коду от AI:

pub fn update_balance(ctx: Context<UpdateAccount>, amount: f64) -> Result<()> {
    let account = &mut ctx.accounts.token_account;
    account.amount += amount;
    Ok(())
}

У этого кода две проблемы:

Во-первых, для amount он использует f64 вместо u64. 

Solana поддерживает нативную арифметику с плавающей точкой лишь в очень ограниченном виде. Предпочтительный подход — использовать арифметику с фиксированной точкой и масштабировать числа с учетом количества десятичных знаков. Это позволяет избежать проблем с производительностью и совместимостью.

Во-вторых, поле баланса названо amount, что не соответствует вашей структуре. В будущем это может привести к путанице и ошибкам.

Если предоставить структуру TokenAccount в качестве контекста, AI может сгенерировать такой вариант:

pub fn update_balance(ctx: Context<UpdateAccount>, amount: u64) -> Result<()> {
    let token_account = &mut ctx.accounts.token_account;
    token_account.balance += amount;
    Ok(())
}

Этот результат гораздо лучше соответствует вашему проекту. 

Однако даже после этого улучшения стоит добавить проверку переполнения для операции token_account.balance += amount, чтобы код оставался надежным и безопасным.

Как предоставить контекст

Чтобы предоставить инструментам AI нужный контекст, выполните следующие действия:

1. Загрузите файлы: если инструмент AI это позволяет, загрузите определения структур, схемы аккаунтов и другие файлы проекта.
2. Добавляйте код в промпты: копируйте и вставляйте в промпты релевантные фрагменты, чтобы AI мог использовать их в качестве справочной информации.
3. Опишите структуру: если загрузить файлы невозможно, четко опишите данные в промпте. Например: «У меня есть структура TokenAccount с полями balance (u64) и is_initialized (bool).»

4. Развивайте существующий код

Необязательно каждый раз начинать с нуля. Часто у вас уже есть рабочий фрагмент кода, который можно улучшить. AI поможет это сделать. Рассмотрим пример:

Исходный код:

pub fn create_token_account(ctx: Context<CreateAccount>) -> Result<()> {
    let token_account = &mut ctx.accounts.token_account;
    token_account.balance = 0;
    Ok(())
}

Этот код инициализирует аккаунт токена и устанавливает нулевой баланс. Он прост, но не обрабатывает такие сценарии, как обновление существующего аккаунта или проверка владельца.

Ваш промпт:

«Сделай эту функцию надежнее. Если аккаунт токена существует, прибавь значение к его балансу. Если нет, инициализируй его с указанной суммой. Также убедись, что аккаунт принадлежит текущей программе».

Код, созданный AI после вашего промпта:

pub fn create_or_update_token_account(
    ctx: Context<CreateAccount>,
    amount: u64
) -> Result<()> {
    let token_account = &mut ctx.accounts.token_account;

    // Check ownership
    if token_account.owner != ctx.program_id {
        return err!(ProgramError::IncorrectProgramId);
    }

    // Update or initialize
    if token_account.is_initialized {
        token_account.balance += amount;
    } else {
        token_account.balance = amount;
        token_account.is_initialized = true;
    }

    Ok(())
}

Почему это работает

1. Учитывает распространенные сценарии: новый код обрабатывает инициализированные и неинициализированные аккаунты, что делает его полезнее в реальных приложениях.
2. Добавляет проверку владельца: это предотвращает несанкционированные изменения, поскольку программа проверяет, принадлежит ли ей аккаунт.
3. Делает функцию умнее: теперь функция может обновлять баланс вместо того, чтобы каждый раз обнулять его. Это устраняет лишние действия и соответствует реальным сценариям использования.
4. Экономит время: вам не пришлось переписывать всю функцию. AI расширил уже существующий код и ускорил переход от базовой функции к надежной реализации.

Как использовать этот подход

В дальнейшем применяйте этот подход следующим образом:

1. Начните с рабочей основы: найдите функции или фрагменты, которые уже работают, но нуждаются в улучшении.
2. Формулируйте промпт конкретно: объясните, что именно нужно улучшить, например добавить проверку ошибок, обработать граничные случаи или усовершенствовать логику.
3. Проверяйте предложения AI: убедитесь, что созданный AI результат подходит вашему проекту и соответствует лучшим практикам Solana.
4. Повторяйте итерации при необходимости: если первый результат неидеален, скорректируйте промпт или отредактируйте код, чтобы приблизиться к цели.

5. Работайте поэтапно

Поэтапное написание кода помогает избегать ошибок и дорабатывать результат по ходу работы. Не пытайтесь сразу создать сложную функцию. Разделите ее на небольшие задачи. Так будет проще тестировать и улучшать каждую часть перед переходом к следующей.

Пример рабочего процесса

Начнем с малого. Попросите AI написать простую функцию для вычисления адреса, производного от программы (PDA), с помощью seed.

Пример промпта:

«Напиши функцию на Rust, которая вычисляет PDA на основе seed и ID программы с помощью Anchor».

Результат AI:

 pub fn find_pda(seed: &[u8], program_id: &Pubkey) -> Pubkey {
    Pubkey::create_program_address(&[seed], program_id).unwrap()
}

Это хорошая отправная точка, но функция еще не завершена. Добавим обработку ошибок.

Проверьте код и найдите проблемы. Например, использование unwrap() может привести к аварийному завершению программы, если seed недопустим.

Попросите AI исправить это:

«Обнови эту функцию и добавь обработку ошибок для недопустимых seeds. Возвращай Result вместо распаковки значения».

Обновленный код:

 pub fn find_pda(seed: &[u8], program_id: &Pubkey) -> Result<Pubkey, ProgramError> {
    Pubkey::create_program_address(&[seed], program_id)
        .map_err(|_| ProgramError::InvalidSeeds)
}

Теперь функция корректно обрабатывает недопустимые seeds: вместо паники она возвращает ошибку.

Затем интегрируем функцию. 

Попросите AI использовать функцию PDA в более крупной процедуре. Например:

«Напиши функцию, которая использует этот PDA для создания нового аккаунта токена. Проверь, что PDA еще не используется».

Результат AI:

pub fn create_token_account(ctx: Context<CreateAccount>, seed: &[u8], amount: u64) -> Result<()> {
    let program_id = ctx.program_id;
    let pda = find_pda(seed, &program_id)?;

    if ctx.accounts.token_account.key != pda {
        return Err(ProgramError::InvalidSeeds);
    }

    if !ctx.accounts.token_account.is_initialized {
        let token_account = &mut ctx.accounts.token_account;
        token_account.balance = amount;
        token_account.is_initialized = true;
    }

    Ok(())
}

На этом этапе логика PDA интегрируется в создание аккаунта, а также обеспечивается защита от некорректного повторного использования PDA.

Теперь оптимизируем и завершим код. Попросите AI дополнительно улучшить функцию с помощью такого промпта:

«Оптимизируй эту функцию, чтобы минимизировать стоимость транзакции, и добавь проверку владельца».

Результат AI:

pub fn create_token_account(ctx: Context<CreateAccount>, seed: &[u8], amount: u64) -> Result<()> {
    let program_id = ctx.program_id;
    let pda = find_pda(seed, &program_id)?;

    if ctx.accounts.token_account.key != pda || ctx.accounts.token_account.owner != program_id {
        return Err(ProgramError::IncorrectProgramId);
    }

    if !ctx.accounts.token_account.is_initialized {
        let token_account = &mut ctx.accounts.token_account;
        token_account.balance = amount;
        token_account.is_initialized = true;
    }

    Ok(())
}

Итоговая функция эффективна, безопасна и соответствует лучшим практикам Solana.

Почему этот подход работает

1. Сохраняет управляемость процесса: если сосредоточиться на одной небольшой задаче за раз, AI не будет перегружен. Каждый следующий шаг опирается на предыдущий, что упрощает тестирование и доработку.
2. Помогает рано выявлять ошибки: благодаря небольшим шагам вы заметите проблемы до того, как они повлияют на остальной код. Например, раннее добавление обработки ошибок предотвращает сбои в дальнейшем.
3. Поддерживает итеративную работу: если что-то работает неидеально, можно изменить функцию, не перерабатывая всю кодовую базу.
4. Повышает качество кода: каждая доработка делает код надежнее. В результате вы получаете более стабильное и удобное в сопровождении решение.

Как использовать этот подход

При следующем сеансе парного программирования с AI учитывайте следующие рекомендации:

1. Разделяйте задачи на небольшие этапы: вместо запроса одной сложной функции разбейте ее на более простые и управляемые задачи, а затем выполняйте их последовательно.
2. Тестируйте результат после каждого этапа: запускайте код после каждого изменения, чтобы убедиться в его работоспособности. Если он не работает, устраните проблему или скорректируйте промпт перед переходом к следующему этапу.
3. Дорабатывайте код в процессе: не ограничивайтесь одним результатом. Просите AI оптимизировать код или добавить возможности, например валидацию, повышение производительности или более качественную обработку ошибок.

Заключение

AI может стать исключительно мощным инструментом для разработки на Solana, если использовать его вдумчиво и осторожно. Архитектура Solana отличается от других блокчейнов: она использует PDA, параллельную обработку транзакций и модель на основе аккаунтов. Поэтому вам необходимо правильно направлять AI.

Начните с понятных промптов. Точно сообщите AI, что вам нужно, и конкретно укажите такие инструменты, как Rust, Anchor и PDA. Хороший промпт может выглядеть так:

«Напиши функцию на Rust для инициализации аккаунта токена Solana с помощью PDA, проверки состояния аккаунта и обработки ошибок.»

Такая точность повышает вероятность того, что AI создаст код, который будет работать в Solana.

Всегда предоставляйте контекст. Делитесь кодом проекта или объясняйте используемые структуры, например схемы аккаунтов или типы данных. Если у вас есть структура TokenAccount, предоставьте сведения о ней, чтобы AI мог согласовать результат. Но не перегружайте его: сосредоточьтесь на релевантных частях, чтобы предложения оставались точными и полезными.

Разделяйте задачи на небольшие этапы. Используйте итеративный процесс и дорабатывайте код по ходу работы. Начните с простых задач, например вычисления PDA, а затем добавьте обработку ошибок или проверку аккаунта. Тестируйте результат после каждого этапа. Так вы сможете рано выявлять проблемы и уверенно двигаться вперед.

Наконец, тщательно проверяйте работу AI. Созданный AI код часто содержит небольшие недочеты, например в нем могут отсутствовать проверки переполнения или валидация. Убедитесь, что результат соответствует правилам Solana, не содержит ошибок и использует возможности параллельного выполнения.

AI — лишь отправная точка, а завершить работу должны вы. Понятные инструкции, контекст, поэтапная разработка и тщательная проверка помогут использовать AI для создания безопасных и оптимизированных программ Solana. Сохраняйте контроль над процессом, и AI станет ценным инструментом, который поможет экономить время и писать более качественный код.

Дополнительные материалы

Чтобы узнать больше о разработке на Solana с помощью AI, изучите следующие ресурсы:

1. Anthropic: обзор проектирования промптов
2. AWS: методы проектирования промптов
3. Оптимизация программ Solana
4. Как оптимизировать использование вычислительных ресурсов в Solana
5. Документация Anchor