Como criar aplicativos Solana com Gill

O que é Gill?

Gill é uma biblioteca moderna em TypeScript para desenvolver aplicativos Solana em qualquer ambiente baseado em JavaScript, do navegador ao servidor e a dispositivos móveis.

A biblioteca gill foi criada para desenvolvedores Solana de todos os níveis de experiência, de iniciantes a avançados. Ao disponibilizar abstrações de alto nível e primitivas de baixo nível no mesmo pacote, os desenvolvedores podem usar facilmente funcionalidades mais avançadas quando necessário ou quando elas não forem compatíveis com as abstrações. 

E o melhor? 

Gill é totalmente compatível com tree-shaking. Assim, seu bundler removerá automaticamente todas as primitivas ou abstrações que não forem usadas na base de código.

O principal objetivo da Gill é melhorar a experiência do desenvolvedor, simplificando tarefas comuns do desenvolvimento na Solana e eliminando código repetitivo sem comprometer a possibilidade de trabalhar em um nível mais baixo quando necessário ou desejado. Os desenvolvedores não devem ficar limitados a abstrações de alto nível ou primitivas de baixo nível. Eles devem poder escolher facilmente qualquer uma das opções quando fizer sentido.

Como instalar Gill

Gill pode ser instalada em qualquer projeto baseado em JavaScript ou TypeScript, incluindo NodeJS/Bun, navegador, React Native ou praticamente qualquer outro ambiente JavaScript.

npm install gill

A biblioteca gill oferece amplo suporte a TypeScript e deve funcionar imediatamente na maioria dos aplicativos. No entanto, a configuração específica do seu projeto pode exigir ajustes para funcionar melhor com gill. Consulte a documentação para saber mais sobre o suporte a TypeScript na gill.

Gill vs. @solana/kit

A biblioteca gill foi criada diretamente sobre @solana/kit, as novas primitivas JavaScript de baixo nível desenvolvidas pela Anza como uma substituição mais eficiente para a antiga @solana/web3.js.

Como Kit oferece apenas essas primitivas de baixo nível, os desenvolvedores ficam restritos a uma única experiência, na qual precisam criar tudo manualmente. Isso resulta em aplicativos cada vez maiores e repletos de código repetitivo e verboso.

É aí que entra gill.

Gill oferece as mesmas primitivas de baixo nível que Kit e também abstrações com algumas decisões predefinidas para simplificar tarefas comuns, tudo por meio de uma única interface compatível. Ao simplificar todo o processo com gill, os desenvolvedores podem dedicar mais tempo à lógica de negócios do aplicativo e menos ao código repetitivo e verboso.

Exemplos de código com Gill e Kit

Os trechos de código a seguir demonstram como você pode simplificar seu código mantendo a mesma funcionalidade (e possivelmente adicionando mais recursos). Quase todos os aplicativos precisarão realizar duas tarefas: estabelecer uma conexão com a blockchain e criar transações.

Uma conexão com a blockchain usando @solana/kit é criada da seguinte maneira:

import {
  devnet,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  sendAndConfirmTransactionFactory,
} from "@solana/kit";

const rpc = createSolanaRpc(devnet("https://api.devnet.solana.com"));

const rpcSubscriptions = createSolanaRpcSubscriptions(
  devnet("wss://api.devnet.solana.com"),
);

const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({
  rpc,
  rpcSubscriptions,
});

A mesma lógica pode ser implementada e simplificada com a função createSolanaClient da gill:

import { createSolanaClient } from "gill";

const { rpc, rpcSubscriptions, sendAndConfirmTransaction } = createSolanaClient({
  urlOrMoniker: "devnet",
});

Agora você pode fazer solicitações RPC simples usando o objeto rpc criado com qualquer uma das bibliotecas nos exemplos acima:

// get the latest blockhash from your RPC provider
const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

Uma transação simples que inclui uma instrução de memo com otimizações básicas (usando instruções de orçamento computacional) é criada em @solana/kit da seguinte maneira:

import {
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  appendTransactionMessageInstructions,
  setTransactionMessageLifetimeUsingBlockhash,
} from "@solana/kit";
import { getAddMemoInstruction } from "@solana-program/memo";
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";

