NOVO: Helius adquire a Light Protocol
Uma pipa flutuando acima do texto 'Apresentamos o Kite', um framework moderno da Solana para TypeScript.
Blog/Desenvolvimento

Apresentamos o Kite: o framework moderno da Solana para TypeScript

Educação para desenvolvedoresMike MacCana no XMike MacCana no LinkedIn
4 min de leitura
Índice

    Hoje, temos o prazer de anunciar o Kite, o framework moderno de TypeScript para navegadores e Node.js. O Kite aproveita o poder do Solana web3.js versão 2 e, ao mesmo tempo, simplifica drasticamente as tarefas comuns.

    Por que usar o Kite?

    O Kite aproveita a velocidade e a elegância do Solana web3.js versão 2, mas permite realizar tarefas cotidianas da Solana com uma única função.

    Como o Kite usa o web3.js versão 2 para fazer o trabalho pesado, todos os recursos do web3.js versão 2 ficam disponíveis. Se você não precisar mais do Kite, poderá removê-lo facilmente e usar apenas o web3.js versão 2.

    O Kite é uma atualização do @solana-developers/helpers para o web3.js v2, a biblioteca de alto nível mais popular para o web3.js versão 1, criada pelo autor original.

    O pacote Kite inclui versões atualizadas da maioria dos helpers originais, incluindo contribuições da Helius, Solana Foundation, Anza, Turbin3, Unboxed Software e StarAtlas.

    As funções do @solana-developers/helpers que ainda não estão disponíveis no Kite serão adicionadas em breve.

    O Kite funciona tanto no navegador quanto no node.js e tem dependências mínimas.

    O que posso fazer com o Kite?

    O Kite inclui funções para fazer o seguinte:

    Carteiras

    SOL

    Tokens

    Transações

    Explorer

    Comparação entre o Kite e o Solana web3.js 2:

    Veja um exemplo rápido de como criar um token

    Usando o Kite

    Lembre-se: o Kite é apenas um framework criado sobre o web3.js v2. Por isso, ele usa os mesmos tipos e recursos subjacentes do web3.js v2 para executar seu trabalho.

    Making a token (including metadata) using Kite
    import { connect } from "@helius-dev/kite";
const connection = connect();
const mintAddress = await connection.makeTokenMint(
  mintAuthority,
  6,
  "My Token",
  "MTKN",
  "https://example.com/metadata.json",
  {
    description: "A sample token",
    website: "https://example.com",
  },
);
console.log(connection.getExplorerLink(mintAddress));

    Usando o Solana web3.js v2

    ...sem o Kite!

    Making a token using web3.js version 2
    import {
  airdropFactory,
  appendTransactionMessageInstructions,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  createTransactionMessage,
  generateKeyPairSigner,
  getSignatureFromTransaction,
  lamports,
  pipe,
  sendAndConfirmTransactionFactory,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  signTransactionMessageWithSigners,
  some,
} from "@solana/web3.js";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
  getInitializeMintInstruction,
  getMintSize,
  TOKEN_2022_PROGRAM_ADDRESS,
  extension,
  getInitializeMetadataPointerInstruction,
  getInitializeTokenMetadataInstruction,
  tokenMetadataField,
  getUpdateTokenMetadataFieldInstruction,
} from "@solana-program/token-2022";

const rpc = createSolanaRpc("http://127.0.0.1:8899");
const rpcSubscriptions = createSolanaRpcSubscriptions("ws://127.0.0.1:8900");

const feePayer = await generateKeyPairSigner();
console.log(feePayer.address);
const mint = await generateKeyPairSigner();

await airdropFactory({ rpc, rpcSubscriptions })({
  recipientAddress: feePayer.address,
  lamports: lamports(1_000_000_000n),
  commitment: "confirmed",
});

const balance = await rpc.getBalance(feePayer.address).send();
console.log("balance:", balance.value);

const metadataPointerExtension = extension("MetadataPointer", {
  authority: some(feePayer.address),
  metadataAddress: some(mint.address),
});

