process_categories``categories``[0, 1]Para llamar a la Afunción desde una aplicación de Node.js con el SDK Sui TypeScript, pasa el Bargumento como una matriz de números correspondientes a las variantes de enumeración (por ejemplo, for,). The Move vector<Category>deserializará automáticamente los valores numéricos en las variantes de enumeración correctas. Usa el transactionobjeto del SDK para crear la llamada:

const tx = new Transaction();
tx.moveCall({
  target: `${packageId}::module_name::process_categories`,
  arguments: [tx.pure([0, 1])], // e.g., Category::A, Category::B
});

Asegúrese de que la enumeración esté definida en su módulo Move y de que el paquete esté correctamente referenciado.

Para llamar a la process_categoriesfunción desde tu aplicación Node.js con el SDK Sui TypeScript, debes hacer lo siguiente:

1.Instale el SDK de Sui

Primero, asegúrate de tener el SDK de Sui instalado en tu proyecto:

npm install @mysten/sui.js

###2.Configurar la conexión

A continuación, tendrás que conectarte a la red Sui. Esto se hace con el JsonRpcProviderfin de acceder a la cadena de bloques.

import { JsonRpcProvider, RawSigner, Ed25519Keypair } from '@mysten/sui.js';

const provider = new JsonRpcProvider('https://fullnode.devnet.sui.io:5001'); // Change the URL if you're using Testnet/Mainnet
const keypair = Ed25519Keypair.fromFile('path/to/your/secret.key'); // Path to your private key
const signer = new RawSigner(keypair, provider);

3.Crea el vector de categorías

La función a la que llamas toma un vector de Categoryvalores, por lo que tendrás que pasarlo como argumento. Como estás pasando valores de enumeración como A``B, yC, querrás preparar la matriz de categorías.

const categories = ["A", "B", "C"];  // These are the categories you want to pass

4.Cree y envíe la transacción

Ahora, crearás una transacción que llame a tu process_categoriesfunción y pase las categorías como argumento. Usarás el TransactionBlockpara configurarlo.

import { TransactionBlock } from '@mysten/sui.js';

const tx = new TransactionBlock();

// Create the vector of categories as an argument
const categoriesArg = tx.makeMoveVec(categories.map(category => tx.pure(category)));

// Call the Move function, passing the categories
tx.moveCall({
  target: '0xYourPackageAddress::YourModule::process_categories', // Replace with your actual package and module address
  arguments: [categoriesArg],
});

// Sign and execute the transaction
const response = await signer.signAndExecuteTransactionBlock({ transactionBlock: tx });
console.log('Transaction response:', response);

Qué está pasando:

*Creando categorías: Estás creando un vector de las categorías A``By, a modo de Cmatriz simple, las conviertes a un formato que Sui entienda. *Llamar a la función de movimiento: Le estás diciendo a Sui que llame process_categoriescon el vector de categorías. *Firmar la transacción: RawSignerFirma la transacción y, a continuación, la ejecuta en la red.

Notas clave:

*Dirección del paquete: sustitúyala por 0xYourPackageAddress::YourModule::process_categoriesla dirección real de tu módulo Move. *Confirmación de la transacción: Esto debería enviar la transacción y recibirás una respuesta en tu consola. Si hay algún problema, la respuesta normalmente te indicará qué fue lo que salió mal.

Para llamar process_categoriesdesde Node.js con el SDK de Sui TS, es necesario: 1.Serialice el Categoryvector de enumeraciónmediante BCS. 2.Cree y ejecute la transacción.

####Código de ejemplo (Node.js) :

import { Transaction } from '@mysten/sui.js/transactions';
import { bcs } from '@mysten/sui.js/bcs';

// Define BCS type for the enum (must match Move definition)
bcs.registerEnumType('Category', {
  A: null,
  B: null,
  C: null,
});

const tx = new Transaction();
tx.moveCall({
  target: '0xPACKAGE_ID::module_name::process_categories',
  arguments: [
    tx.pure(bcs.vector(bcs.Category).serialize(['A', 'B', 'C']), // Categories vector
    tx.pure.address('0xYourAddress'), // TxContext (if needed)
  ],
});

// Sign and execute
const signedTx = await wallet.signTransaction(tx);
const result = await client.executeTransaction(signedTx);

###Pasos clave:

1. A``B``CRegistrar BCS Enum: Coincide con la enumeración de movimientos (,,).
2. bcs.vector()Serializar vector: utilícelo para el argumento. 3.Función Call Move: especifique el paquete, el módulo y la función.

###Notas:

• Sustituya 0xPACKAGE_IDy por module_namesus valores actuales.
• Asegúrese de que la billetera (wallet) y el cliente (client) estén inicializados.

Para llamar a la process_categoriesfunción desde una aplicación de Node.js mediante el SDK de Sui TypeScript y pasar vector<Category>a como argumento, tendrás que serializar los valores de enumeración en el formato que Sui Move espera durante la ejecución de la transacción. En tu caso, Categoryes un movimiento enumcon variantes A``By, Cque se representan comodiscriminantesnuméricos (0, 1, 2) en la codificación BCS. vector<Category>Como Move espera avector<u8>, tendrás que serializar los valores de la enumeración como a TransactionBlocky pasarlos a la función correctamente mediante el.

@mysten/sui.jsAsí es como puedes hacerlo desde Node.js usando:

import { TransactionBlock, SuiClient, getFullnodeUrl } from '@mysten/sui.js';
import { bcs } from '@mysten/bcs';

// Enum mapping: A = 0, B = 1, C = 2
const CategoryEnum = {
  A: 0,
  B: 1,
  C: 2,
};

// Example categories you want to send
const selectedCategories = [CategoryEnum.A, CategoryEnum.B];

// Serialize the enum values into a BCS vector<u8>
const serializedCategories = bcs.vector(bcs.u8()).serialize(selectedCategories).toBytes();

// Build the transaction
const tx = new TransactionBlock();
tx.moveCall({
  target: '0xYourPackage::your_module::process_categories',
  arguments: [tx.pure(serializedCategories, 'vector<u8>')],
});

// Execute the transaction
const client = new SuiClient({ url: getFullnodeUrl('testnet') });
const result = await client.signAndExecuteTransactionBlock({
  signer: yourWalletOrKeypair,
  transactionBlock: tx,
});

console.log('Transaction result:', result);

Este patrón garantiza que los valores de enumeración se pasen correctamente codificados vector<Category>de JavaScript a Move. Solo asegúrate de que tu módulo Move esté publicado en cadena y de que hagas referencia a la targetdirección y el nombre del módulo correctos.

Para obtener información sobre los argumentos de Move y la serialización de enumeraciones mediante BCS, consulta: https://docs.sui.io/build/programmable-transactions