Oui, il existe plusieurs façons de suivre lestransactions de publicationdans Sui. En voici le détail :

1.Diffusion d'événements transactionnels :

• LeStreamingest l'approche la plus flexible car vous pouvez suivre les transactions au fur et à mesure qu'elles sont publiées et traitées sur le réseau. Vous pouvez diffuser les transactions et filtrer les publishcommandes dans les événements.
• Vous pouvez utiliser l'API Sui JSON-RPCouWebSocketpour vous abonner aux événements de transaction. Plus précisément, les onTransaction``onEventméthodes ou RPC vous fourniraient les détails des transactions en temps réel.

Vous pouvez ensuite filtrer les Publishévénements en examinant le type de transaction, car une transaction de publication inclura une Publishcommande** type**spécifique à laquelle vous pouvez faire correspondre.

Voici un exemple dans TypeScript utilisant le SDK Sui pour diffuser et filtrer les transactions de publication :

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

const provider = new JsonRpcProvider('https://fullnode.devnet.sui.io');

async function subscribeToPublishTransactions() {
    const subscription = provider.subscribeTransaction((tx) => {
        if (tx.type === 'publish') {
            console.log('Publish Transaction Detected:', tx);
        }
    });

    // To stop streaming
    // subscription.unsubscribe();
}

subscribeToPublishTransactions();

###2.Filtrage au niveau du noeud :

Malheureusement, pour l'instant, le nœud Sui ne fournit pas de moyen direct defiltrerpour des types de transactions spécifiques (commepublish) côté nœud via le RPC. Vous devrez filtrer ces transactions au niveau de l'application, comme indiqué ci-dessus, en inspectant le type ou la commande dans les données de transaction.

3.Point de terminaison du statut des transactions :

Une autre option consiste à utiliser le getTransactionpoint de terminaison de l'API JSON-RPC. Après avoir publié une transaction, vous pouvez interroger ce point de terminaison pour connaître l'état de la transaction et vérifier s'il s'agit d'un publishtype.

Conclusion :

publish* LeStreamingest le moyen le plus simple et le plus flexible de suivre publishles transactions en temps réel, car il vous permet de surveiller tous les types de transactions et de filtrer directement les événements.

• Pour l'instant, il n'y a pas de filtrage intégré pour publishles transactions côté nœud. Le filtrage doit être effectué côté client après réception des événements de transaction.

###Suivez facilement les transactions de publication 1.À utiliser suix_queryTransactionBlocksavec un filtre :

curl -X POST https://fullnode.mainnet.sui.io \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "suix_queryTransactionBlocks",
    "params": [{
      "MoveFunction": "0x2::package::publish"
    }, null, 10]
  }'

2.Diffusez via WebSocket(en temps réel) :

const client = new SuiClient({ url: 'wss://fullnode.mainnet.sui.io' });
client.subscribeEvent({
  filter: { MoveEventType: '0x2::package::PublishEvent' },
  onMessage: (event) => console.log('Published:', event)
});

Oui, vous pouvez suivre les transactions de publication de manière plus efficace en tirant parti desAPI de filtrage des transactionset des mécanismes d'abonnement aux événements de Sui, mais avec certaines limites en fonction de la configuration du nœud. L'approche la plus simple consiste àsouscrire aux MoveModulePublishedévénementsémis lors de la publication d'un package. Cela permet d'éviter de scanner chaque transaction manuellement.

Pour ce faire, vous pouvez utiliser la suix_queryEventsméthode RPC avec un filtre d'événements tel que :

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "suix_queryEvents",
  "params": [
    {
      "MoveModule": {
        "package": "0x0000000000000000000000000000000000000002",
        "module": "package"
      }
    },
    null,
    10,
    null
  ]
}

Ou plus généralement, filtrez simplement par type d'événement MoveModulePublishedsans nécessiter de package ou de module spécifique. Notez que tous les fullnodes n'indexent pas correctement les événements, sauf s'ils sont configurés en tant que nœuds d'archive.

Si vous créez un indexeur ou un flux, vous pouvez également suivre les blocs de transactions à l'aide de sui_getTransactionBlockou sui_queryTransactionBlockset filtrer par Publishtype de transaction.

Pour une solution plus évolutive, configurez unSui fullnode avec l'indexation des événements activéeet utilisez l'--enable-event-dbindicateur dans la configuration de votre nœud. Cela améliore considérablement les performances des requêtes d'événements.

Vous trouverez une documentation complète à ce sujet ici : https://docs.sui.io/build/events et https://docs.sui.io/sui-jsonrpc.

###1. Filtre gRPC direct (le plus rapide)

# Filter publishes only
grpcurl -plaintext -d '{
  "filter": {
    "MoveFunction": "0x2::package::publish"
  }
}' localhost:9000 sui.rpc.v2.Read/QueryTransactionBlocks

###2. WebSocket (en temps réel)

const client = new SuiClient({ url: 'wss://fullnode.mainnet.sui.io' });
const unsubscribe = client.subscribeEvent({
  filter: { MoveEventType: '0x2::package::PublishEvent' },
  onMessage: (event) => console.log('New publish:', event)
});

###3. Raccourci de l'explorateur -Suisse : https://suiscan.xyz/mainnet/packages -Sui Vision : Filtrer par type de transaction « Publier »

