NUEVO: Helius adquiere Light Protocol
Una cometa flotando sobre el texto 'Presentamos Kite', un framework moderno de Solana para TypeScript.
Blog/Desarrollo

Presentamos Kite: el framework moderno de Solana para TypeScript

Formación para desarrolladoresMike MacCana en XMike MacCana en LinkedIn
4 min de lectura
Tabla de contenido

    Hoy nos complace anunciar Kite, el framework moderno de TypeScript para el navegador y Node.js. Kite aprovecha la potencia de Solana web3.js versión 2 y, al mismo tiempo, simplifica drásticamente las tareas comunes.

    ¿Por qué Kite?

    Kite aprovecha la velocidad y elegancia de Solana web3.js versión 2, pero te permite realizar tareas habituales de Solana con una sola función.

    Como Kite usa web3.js versión 2 para el trabajo pesado, tienes acceso a todas sus funcionalidades. Si ya no necesitas Kite, puedes eliminarlo fácilmente y usar web3.js versión 2 directamente.

    Kite es una actualización de @solana-developers/helpers para web3.js v2, la biblioteca de alto nivel más popular para web3.js versión 1, creada por el autor original.

    El paquete Kite incluye versiones actualizadas de la mayoría de las funciones auxiliares originales, con contribuciones de Helius, Solana Foundation, Anza, Turbin3, Unboxed Software y StarAtlas.

    Pronto agregaremos a Kite las funciones de @solana-developers/helpers que aún faltan.

    Kite funciona tanto en el navegador como en node.js y tiene dependencias mínimas.

    ¿Qué puedo hacer con Kite?

    Kite incluye funciones para hacer lo siguiente:

    Billeteras

    SOL

    Tokens

    Transacciones

    Explorador

    Comparación entre Kite y Solana web3.js 2:

    Este es un ejemplo rápido de cómo crear un token

    Con Kite

    Recuerda que Kite es solo un framework construido sobre web3.js v2, por lo que usa los mismos tipos y las mismas funcionalidades subyacentes de web3.js v2 para hacer su trabajo.

    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));

    Con Solana web3.js v2

    ...¡sin 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 puedes ver, sin Kite tendrías que crear un mensaje de transacción con cinco instrucciones y las opciones correspondientes, firmarlo y enviarlo al RPC. En Kite, ejecutas makeTokenMint y recibes la dirección del nuevo mint.

    Comparación entre Kite y Poseidon

    Kite es una biblioteca que funciona exclusivamente del lado del cliente para navegadores y node.js. Explora Poseidon si te interesa crear aplicaciones on-chain (por ejemplo, contratos inteligentes) con TypeScript. 

    Contribuciones

    Aunque Kite es nuevo, nos comprometemos a convertirlo en un framework sólido que haga el desarrollo en Solana más accesible para todos.

    Al simplificar las tareas comunes y reducir el código repetitivo, podemos ayudar a más desarrolladores a crear proyectos increíbles en Solana.

    Así puedes ayudar:

    Prueba Kite hoy

    ¿Todo listo para simplificar tu desarrollo en Solana?

    Empieza a usar Kite:

    Installing Kite
    npm i @helius-dev/kite

    Consulta nuestro repositorio de GitHub para ver la documentación completa y los ejemplos.

    ¡Aceleremos juntos el desarrollo en Solana! 🪁

    Artículos relacionados

    Suscríbete a Helius

    Mantente al día con las novedades del desarrollo en Solana y recibe actualizaciones cuando publiquemos