const transaction = pipe(
  createTransactionMessage({ version: "legacy" }),
  (tx) => setTransactionMessageFeePayerSigner(signer, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
  (tx) =>
    appendTransactionMessageInstructions(
      [
        getAddMemoInstruction({
          memo: "gm world!",
        }),
        getSetComputeUnitLimitInstruction({ units: 5000 }),
        getSetComputeUnitPriceInstruction({ microLamports: 1000 }),
      ],
      tx,
    ),
);

A mesma lógica pode ser bastante simplificada usando gill da seguinte maneira:

import { createTransaction } from "gill";
import { getAddMemoInstruction } from "gill/programs";

const transaction = createTransaction({
  version: "legacy",
  feePayer: signer,
  instructions: [
    getAddMemoInstruction({
      memo: "gm world!",
    }),
  ],
  latestBlockhash,
  computeUnitLimit: 5000,
  computeUnitPrice: 1000,
});

Para uma comparação mais abrangente entre essas duas bibliotecas, consulte na documentação da gill a página gill vs. @solana/kit.

O que envolve o processo de migração de Kit para Gill?

Para qualquer aplicativo que use a biblioteca @solana/kit, o processo de migração para o pacote gill é muito simples:

1. Instale gill
2. Substitua todas as importações de @solana/kit por gill
3. Desinstale @solana/kit

Como gill também inclui diretamente os clientes mais comuns da Solana Program Library (SPL), você pode substituir as importações desses pacotes por gill. Gill inclui os seguintes clientes SPL, acessíveis diretamente pelo caminho de importação gill/programs:

• @solana-program/system
• @solana-program/memo
• @solana-program/compute-budget
• @solana-program/address-lookup-table
• @solana-program/token-2022 (consulte a observação abaixo sobre clientes de programas de token)

Para usar apenas o pacote gill com esses clientes de programas SPL:

1. Substitua as importações dos pacotes @solana-program/* listados acima por gill/programs
2. Desinstale os pacotes @solana-program/* listados acima.

Depois de atualizar suas importações, seu aplicativo estará imediatamente pronto para começar a usar a biblioteca "gill core". Agora você pode refatorar facilmente o código repetitivo e verboso de Kit (como a criação de conexões com a blockchain e transações) usando qualquer uma das abstrações disponíveis em gill.

Quais componentes estão incluídos na Gill?

A biblioteca gill pode ser dividida em alguns componentes principais:

• Funcionalidades principais (também conhecidas como "gill core")
• Utilitários específicos para runtimes de servidor (como NodeJS e Bun)
• Clientes de programas
• Construtores de transações
• Modo de depuração

Funções auxiliares para Node.js

O pacote gill inclui vários utilitários específicos para runtimes de servidor JavaScript. Embora estejam incluídos no pacote gill, eles têm um caminho de importação separado para aprimorar o tree-shaking. Esses utilitários permitem, entre outras funções, carregar e salvar facilmente pares de chaves em arquivos ou variáveis ENV.

import { ... } from "gill/node"

Para carregar facilmente um arquivo de par de chaves do seu sistema de arquivos local (como o par de chaves da Solana CLI):

import { loadKeypairSignerFromFile } from "gill/node";

// default file path: ~/.config/solana/id.json
const signer = await loadKeypairSignerFromFile();
console.log("address:", signer.address);

Você também pode carregar um par de chaves codificado em base58 a partir de uma variável ENV:

import { loadKeypairSignerFromEnvironmentBase58 } from "gill/node";

// loads signer from base58 keypair stored at `process.env[variableName]`
const signer = await loadKeypairSignerFromEnvironmentBase58(variableName);
console.log("address:", signer.address);

Construtores de transações

Para simplificar a criação de transações comuns que costumam interagir com vários programas ao mesmo tempo, gill inclui diversos "construtores de transações" que ajudam a montar facilmente transações prontas para assinatura nessas tarefas.

Como cada construtor de transações se limita a uma única tarefa, ele pode abstrair facilmente diferentes partes do código repetitivo e também ajudar a criar uma transação otimizada.

Alguns dos construtores de transações oferecidos pela gill incluem:

• buildCreateTokenTransaction - cria um token com metadados
• buildMintTokensTransaction - emite tokens para uma carteira de destino
• buildTransferTokensTransaction - transfere tokens para uma carteira de destino

Cada construtor de transações vem acompanhado de um "construtor de instruções" para oferecer mais flexibilidade aos desenvolvedores ao usar essas abstrações da gill.

Modo de depuração

Na gill, você pode ativar o "modo de depuração" para registrar automaticamente informações adicionais que ajudarão a solucionar problemas nas suas transações.

O modo de depuração vem desativado por padrão para minimizar os registros adicionais do aplicativo. Com seu controlador flexível, você pode ativá-lo nos ambientes mais comuns em que seu código será executado, incluindo o próprio código, backends NodeJS, funções serverless e até o console do navegador.

Para ativar o modo de depuração, defina qualquer uma das opções a seguir como true ou 1:

• process.env.GILL_DEBUG
• global.__GILL_DEBUG__
• window.__GILL_DEBUG__ (por exemplo, no console do navegador)
• ou defina manualmente qualquer nível de registro de depuração (consulte a documentação)

Consulte a documentação do Modo de depuração da gill para saber mais.

Ferramentas complementares para desenvolver com Gill

@gillsdk/react

Dentro da própria biblioteca gill há outro pacote, @gillsdk/react, uma coleção de hooks do React projetada para melhorar radicalmente a experiência de desenvolvimento de aplicativos frontend baseados em React. Ele também é criado sobre TanStack Query, uma biblioteca popular de reatividade, o que facilita seu uso em aplicativos existentes.

O pacote @gillsdk/react ainda está em seus estágios iniciais e em desenvolvimento ativo. Atualmente, ele oferece vários hooks úteis do React para aplicativos Solana:

• useAccount - obtém as informações da conta de um endereço
• useBalance - obtém o saldo da conta (em lamports)
• useLatestBlockhash - obtém o blockhash mais recente
• useSignatureStatuses - obtém os status das assinaturas
• useProgramAccounts - obtém as contas de um programa (GPA)
• useTokenMint - obtém a conta Mint decodificada de um token
• useTokenAccount - obtém a conta de token de um determinado Mint e proprietário (ou ATA)

Codama

Codama é uma ferramenta que permite aos desenvolvedores usar a IDL de um programa Solana para gerar bibliotecas cliente (como JavaScript e Rust) que podem ser usadas por outros aplicativos. Codama reduz toda a complexidade da criação de instruções da Solana a uma IDL, um arquivo de configuração e a importação de uma função.

Gill e Codama podem ser integrados facilmente com a função createCodamaConfig da gill. O mantenedor da gill também trabalha ativamente para aprimorar ainda mais a integração gill<>Codama, incluindo suporte direto na Codama CLI!

Por padrão, os clientes TypeScript de programas gerados pela Codama usarão @solana/kit, mas isso pode ser facilmente alterado no arquivo de configuração da Codama do seu programa Solana. A função createCodamaConfig torna muito simples a atualização da configuração da Codama para usar gill.

Veja a seguir um exemplo de arquivo codama.js que gerará um cliente TypeScript para um programa Solana usando gill:

import { createCodamaConfig } from "gill";

export default createCodamaConfig({
  idl: "program/idl.json",
  clientJs: "clients/js/src/generated",
});

Você encontra um guia completo na documentação da gill sobre como gerar clientes para programas Solana com Codama.

O futuro da Gill

O futuro da biblioteca gill é promissor, e ainda há muito a fazer. O site oficial da documentação da gill acaba de ser lançado, e a biblioteca está se aproximando de 20 mil downloads mensais.

Você encontra mais informações sobre os itens atuais do roadmap da gill na página de projetos do GitHub. No momento, a lista inclui:

• Suporte direto à especificação Solana Pay
• Integração nativa da especificação da API Digital Assets Standard (DAS)
• Melhor suporte a tokens baseados em Token Extension
• Melhor suporte a Address Lookup Tables
• Documentação mais abrangente

Incluído na biblioteca gill, o pacote @gillsdk/react ainda está em seus estágios iniciais (com nove hooks diferentes do React). Ele continua sendo desenvolvido para permitir que os desenvolvedores adicionem reatividade facilmente aos aplicativos baseados em React, incluindo suporte a todos os métodos RPC da Solana mais comuns e uma integração mais estreita com wallet-ui.

Curiosidade: há planos para integrar gill diretamente ao framework Anchor, permitindo que os desenvolvedores aproveitem com mais facilidade as otimizações e melhorias na experiência de desenvolvimento oferecidas pela gill em seus aplicativos. Quem sabe gill não se torne o padrão no Anchor v2. :shhh:

Como contribuir com Gill

A biblioteca gill é de código aberto (licença MIT), e contribuições são bem-vindas! Se você tiver interesse em contribuir com a biblioteca, confira as issues abertas e considere resolver uma delas.

Se quiser recomendar um novo recurso ou uma melhoria para a biblioteca, abra primeiro uma issue para iniciar uma conversa com os mantenedores antes de trabalhar no código de um PR.

Recursos adicionais

Encontre mais informações e recursos sobre gill nos links a seguir:

• Pacote @gillsdk/react no npm
• Sequência de posts do criador da gill - @nickfrosty
• Desenvolvimento na Solana com JavaScript: como usar gill
• Conta oficial da Gill no X
• Vídeo: Tutorial de JavaScript para Solana: comece a desenvolver para a web3 usando gill
• Playlist: JavaScript para Solana com gill