###Configuration du nœud (facultatif) Ajoutez à fullnode.yamlpour une indexation spécifique à la publication :

event-handlers:
  - event-type: publish
    sink:
      type: webhook
      url: "your-webhook-url"

###Pourquoi cela fonctionne

• Publiez les transactions, utilisez toujours 0x2::package::publish
• PublishEventContient toutes les métadonnées (ID du colis, expéditeur, etc.)

Pour les données historiques en masse, utilisez :

sui-tool query-tx --module package --function publish --limit 100

Oui, il existe des moyens plus simples de suivre les transactions de publication sur leréseau Suisans avoir à diffuser toutes les transactions et à les filtrer manuellement. Vous pouvez tirer parti de l'API Sui RPCpour interroger et filtrer les transactions, ce qui peut vous aider à suivre directement publishles commandes sans vous soucier du bruit de transaction inutile.

1.Utilisation du point de get_transactionsterminaison RPC (avec filtres)

L'API Sui RPC fournit un get_transactionspoint de terminaison qui vous permet de filtrer les transactions en fonction de divers paramètres, notamment le type de transaction qui vous intéresse. Pour suivre lestransactions de publication, vous pouvez filtrer en fonction du MoveCalltype de transaction et rechercher des commandes spécifiques correspondant à la publication d'un module Move.

Exemple : Filtrer les transactions par type

Vous pouvez demander à filtrer lestransactions de publicationen vérifiant les MoveCalltransactions avec des appels de fonction spécifiques (ceux liés à la publication). Voici comment vous pourriez structurer votre requête :

GET /v1/transactions?Filter[TransactionType]=MoveCall&Filter[MoveFunctionName]=publish

Cela vous aidera à interroger spécifiquement les transactions liées à la publication d'un module Move, en filtrant les transactions inutiles.

###2.Flux de transactions avec filtres

Vous pouvez diffuser des transactions à l'aide de l'API Sui WebSocketou via un long sondage avec le RPC pour obtenir des mises à jour des transactions en direct. Dans ce cas, le filtrage au niveau du nœud pour les transactions de publication peut s'avérer plus compliqué, mais vous pouvez toujours diffuser les transactions et les filtrer côté client en utilisant l'approche suivante :

1.Diffusez les transactionsà l'aide de l'API WebSocket. 2.Filtrepour les transactions contenant des MoveCallfonctions liées à la publication ou l'adresse spécifique liée au contrat en cours de publication.

Voici un exemple de requête de flux de transactions (pseudo-code pour un WebSocket) :

const socket = new WebSocket("ws://localhost:5001");

socket.onmessage = function(event) {
    const txData = JSON.parse(event.data);
    if (txData.type === "MoveCall" && txData.function === "publish") {
        console.log("Publish Transaction Detected:", txData);
    }
};

Cette approche permet le suivi en temps réel des transactions de publication.

3.Sui Explorer (pour le suivi visuel)

Pour le suivi non programmatique, vous pouvez utiliser leSui Explorerpour surveiller les transactions dans une interface visuelle. Sui Explorer vous permet de rechercher des types de transactions spécifiques, y compris la publication du module Move. Bien que cela ne soit pas automatique, cela peut être utile pour des vérifications rapides pendant le développement ou les tests.

*Sui Explorer : Sui Explorer

##4.Surveillez l'publishévénement (si disponible)

S'il existe un événement spécifiquement lié à la publication, par exemplePublishEvent, vous pouvez l'écouter directement (à l'aide de la fonctionnalité basée sur les événements) dans votre application, s'il est pris en charge par le nœud Sui ou le framework blockchain. Bien que cette fonctionnalité ne soit pas disponible immédiatement, les futures implémentations ou solutions développées par la communauté pourraient ajouter cette fonctionnalité.

##5.Automatisez le suivi grâce à des sondages périodiques

Pour le suivi périodique des transactions publiées, vous pouvez utiliser le get_transactionspoint de terminaison à intervalles réguliers pour rechercher les modules récemment publiés. Cela évite le streaming continu mais vous permet de bénéficier de mises à jour fréquentes :

use reqwest::blocking::get;
use serde_json::Value;

fn fetch_transactions() -> Result<Value, reqwest::Error> {
    let url = "http://localhost:5001/v1/transactions?Filter[TransactionType]=MoveCall&Filter[MoveFunctionName]=publish";
    let response = get(url)?;
    let json: Value = response.json()?;
    Ok(json)
}

Cela peut être utilisé dans un système backend qui vérifie périodiquement la présence de nouvelles publishtransactions.

Résumé :

get_transactions``MoveCall*Filtrage des requêtes RPC : utilisez le publishpoint de terminaison avec des filtres pour affiner les transactions à l'aide de la fonction. MoveCall*WebSocket Streaming : diffusez toutes les transactions et filtrez les transactions liées à la publication. *Explorer : utilisez le Sui Explorer pour le suivi manuel, particulièrement utile pour l'inspection visuelle. *Sondage périodique : implémentez un mécanisme de sondage pour récupérer régulièrement les transactions pour les nouveaux événements de publication.

Chaque méthode peut être adaptée en fonction de votre cas d'utilisation, que vous construisiez un système automatisé ou que vous ayez simplement besoin de vérifications manuelles rapides.