const tokenMetadataExtension = extension("TokenMetadata", {
  updateAuthority: some(feePayer.address),
  mint: mint.address,
  name: "OPOS",
  symbol: "OPOS",
  uri: "https://raw.githubusercontent.com/solana-developers/opos-asset/main/assets/DeveloperPortal/metadata.json",
  additionalMetadata: new Map<string, string>([["description", "Only Possible On Solana"]]),
});

const spaceWithoutMetadata = BigInt(getMintSize([metadataPointerExtension]));

const spaceWithMetadata = BigInt(getMintSize([metadataPointerExtension, tokenMetadataExtension]));

const rent = await rpc.getMinimumBalanceForRentExemption(spaceWithMetadata).send();

const createAccountInstruction = getCreateAccountInstruction({
  payer: feePayer,
  newAccount: mint,
  lamports: rent,
  space: spaceWithoutMetadata,
  programAddress: TOKEN_2022_PROGRAM_ADDRESS,
});

const initializeMetadataPointerInstruction = getInitializeMetadataPointerInstruction({
  mint: mint.address,
  authority: feePayer.address,
  metadataAddress: mint.address,
});

const initializeMintInstruction = getInitializeMintInstruction({
  mint: mint.address,
  decimals: 2,
  mintAuthority: feePayer.address,
});

const initializeTokenMetadataInstruction = getInitializeTokenMetadataInstruction({
  metadata: mint.address,
  updateAuthority: feePayer.address,
  mint: mint.address,
  mintAuthority: feePayer,
  name: tokenMetadataExtension.name,
  symbol: tokenMetadataExtension.symbol,
  uri: tokenMetadataExtension.uri,
});

const updateTokenMetadataInstruction = getUpdateTokenMetadataFieldInstruction({
  metadata: mint.address,
  updateAuthority: feePayer,
  field: tokenMetadataField("Key", ["description"]),
  value: "Only Possible On Solana",
});

const instructions = [
  createAccountInstruction,
  initializeMetadataPointerInstruction,
  initializeMintInstruction,
  initializeTokenMetadataInstruction,
  updateTokenMetadataInstruction,
];

const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (message) => setTransactionMessageFeePayerSigner(feePayer, message),
  (message) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, message),
  (message) => appendTransactionMessageInstructions(instructions, message),
);

const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);

const transactionSignature = getSignatureFromTransaction(signedTransaction);

await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(signedTransaction, {
  commitment: "confirmed",
  skipPreflight: true,
});

console.log("Transaction Signature:", `https://explorer.solana.com/tx/${transactionSignature}?cluster=custom`);

    Como você pode ver, sem o Kite, seria necessário criar uma mensagem de transação com cinco instruções e as opções relevantes, assinar a mensagem de transação e enviá-la ao RPC. No Kite, você executa makeTokenMint e recebe de volta o endereço do novo mint.

    Comparação entre o Kite e o Poseidon

    O Kite é uma biblioteca totalmente client-side para navegadores e node.js. Conheça o Poseidon se você tiver interesse em criar aplicativos on-chain (por exemplo, smart contracts) usando TypeScript. 

    Como contribuir

    Embora o Kite seja novo, estamos comprometidos em transformá-lo em um framework robusto que torne o desenvolvimento na Solana mais acessível para todos.

    Podemos ajudar mais desenvolvedores a criar projetos incríveis na Solana simplificando tarefas comuns e reduzindo o código boilerplate.

    Veja como você pode ajudar:

    Experimente o Kite hoje mesmo

    Tudo pronto para facilitar seu desenvolvimento na Solana?

    Comece a usar o Kite:

    Installing Kite
    npm i @helius-dev/kite

    Acesse nosso repositório no GitHub para conferir a documentação completa e os exemplos.

    Vamos acelerar juntos o desenvolvimento na Solana! 🪁

    Artigos relacionados

    Assine a Helius

    Acompanhe as novidades mais recentes do desenvolvimento Solana e receba atualizações quando publicarmos