Artikel

Bildungsmaterialien und Tutorials über Sui

Beiträge

harry phan65
Apr 13, 2025
Artikel
Objektzugriffskontrolle und Empfangsmechanik
Dies ist Teil 2 der Serie „Eltern-Kind-Objekte in Sui Move“. Teil 1 können Sie hier lesen Übertragung der Objektzugriffskontrolle: :receive Mechanics Sie haben also ein ObjektXin ein übergeordnetesPgesteckt (indem Sie X auf die ID von P übertragen haben) — wie holen Sie es wieder heraus oder verwenden es? 🤔 An dieser Stelle kommt Suis spezieller Empfangsmechanismus ins Spiel. Wenn ein Objekt an ein übergeordnetes Objekt übertragen wird, springt es nicht automatisch heraus. Es befindet sich dort und gehörtP. Um dieses untergeordnete Objekt in einer Transaktion verwenden oder entfernen zu können, müssen Sie esempfangen. Sui bietet eine strukturierte Möglichkeit, dies mithilfe einesEmpfangsticketund der Funktion transfer: :receive zu tun. ##Das Empfangsticket Stellen Sie sich Wareneingang als Anspruchsticket für ein untergeordnetes Objekt des Typs T vor. Anstatt das untergeordnete Objekt (das Sie noch nicht besitzen) direkt an eine Funktion weiterzuleiten, übergeben Sie einen Wareneingang — im Wesentlichen einen Verweis auf „das Objekt mit der ID Y, das dem übergeordneten Objekt X gehört“. Dieses Receiving ist eine spezielle Move-Struktur, die die ID, Version und den Digest des Objekts enthält, das empfangen werden soll. Sie hat nur die Fähigkeit, sie abzulegen, was bedeutet, dass sie kurzlebig existieren kann, aber nicht dauerhaft gespeichert werden kann. Mit anderen Worten, es handelt sich um ein Ticket zur einmaligen Verwendung innerhalb einer Transaktion. Wie bekommt man eine Quittung? In der Regel, indem Sie die Übertragung durchführen. In einem programmierbaren Transaktionsblock (PTB) kann ein Schritt das ObjektCan das übergeordnete ObjektPübertragen, wodurch ein Empfangsticket entsteht, das der nächste Schritt verwenden kann. Wenn das Kind bereits in einer früheren Transaktion im übergeordneten Objekt saß, können Sie einen Empfang als Eingabe für eine neue Transaktion angeben (das Sui SDK/CLI ermöglicht es Ihnen, ein untergeordnetes Objekt anhand seiner ID und des übergeordneten Objekts anzugeben, um das Ticket zu generieren). Wichtig: Eine Empfangsfunktion ist nicht das Objekt selbst — es überträgt Ihnen noch keine Eigentumsrechte. Es signalisiert nur, dass „ein Objekt vom Typ T mit dieser ID diesem Elternteil gehört und ich beabsichtige, es zu übernehmen“. Um das Objekt tatsächlich abzurufen, müssen Sie transfer: :receive: aufrufen: module example::toy_box { use sui::transfer::{Self, Receiving}; struct Toy has key { id: UID, name: vector } struct Box has key { id: UID } /// Remove a Toy child from a Box, returning the Toy to the caller. public entry fun take_toy(box: &mut Box, toy_ticket: Receiving): Toy { // Use the parent's UID and the Receiving ticket to get the Toy let toy = transfer::receive(&mut box.id, toy_ticket); // Now toy is an owned value we can return (or transfer to someone). toy } } In take_toy steht toy_ticket: Receiving für ein Spielzeug, das zur Box gehört. Durch den Aufruf von transfer: :receive (&mut box.id, toy_ticket) rufen wir die native Logik von Sui auf, um das Toy-Objekt tatsächlich aus der Box abzurufen. Das macht ein paar wichtige Dinge: Esüberprüftzur Laufzeit, ob das toy_ticket tatsächlich auf ein Objekt verweist, das derzeit der Box gehört (unter Verwendung der UID des übergeordneten Objekts). Wenn etwas nicht passt (falsches übergeordnetes Objekt oder Objekt, das nicht wirklich vorhanden ist), wird der Vorgang abgebrochen. Es gibt dann das eigentliche Toy-Objekt als eigenen Wert in der Transaktion zurück, was bedeutet, dass das Spielzeug jetzt unter der Kontrolle unserer Funktion steht. Beachten Sie, dass wir &mut box.id übergeben mussten. Sui erzwingt, dass wir eineveränderbare Referenz auf die UIDdes Elternteils haben, um den Empfang aufzurufen. Das ist eine clevere Zugriffskontrolle: Nur das Modul, das eine &mut-UID des Elternteils erzeugen kann, kann den Empfang zulassen. Normalerweise stellt das Definitionsmodul des übergeordneten Typs eine Funktion wie take_toy bereit, die interne Aufrufe empfangen. Wenn das übergeordnete Modul keine Funktion bereitstellt, die eine &mut-UID ausgibt (direkt oder indirekt), kann kein externer Code seine untergeordneten Elemente abrufen. Auf diese Weise steuert das Modul der Eltern, wie und wann auf Kinder zugegriffen werden kann. Im Beispiel hat Box ein Feld id: UID. Da sich take_toy im selben Modul befindet, kann es &mut box.id ausleihen. Externe Module oder Transaktionen können take_toy (box_obj, ticket) aufrufen, aber sie können nicht selbst transfer: :receive auf Box aufrufen, da box.id privat ist. Dieses Muster stellt sicher, dass nur autorisierter Code Kinder abrufen kann.✅ Was ist mit verschachtelten Objekten? Wenn Toy buchstäblich ein Feld in der Box wäre (sagen wir Box {id, toy: Toy}), bräuchten wir keinen Empfang — das Spielzeug wäre immer zugänglich, wenn Sie &mut Box haben. Das bedeutet aber auch, dass es schwieriger ist, es zu entfernen oder es separat zu behandeln (es ist wie ein Teil der Box). Bei Objekten für Kinder entkoppeln wir den Stauraum: Das Spielzeug ist separat und muss explizit herausgenommen werden. Diese Deutlichkeit ist der Grund, warum Sui die Option „Ticket annehmen“ und „Anruf annehmen“ verlangt — so wird das Abrufen von Kindern zu einer autorisierten Aktion. Veränderbare Referenzanforderung: Sie fragen sich vielleicht, warum &mut UID und nicht nur &UID? Mutable stellt sicher, dass das übergeordnete Objekt während des Empfangsvorgangs gesperrt ist, wodurch gleichzeitige Änderungen verhindert werden und sichergestellt wird, dass der Anrufer tatsächlich das Recht hat, dieses übergeordnete Objekt zu ändern (was normalerweise bedeutet, dass er der Eigentümer ist). Das ist Teil der dynamischen Eigentumsüberprüfung von Sui. Indem Sui die UID des Elternteils veränderbar ausnutzt, garantiert Sui, dass keine andere Transaktion oder parallele Aktion stören kann, während Sie das Kind herausziehen. Es ist ein bisschen so, als würde man die Tür der Eltern verriegeln, bevor man den Inhalt herausnimmt. Beispiel für die Verwendung in einem Transaktionsblock: Angenommen, ein Box-Objekt gehört Alice, und sie hat ein Toy-Objekt, das sie in die Box legen möchte und dann vielleicht Also nimm es später heraus. So könnte es aussehen, okay: Spielzeug an der Kiste befestigen:** Alice ruft transfer: :public_transfer (toy, @); in einer PTB auf. Dadurch wird das Spielzeug unter die Box übertragen (wir verwenden hier public_transfer, weil es ein Transaktionskontext ist — dazu bald mehr). Jetzt ist das Spielzeug ein Kind der Box. -Rufen Sie in derselben oder einer anderen Transaktion Spielzeug ab: Alice ruft example: :toy_box: :take_toy (box_obj,) auf, wobei Receiving auf das Spielzeug verweist. Unter der Haube ruft take_toy den Empfang an, überprüft die Beziehung und gibt das Spielzeug zurück. Jetzt wäre das Spielzeug eine Ausgabe der Transaktion und landet normalerweise wieder unter Alices Adresse (da wir es von einer Eingabefunktion zurückgegeben haben). Wichtige Erkenntnisse: Auf untergeordnete Objekte kann standardmäßig nicht zugegriffen werden. Sie benötigen ein Empfangsticket und eine entsprechende Funktion, um sie herauszuholen. — Das übergeordnete Modul entscheidet, wie Sie Daten abrufen können (indem Sie eine Funktion mit &mut UID bereitstellen). transfer: :receive wird innerhalb des Definitionsmoduls des übergeordneten Moduls für Objekte dieses Moduls oder seiner Freunde verwendet. Wenn der Typ des Kindes an anderer Stelle definiert ist, benötigen Sie einen anderen Ansatz (geben Sie public_receive... ein). Bevor wir weitermachen, noch ein Detail: Wenn ein Objekttyp T nur die Schlüsselfähigkeit hat (kein Speichern), behandelt Sui sie etwas eingeschränkter. Solche Objekte können nicht mit generischem Code außerhalb ihres Moduls empfangen werden. In der Praxis bedeutet das, wenn T nur einen Schlüssel hat und ein untergeordnetes Objekt wird, müssen Sie den Abruf in einem eigenen Modul oder im Modul des Elternteils mit einer benutzerdefinierten Regel durchführen. Wenn T auch Speicher hat, haben wir über public_receive mehr Flexibilität. Lassen Sie uns das als Nächstes untersuchen.
- Sui
2
harry phan65
Apr 12, 2025
Artikel
✏️ Eltern-Kind-Objekte in Sui Move
In Sui Move können Objekte andere Objekte besitzen, genau wie Accounts eigene Objekte. Das eröffnet Entwicklern neue Entwurfsmuster (und ein paar Fallstricke). In diesem Handbuch werde ich die Konzepte von über- und untergeordneten Objekten in Sui Move in vier Teile unterteilen: 1.Einführung in die Eltern-Kind-Konzepte in Sui Move 2.Objektzugriffskontrolle und Empfangsmechanik 3.Modulübergreifende Kinderverwaltung mit public_receive 4.Seelenbindende Logik und Muster für Rücksendebestätigungen Am Ende wirst du verstehen, wie man Objekte verschachtelt, untergeordnete Objekte per transfer: :receive abruft, untergeordnete Objekte mit public_receive modulübergreifend verwaltet und sogar seelengebundene Objekte erstellt, die zu ihrem Besitzer zurückkehren. Einführung in die Eltern-Kind-Konzepte in Sui Move ###Was sind übergeordnete und untergeordnete Objekte? In Sui hat jedes Objekt eine eindeutige ID und einen Eigentümer. Normalerweise istder Besitzer eine Adresse(wie ein Benutzerkonto), aber der Besitzer kann auch ein anderes Objekt sein. Wenn Objekt A Objekt B besitzt, nennen wir A das Elternteil und B das Kind. Das Kind gehört dem Objekt und nicht der Adresse. Übertragung auf Objekte: Sui unterscheidet nicht wirklich zwischen einer Adresse und einer Objekt-ID unter der Haube — beide sind nur 32-Byte-Identifikatoren. Das bedeutet, dass Sie ein Objekt auf die ID eines anderen Objekts übertragen können, genauso wie Sie es an die Adresse eines Benutzers übertragen würden. Wenn Sie das tun, verschachteln Sie quasi ein Objekt innerhalb eines übergeordneten Objekts. Die Laufzeit von Sui setzt das Eigentümerfeld des Kindes auf die ID des Elternteils (statt auf eine Adresse) Also warum ist das cool? Weil das Kind seine eigene eindeutige ID behält und unabhängig im Speicher existiert, aber jetzt ist es an das Elternteil gebunden. Es ist, als ob du deinem Freund ein einzigartiges Sammlerstück gibst, das er in seinem Schließfach aufbewahren kann — das Sammlerstück behält seine ID und kann nachverfolgt werden, aber das Schließfach deines Freundes ist jetzt als Besitzer aufgeführt. Es ist wichtig,Einzigartige Objekte von verschachtelten Objekten und untergeordneten Objekten zu unterscheiden: Eindeutiges Objekt (im Besitz der Adresse) :**Ein reguläres Objekt, das einer Adresse gehört (z. B. ein Benutzerkonto). Dies ist der Standardfall — denken Sie an NFTs, Münzen usw., die sich direkt in der Brieftasche eines Benutzers befinden. Jedes hat eine eindeutige ID und befindet sich auf der obersten Speicherebene. Verschachteltes (umhülltes) Objekt:* Ein Objekt, das *in den Daten eines anderen Objekts gespeichert wird (z. B. als Feld in einer Struktur). In diesem Fall ist das innere Objekt verpackt undnichteine separate Entität der obersten Ebene. Es wird nicht anhand seiner ID im globalen Speicher angezeigt, da es Teil des Byte-Inhalts des übergeordneten Objekts ist. Wenn Sie in Sui ein Objekt ohne besondere Behandlung als Feld in ein anderes einfügen, wird es umschlossen. Untergeordnetes Objekt (Object-Owned) :*Ein Objekt, das einem anderen Objekt gehört, *aber nicht direkt in seine Felder eingeschlossen ist. Das untergeordnete Objekt bleibt ein separates Objekt der obersten Ebene im Speicher (mit eigener ID und eigenen Daten), und die ID des Elternteils wird in den Metadaten des Kindes als Besitzer aufgezeichnet. Das bedeutet, dass Sie das Kind anhand seiner ID abfragen oder darauf zugreifen können (mit den richtigen Berechtigungen). Es ist nicht physisch in den Inhalt der Eltern eingebettet, sondern gehört ihm nur logisch. Mit unserer Analogie ist es so, als ob du deinem Freund dein Sammlerstück zum Aufbewahren gegeben hast — es ist immer noch individuell markiert und verfolgbar, es wird nur in seinem Schließfach aufbewahrt. Der Vorteil, ein Kind zum Objekt zu machen (per Transfer), anstatt es zu verpacken, besteht darin, dass der Ausweis des Kindes von außen zugänglich bleibt. Beispielsweise können Explorer oder Wallets ein untergeordnetes Objekt nach seiner ID auflisten, wohingegen ein umschlossenes Objekt außerhalb des übergeordneten Objekts unsichtbar ist. Untergeordnete Objekte behalten auch dann stabile IDs bei, wenn sie zwischen Besitzern wechseln oder in verschiedenen übergeordneten Objekten verschachtelt werden. Das eignet sich hervorragend für Dinge wie Inventar auf der Kette oder Muster „Brieftasche in einer Brieftasche“, bei denen Sie möchten, dass ein Containerobjekt viele Gegenstände enthält, auf die andere immer noch einzeln verweisen können Eigentum und Zugriff: Wenn ein Objekt einem anderen Objekt gehört, kann in der Regel nur der Besitzer des übergeordneten Objekts auf das untergeordnete Objekt zugreifen oder es verwenden. Dies ist eine Form der dynamischen Autorisierung. Wenn Alice beispielsweise ein übergeordnetes Objekt P besitzt und P das untergeordnete Objekt C besitzt, dann kann nur Alice (oder Transaktionen, die Alice signiert) C manipulieren. Sui erzwingt dies, sodass der Besitz eines übergeordneten Objekts so ist, als würde man allen untergeordneten Objekten die Schlüssel halten 🔑. Vielleicht weißt du: Die Funktion zum Übertragen auf ein Objekt von Sui gibt uns im Grunde genommen baumähnliches Objektbesitz. Ein Elternteil kann viele Kinder haben (und diese Kinder können ihre eigenen Kinder haben, wodurch eine Hierarchie entsteht). Dies wird erreicht, indem Objekt-IDs wie Adressen für Übertragungen behandelt werden. Wir haben: Adresseigene Objekte**(normale eindeutige Objekte), Objekteigene Objekte**(untergeordnete Objekte, immer noch auf oberster Ebene, aber an ein übergeordnetes Objekt gebunden), Umschlossene Objekte**(verschachtelt in den Daten eines anderen Objekts, nicht auf oberster Ebene). In den nächsten Artikeln werden wir sehen, wie man untergeordnete Objekte tatsächlich abruft oder mit ihnen interagiert (da auf sie nicht direkt zugegriffen werden kann, wie es bei adresseigenen Objekten der Fall ist) und wie man Regeln für sie durchsetzt.
- Sui
- Move
3
harry phan65
Apr 10, 2025
Artikel
Aufbau einer NFT-Lotterie-dApp der nächsten Generation mit Sui Move und einer modernen Benutzeroberfläche
🧩 Erstellen einer NFT-Lotterie-dApp der nächsten Generation mit Sui Move und einer modernen Benutzeroberfläche Dies ist dein ultimativer Leitfaden zum Erstellen einer spielerischen, NFT-betriebenen Lotterie-DApp mitSui Move, mit Mehrrundenunterstützung, Empfehlungssystemen, DAO-Governance und einem Designsystem, das die Generation Z lieben wird. Von der Vertragsarchitektur bis zum UI-Flow — lassen Sie uns alles einbeziehen. 📦 Phasenzusammenbruch Phase 1 — Kernlotterie Mehrrunden-Gameplay NFT-Ticketing Prämiensystem für Empfehlungen Grundlegende DAO-Abstimmung Phase 2 — Marktplatz und Gamification Integration des NFT-Marktplatzes Booster (erhöhen Sie die Gewinnchance) Jackpot-System Versteckte Airdrops Phase 3 — DAO und Multichain Kettenübergreifende Kompatibilität DAO mit fortgeschrittenen Vorschlägen Dynamische Preisgestaltung On-Chain-Analysen 🧠 Smart Contract — Ein tiefer Einblick in Sui Move Vertragsstruktur module nft_lottery_x::nft_lottery_x { use sui::object; use sui::balance::{Balance, zero}; use sui::coin::{Self, Coin}; use sui::clock::Clock; use sui::random::Random; use sui::event::emit; use sui::transfer; use sui::tx_context::TxContext; use std::option; use std::signer; const EGameNotStarted: u64 = 1000; const EGameAlreadyFinished: u64 = 1001; const EInvalidPayment: u64 = 1002; const ENoTickets: u64 = 1003; const EWinnerAlreadyChosen: u64 = 1004; const ENotWinner: u64 = 1005; public struct Game has key { id: UID, ticket_price: u64, start_time: u64, end_time: u64, total_tickets: u32, round: u32, winner: Option, balance: Balance, referral_bonus: u64, } public struct Ticket has key { id: UID, game_id: ID, ticket_number: u32, buyer: address, referrer: Option, } public struct GameCreated has copy, drop { game_id: ID, start_time: u64, end_time: u64, ticket_price: u64, } public struct TicketBought has copy, drop { game_id: ID, ticket_number: u32, buyer: address, referrer: Option, } public struct WinnerAnnounced has copy, drop { game_id: ID, winner_ticket: u32, round: u32, } public struct RewardClaimed has copy, drop { game_id: ID, ticket_number: u32, amount: u64, } public fun create_game( start_time: u64, end_time: u64, ticket_price: u64, referral_bonus: u64, ctx: &mut TxContext ) { let game = Game { id: object::new(ctx), ticket_price, start_time, end_time, total_tickets: 0, round: 1, winner: option::none(), balance: zero(), referral_bonus, }; emit(GameCreated { game_id: object::id(&game), start_time, end_time, ticket_price, }); transfer::share_object(game); } public fun buy_ticket( game: &mut Game, coin: Coin, clock: &Clock, referrer: Option, ctx: &mut TxContext ): Ticket { assert!(clock.timestamp_ms() >= game.start_time, EGameNotStarted); assert!(clock.timestamp_ms() (TicketBought { game_id: object::id(game), ticket_number: ticket.ticket_number, buyer: ticket.buyer, referrer: ticket.referrer, }); ticket } public entry fun determine_winner( game: &mut Game, rand: &Random, clock: &Clock, ctx: &mut TxContext ) { assert!(clock.timestamp_ms() >= game.end_time, EGameNotStarted); assert!(game.winner.is_none(), EWinnerAlreadyChosen); assert!(game.total_tickets > 0, ENoTickets); let mut generator = rand.new_generator(ctx); let winning_ticket = generator.generate_u32_in_range(1, game.total_tickets); game.winner = option::some(winning_ticket); emit(WinnerAnnounced { game_id: object::id(game), winner_ticket: winning_ticket, round: game.round, }); } public fun claim_reward( ticket: Ticket, game: Game, ctx: &mut TxContext ): Coin { assert!(object::id(&game) == ticket.game_id, EInvalidPayment); let ticket_num = ticket.ticket_number; assert!(game.winner.contains(&ticket_num), ENotWinner); let amount = game.balance.value(); let reward = game.balance.into_coin(ctx); emit(RewardClaimed { game_id: object::id(&game), ticket_number: ticket.ticket_number, amount, }); object::delete(object::id(&game)); reward } } Wichtige Erkenntnisse: ✅ Balancesorgt für Typsicherheit und den ordnungsgemäßen Umgang mit Münzen ✅ Optionsignalisiert deutlich, ob ein Gewinner ausgewählt wurde ✅ Ereignisse bieten Rückverfolgbarkeit für Frontends und Entdecker 🛠 Sui CLI-Befehle sui client call --package --module nft_lottery_x --function create_game --args --gas-budget 10000000 Folgen Sie ähnlichen CLI-Abläufen, um ein Ticket zu kaufen, den Gewinner zu ermitteln oder eine Prämie in Anspruch zu nehmen. 🔮 Zukünftige Ergänzungen Automatisches Zurücksetzen der Logik für die nächste Runde in claim_reward Sendet mehr Ereignisse aus wie ReferralRewardDistributed Umwandeln von Jackpots und Empfehlungen in Submodule Lass mich wissen, ob du Teil 2 zum Erstellen der Benutzeroberfläche und zur Integration im Sui-Testnet haben möchtest!
- Sui
3
harry phan65
Apr 09, 2025
Artikel
Leitfaden für SUI-Transaktionen: Von der Einrichtung bis zur Ausführung und Überprüfung
Leitfaden für Sui-Transaktionen: Von der Einrichtung bis zur Ausführung und Überprüfung Wenn Sie neugierig auf die Einzelheiten der Ausführung von Transaktionen auf der Sui-Blockchain sind und einen ausführlichen, praktischen Leitfaden wünschen, der Sie durch jeden Schritt führt. In diesem Artikel werden wir den gesamten Prozess untersuchen — von der Einrichtung Ihrer Kundenumgebung über die Überprüfung Ihrer Wallet-Objekte, die Berechnung der Gasgebühren bis hin zur Unterzeichnung und Ausführung einer Transaktion und schließlich der Überprüfung ihrer Details. Lassen Sie uns das Schritt für Schritt aufschlüsseln: Was macht Sui so besonders? 🔥 Sui bietet eine hochoptimierte Plattform für dezentrale Anwendungen (dApps) und intelligente Verträge. Sein elegantes Design bei der Verwaltung von Gasgebühren und Transaktionslogik macht es zu einem aufregenden Spielplatz für Entwickler, die die Grenzen der Web3-Technologie erweitern möchten. Nummer 2. Erste Schritte: Umgebungs-Setup und Wallet-Konfiguration ⚙️ 2.1. Konfiguration Ihrer Sui-Client-Umgebung Bevor Sie mit Transaktionen beginnen, stellen Sie sicher, dass Ihr Sui-Client ordnungsgemäß eingerichtet ist. Sui unterstützt mehrere Netzwerke (devnet, mainnet, testnet), und Sie können mit dem folgenden Befehl überprüfen, welches aktiv ist: ➜ sui client envs ╭─────────┬─────────────────────────────────────┬────────╮ │ alias │ url │ active │ ├─────────┼─────────────────────────────────────┼────────┤ │ devnet │ https://fullnode.devnet.sui.io:443 │ │ │ mainnet │ https://fullnode.mainnet.sui.io:443 │ │ │ testnet │ https://fullnode.testnet.sui.io:443 │ * │ ╰─────────┴─────────────────────────────────────┴────────╯ Dies bestätigt, dass Sie mit dem Testnetz verbunden sind. Im richtigen Netzwerk zu sein, ist der erste Schritt zu einer erfolgreichen Transaktion. 2.2. Überprüfe deine aktive Brieftasche Bestätigen Sie als Nächstes Ihre aktive Wallet-Adresse. Dies ist von entscheidender Bedeutung, da jede Transaktion an Ihre Wallet-Identität gebunden ist: ➜ sui client active-address 0x35370841d2e69b495b1e2f944a3087e4242f314e503691a00b054e0ee2a45a73 2.3. Eigene Objekte abfragen Mithilfe der SUIX_GetOwnedObjects-API können Sie Details zu den Objekten (wie Münzen) abrufen, die Sie in der Blockchain besitzen. Mit diesem Befehl können Sie Ihren Kontostand und die für Transaktionen verfügbaren Vermögenswerte überprüfen: { "jsonrpc": "2.0", "id": 1, "method": "suix_getOwnedObjects", "params": [ "0x35370841d2e69b495b1e2f944a3087e4242f314e503691a00b054e0ee2a45a73", { "filter": { "MatchAll": [ { "StructType": "0x2::coin::Coin" } ] }, "options": { "showType": true, "showOwner": true, "showPreviousTransaction": true } } ] } Dieser Schritt ist wichtig, um zu überprüfen, ob Ihre Brieftasche über die erforderlichen Münzen (in diesem Fall SUI-Münzen) verfügt, bevor Sie Transaktionen versuchen. 3. Gasberechnung: Budgetierung der Transaktionskosten 💸 Gas ist der Treibstoff, der Blockchain-Transaktionen antreibt. Es ist wichtig, sowohl den Gaspreis als auch das Gasbudget zu verstehen, um Transaktionsausfälle zu vermeiden. 3.1. Den Gaspreis abrufen Der aktuelle Gaspreis kann mit dem API-Aufruf SUIX_GetReferenceGasPrice abgerufen werden: { "jsonrpc": "2.0", "id": 1, "method": "suix_getReferenceGasPrice", "params": [] } Wenn die API „1000" zurückgibt, bedeutet das, dass jede Gaseinheit 1000 MIST kostet. Denken Sie daran, dass 1 SUI 10^9 MIST entspricht, sodass sich selbst kleine Zahlen in MIST bei der Budgetierung summieren können. 3.2. Festlegung des Gasbudgets Ihr Gasbudget ist die maximale Gasmenge (in MIST), die Sie bereit sind auszugeben. Nehmen wir für unser Beispiel an, Ihr Gasbudget beträgt 4964000 MIST. Die Gesamtkosten einer Transaktion werden in der Regel wie folgt berechnet: Gesamtkosten = Berechnungskosten plus Speicherkosten — Speicherrabatt Zum Beispiel: • Berechnungskosten: 1.000.000 MIST • Speicherkosten: 2.964.000 MIST • Lagerrabatt: 978.120 MIST Die Nettokosten belaufen sich also auf 1.000.000 + 2.964.000 − 978.120 = 2.985.880 MIST. Durch die genaue Festlegung Ihres Gasbudgets wird sichergestellt, dass Ihre Transaktion über ausreichende Mittel verfügt, um erfolgreich ausgeführt zu werden. 4. Die Transaktion vorbereiten: Ein Probelauf für Selbstvertrauen 🔧 Bevor Sie eine Live-Transaktion senden, sollten Sie am besten einen „Probelauf“ durchführen, um potenzielle Probleme zu erkennen. Auf diese Weise können Sie die Transaktionslogik validieren, ohne Gas zu geben. 4.1. Eine Dry-Run-Transaktion erstellen Hier ist ein Beispiel für eine TypeScript-Funktion, die zeigt, wie eine Probelauf-Transaktion vorbereitet und ausgeführt wird. Dieser Code beschreibt, wie Münzen aufgeteilt und Transferoperationen vorbereitet werden: export const signSuiDryRunTransaction = async (requestParams: SignDryRequestParams): Promise => { const { gasPrice, privateKey, coinRefs, network, recipients } = requestParams; const keypair = Ed25519Keypair.fromSecretKey(privateKey); const tx = newTransaction(); // Configure gas payment, price, and sender tx.setGasPayment(coinRefs); tx.setGasPrice(gasPrice); tx.setSender(keypair.toSuiAddress()); // Split coins based on each recipient's amount const coins = tx.splitCoins(tx.gas, recipients.map((transfer) => transfer.amount)); recipients.forEach((transfer, index) => { tx.transferObjects([coins[index]], transfer.to); }); // Build and sign the transaction with the client const client = newSuiClient({ url: getFullnodeUrl(network) }); const bytes = await tx.build({ client }); const { signature } = await keypair.signTransaction(bytes); await verifyTransactionSignature(bytes, signature, { address: keypair.getPublicKey().toSuiAddress() }); return JSON.stringify([toBase64(bytes), signature]); }; Dieser Probelauf ist entscheidend, um sicherzustellen, dass jedes Detail korrekt ist, bevor Sie echtes Geld einsetzen. 5. Unterzeichnung und Ausführung der Transaktion: Alles zusammenfügen ✍️ Nach einem erfolgreichen Probelauf besteht der nächste Schritt darin, Ihre Transaktion zu signieren und auf der Blockchain zu senden. 5.1. Unterzeichnung der Transaktion Im Folgenden finden Sie eine verfeinerte Beispielfunktion, die die Transaktion mit dem angegebenen Gasbudget signiert: const signSuiTransaction = async (requestParams: SignRequestParams): Promise => { const { gasBudget, gasPrice, privateKey, coinRefs, network, recipients } = requestParams; const keypair = Ed25519Keypair.fromSecretKey(privateKey); const tx = newTransaction(); // Set up gas parameters, including the gas budget tx.setGasPayment(coinRefs); tx.setGasPrice(gasPrice); tx.setGasBudget(gasBudget); tx.setSender(keypair.toSuiAddress()); // Split coins for each recipient const coins = tx.splitCoins(tx.gas, recipients.map((transfer) => transfer.amount)); recipients.forEach((transfer, index) => { tx.transferObjects([coins[index]], transfer.to); }); // Build the transaction and sign it const client = newSuiClient({ url: getFullnodeUrl(network) }); const bytes = await tx.build({ client }); const { signature } = await keypair.signTransaction(bytes); await verifyTransactionSignature(bytes, signature, { address: keypair.getPublicKey().toSuiAddress() }); return JSON.stringify([toBase64(bytes), signature]); }; Diese Funktion integriert alle notwendigen Parameter — einschließlich Gasdetails und Empfänger — und stellt sicher, dass Ihre Transaktion sicher signiert und zur Ausführung bereit ist. 5.2. Ausführung der Transaktion Nach der Unterzeichnung wird die Transaktion mithilfe des API-Endpunkts SUI_ExecuteTransactionBlock an die Blockchain gesendet: curl --location 'https://fullnode.testnet.sui.io:443' \ --header 'Content-Type: application/json' \ --data '{ "jsonrpc": "2.0", "id": 1, "method": "sui_executeTransactionBlock", "params": [ "", [""], { "showInput": true, "showRawInput": true, "showEffects": true, "showEvents": true, "showObjectChanges": true, "showBalanceChanges": true }, "WaitForLocalExecution" ] }' Dieser Aufruf gibt eine detaillierte JSON-Antwort mit Informationen wie Transaktionsübersicht, Gasverbrauch, Objektänderungen und Bilanzaktualisierungen zurück. 6. Überprüfung Ihrer Transaktion: Überprüfen Sie alles 🔍 Nach der Ausführung der Transaktion müssen Sie unbedingt überprüfen, ob alles wie erwartet ausgeführt wurde. 6.1. Überprüfung des Browsers Sie können Ihre Transaktion in einem Blockchain-Explorer wie Suivision Testnet Explorer überprüfen. Der Explorer zeigt alle Transaktionsdetails in einem intuitiven visuellen Format an, sodass Probleme leichter erkannt werden können. 6.2. Überprüfung über die Befehlszeile Für eine detailliertere Prüfung verwenden Sie die Befehlszeile: sui client tx-block -- 3FopuDy5qzKm1kLRFZCdi8Lynadym9j15NaVxzUH6nYD Dieser Befehl bietet eine umfassende Aufschlüsselung der Transaktion, einschließlich Absenderdetails, Gaszahlung, Objektänderungen und Ausführungsstatus. 7. Analyse der JSON-Antwort: Die Ebenen einer Transaktion verstehen Lassen Sie uns die JSON-Antwort entpacken, die Sie nach der Ausführung Ihrer Transaktion erhalten: 7.1. Überblick über die Transaktion jsonrpc & id: Standardfelder für das JSON-RPC-Protokoll. Digest: Der eindeutige Transaktions-Hash (z. B. „3fopuDY5QZKM1KLRFZCDI8LYNADYM9J15NAVXZUH6NYD“), der für das Tracking verwendet wird. TimeStampMS & Checkpoint: Geben Sie den Kontext an, wann die Transaktion ausgeführt wurde, und den Blockchain-Checkpoint zu diesem Zeitpunkt. 7.2. Inhalt der Transaktion Sender- und Gasdaten: Enthält die Adresse des Absenders und alle gasbezogenen Konfigurationen (Zahlung, Preis, Budget). Operationen (Transaktionen): Die Transaktionslogik umfasst Operationen wie: SplitCoins: Zerlegen einer Gasmünze in kleinere Teile. TransferObjects: Verschieben von Münzsegmenten an die angegebenen Empfängeradressen. Signaturen: Kryptografische Signaturen (Base64-kodiert) stellen die Authentizität der Transaktion sicher. 7.3. Auswirkungen auf die Ausführung Status: Der Status „Erfolg“ bestätigt, dass die Transaktion ohne Fehler verarbeitet wurde. Gasverbrauch: Zeigt die Rechen- und Lagerkosten sowie etwaige Rabatte an. Objektänderungen: Beschreibt, welche Objekte als Ergebnis der Transaktion geändert, erstellt oder aktualisiert wurden. Abhängigkeiten: Listet verwandte Transaktions-Hashes auf, von denen diese Transaktion abhängt. Diese granulare Aufschlüsselung ist für das Debuggen und die Verbesserung der Leistung Ihrer DApp unerlässlich. 8. Praktische Einblicke für Entwickler: Tipps und Erkenntnisse Wenn Sie jeden Schritt dieses Prozesses verstehen, erwerben Sie die Fähigkeiten, um sichere, effiziente Web3-Anwendungen auf Sui zu erstellen. Diese Erkenntnisse helfen Ihnen nicht nur bei der Behebung von Problemen, sondern ermöglichen es Ihnen auch, innerhalb des Sui-Ökosystems selbstbewusst Innovationen voranzutreiben.
- Sui
- SDKs and Developer Tools
- Transaction Processing
3
0xduckmove135
Apr 08, 2025
Artikel
👀 SEAL- Ich denke, der Datenschutz bei Web3 wird sich bald ändern
👀 SEAL ist live auf Sui Testnet — ich denke, der Datenschutz bei Web3 wird sich bald ändern Im Web3 hört man häufig Ausdrücke wie* „Die Nutzer besitzen ihre Daten“* oder* „von Natur aus dezentralisiert“*. Aber wenn Sie genau hinschauen, verlassen sich viele Anwendungen immer noch auf zentralisierte Infrastrukturen, um sensible Daten zu verarbeiten — und nutzen Dienste wie AWS oder Google Cloud für die Schlüsselverwaltung. Dies führt zu einem Widerspruch: Dezentralisierung an der Oberfläche, Zentralisierung unter der Oberfläche. Aber was wäre, wenn es eine Möglichkeit gäbe, Geheimnisse sicher zu verwalten, ohne die Dezentralisierung aufzugeben? Wir stellen vor: SEAL — Decentralized Secrets Management (DSM), das jetzt live im Sui Testnet verfügbar ist. SEAL hat sich zum Ziel gesetzt, eine der größten Heucheleien von Web3 zu beheben: die Zurufe nach Dezentralisierung und der heimlichen Nutzung von AWS Du fragst mich vielleicht: Was ist SEAL? SEAL ist ein Protokoll, mit dem Sie sensible Daten sicher unddezentralverwalten können — speziell für die Web3-Welt entwickelt. Stellen Sie sich das als eine Zugriffskontrollschicht vor, bei der der Datenschutz an erster Stelle steht und in Ihre DApp integriert wird. Du kannst dir SEAL als eine Art programmierbares Schloss für deine Daten vorstellen. Sie sperren und entsperren Dinge nicht einfach manuell — Sieschreiben mithilfe von Move on Sui Richtlinien direkt in Ihre Smart Contracts. Nehmen wir an, Sie erstellen eine dApp, bei der: Nur NFT-Inhaber können ein Premium-Tutorial freischalten Oder vielleicht muss ein DAO abstimmen, bevor sensible Dateien aufgedeckt werden Oder Sie möchten, dass Metadaten zeitgebunden sind und erst nach einem bestimmten Datum zugänglich sind SEAL macht all das möglich. Die Zugriffskontrolle erfolgt onchain, vollständig automatisiert, sodass kein Administrator sie verwalten muss. Nur Logik, direkt in die Blockchain integriert. SEAL macht all das möglich. Die Zugriffskontrolle erfolgt onchain, vollständig automatisiert, sodass kein Administrator sie verwalten muss. Nur Logik, direkt in die Blockchain integriert. Ein weiterer interessanter Artikel ist, wie SEAL mitVerschlüsselungumgeht. Es verwendet eine sogenannteSchwellenwertverschlüsselung, was bedeutet: Kein einzelner Knoten kann die Daten entschlüsseln. Es braucht eine Gruppe von Servern, um zusammenzuarbeiten — quasi wie Multi-Sig, nur um Geheimnisse zu entsperren. Das verteilt Vertrauen und vermeidet das übliche Single-Point-of-Failure-Problem. Und um die Dinge wirklich geheim zu halten, verschlüsselt und entschlüsselt SEAL allesauf der Clientseite. Ihre Daten sind für kein Backend sichtbar. Sie bleiben — im wahrsten Sinne des Wortes — in Ihren Händen auf Ihrem Gerät. und SEAL ist es egal, wo Sie Ihre Daten speichern. Ob es sich um IPFS, Arweave, Walrus oder eine andere Plattform handelt, SEAL versucht nicht, diesen Teil zu kontrollieren. Es konzentriert sich nur darauf,wer was sehen darf, nicht darauf, wo Dinge aufbewahrt werden. Also ja, es ist nicht nur eine Bibliothek oder API — es ist eineonchain first, zugriffskontrollierte, standardmäßige Datenschutzebenefür deine dApp. SEAL füllt eine ziemlich kritische Lücke. Lassen Sie uns das etwas genauer aufschlüsseln. Wenn Sie eine dApp erstellen, die sich mitjeder Form vertraulicher Datenbefasst — geschützte Inhalte, Benutzerdokumente, verschlüsselte Nachrichten, sogar zeitgesperrte NFT-Metadaten —, werden Sie auf dasselbe Problem stoßen: ➡️ Wie verwalten Sie den Zugriff sicher, ohne sich auf einen zentralen Dienst verlassen zu müssen? Ohne so etwas wie SEAL können die meisten Teams entweder: Verwenden Sie zentralisierte Tools wie AWS KMS oder Firebase, was eindeutig gegen die Dezentralisierung verstößt Oder versuchen Sie, eine unausgegorene Verschlüsselungslogik selbst zusammenzusetzen, was sich in der Regel als spröde herausstellt und schwer zu überprüfen ist https://x.com/EmanAbio/status/1908240279720841425?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1908240279720841425%7Ctwgr%5E697f93dc65359d0c8c7d64ddede66c0c4adeadf1%7Ctwcon%5Es1_&ref_url=https%3A%2F%2Fwww.notion.so%2Fharryph%2FSEAL-Launches-on-Sui-Testnet-1cc4f8e09bb380969c0dcc627b96cc22 Keines davon skaliert gut. Vor allem nicht, wenn Sie versuchen, vertrauenswürdige Apps über mehrere Ketten oder Communities hinweg zu entwickeln. SEAL macht den gesamten Prozess modular und programmierbar. Sie definieren Ihre Zugriffsregeln in Move Smart Contracts, und SEAL kümmert sich um den Rest — Schlüsselgenerierung, Entschlüsselungsgenehmigungen und Zugriffsdurchsetzung — alles, ohne dass jemand manuell Schlüssel ausstellt oder Backend-Checks durchführt. Und was noch besser ist: Diese Regeln sindüberprüfbar und unveränderlich— sobald sie online sind, folgen sie dem Vertrag, nicht einem menschlichen Administrator. Anstatt also zu fragen, „wer sollte den Zugriff auf diese Daten verwalten?“ du fragst einfach: „Welche Logik sollte den Zugriff definieren?“ > ... und lass die Kette das erledigen. Sauber und skalierbar. Das macht SEAL für mehr als nur „Sicherheitstools“ relevant — es ist eine Basisebene fürjede dApp, die Wert auf Datenschutz, Compliance oder dynamische Zugriffslogik legt. Es ist eine kleine Veränderung — aber sie ändert viel daran, wie wir Daten in Web3 betrachten. Anstatt nach der Bereitstellung zu verschlüsseln oder sich auf externe Dienste zu verlassen,beginnen Sie mit integriertem Datenschutz — und der Zugriff wird vollständig über eine intelligente Vertragslogik abgewickelt. Und genau das braucht Web3 gerade. Wie funktioniert SEAL eigentlich? Wir haben behandelt, was SEAL istundwarum Web3 es braucht**. Schauen wir uns an, wie es tatsächlich unter der Haube aufgebaut ist. In diesem Teil werden die Dinge technischer — aber auf eine gute Art und Weise. Die Architektur ist elegant, wenn man sieht, wie alle Teile zusammenpassen. Auf einer hohen Ebene kombiniert SEALOnchain-Access-LogikmitOff-Chain-Schlüsselmanagement. Dabei wird eine Technik namensIdentity-Based Encryption (IBE) verwendet. Auf diese Weise können Entwickler Daten zu einer Identität verschlüsseln und sich dann auf intelligente Verträge verlassen, um zu definieren, wer sie entschlüsseln dürft. Schritt 1: Zugriffsregeln in Smart Contracts (auf Sui) Alles beginnt mit dem Smart Contract. Wenn Sie SEAL verwenden, definieren Sie in Ihrem Move-Vertrag eine Funktion namens seal_approve — hier schreiben Sie Ihre Bedingungen für die Entschlüsselung. Hier ist zum Beispiel eine einfache Time-Lock-Regel, die in Move geschrieben wurde: entry fun seal_approve(id: vector, c: &clock::Clock) { let mut prepared: BCS = bcs::new(id); let t = prepared.peel_u64(); let leftovers = prepared.into_remainder_bytes(); assert!((leftovers.length() == 0) && (c.timestamp_ms() >= t), ENoAccess); } Einmal eingesetzt, fungiert dieser Vertrag als Gatekeeper. Immer wenn jemand Daten entschlüsseln möchte, wird seine Anfrage anhand dieser Logik überprüft. Wenn es erfolgreich ist, wird der Schlüssel freigegeben. Wenn nicht, sind sie blockiert. Niemand muss eingreifen. ##Schritt 2: Identitätsbasierte Verschlüsselung (IBE) Hier passiert die Magie. Anstatt Daten für eine bestimmte Wallet-Adresse zu verschlüsseln (wie bei PGP oder RSA), verwendet SEALIdentitätszeichenfolgen— das heißt, Sie verschlüsseln mit etwas wie: 0 x Wallet-Adresse dao_voted:proposal_xyz pkgID_2025_05_01 (eine auf Zeitstempeln basierende Regel) oder sogar game_user_nft_holder Wenn die Daten verschlüsselt sind, sieht das so aus: Encrypt(mpk, identity, message) mpk = öffentlicher Hauptschlüssel (allen bekannt) Identität = der durch die Logik definierte Empfänger Nachricht = die tatsächlichen Daten Wenn später jemand entschlüsseln möchte, prüft der Schlüsselserver, ob sie der Richtlinie entsprechen (über den Aufruf seal_approve in der Kette). Wenn es genehmigt wird, gibt es einen abgeleiteten privaten Schlüssel für diese Identität zurück. Derive(msk, identity) → sk Decrypt(sk, encrypted_data) Der Benutzer kann den Inhalt dann lokal entschlüsseln. Die Verschlüsselung erfolgt also, ohne dass man im Voraus wissen muss, wer entschlüsselt. Sie definieren einfach die Bedingungen und SEAL findet den Rest später heraus. Es ist dynamisch. ##Schritt 3: Der Schlüsselserver — Offchain, aber nicht zentralisiert Sie fragen sich vielleicht: Wer besitzt diese Hauptschlüssel? An dieser Stelle kommt derKey Servervon SEAL ins Spiel. Stellen Sie sich das als ein Backend vor, das: Enthält den geheimen Hauptschlüssel (msk) Überwacht On-Chain-Verträge (wie deine seal_approve-Logik) Gibt abgeleitete Schlüssel nur aus, wenn die Bedingungen erfüllt sind Aber — und das ist entscheidend — SEAL ist nicht nur auf einen Schlüsselserver angewiesen. Sie können ihn imSchwellenwertmodusausführen, in dem sich mehrere unabhängige Server einigen müssen, bevor ein Entschlüsselungsschlüssel ausgegeben wird. Beispiel: 3 von 5 Schlüsselservern müssen die Anfrage genehmigen. Dadurch werden zentrale Fehlerquellen vermieden und eine Dezentralisierung auch auf der Schlüsselverwaltungsebene ermöglicht. Und was noch besser ist: SEAL wird in ZukunftMPC (Multi-Party Computation) undEnklave-basierte Setups(wie TEE) unterstützen — so können Sie noch bessere Garantien erhalten, ohne die Benutzerfreundlichkeit zu beeinträchtigen. ##Schritt 4: Clientseitige Entschlüsselung Sobald der Schlüssel an den Benutzer zurückgegeben wurde, erfolgt die eigentliche Entschlüsselungauf seinem Gerät. Das bedeutet: Der Server sieht niemals deine Daten Das Backend speichert niemals entschlüsselte Inhalte Nur der Benutzer kann auf die endgültige Nachricht zugreifen Es ist ein solides Datenschutzmodell. Selbst wenn jemand die Speicherebene (IPFS, Arweave usw.) kompromittiert, kann er die Daten immer noch nicht lesen, ohne die Zugriffslogik zu übergeben. Hier ist das schnelle mentale Modell: Diese Struktur macht es einfach, DApps zu erstellen, bei denen die Zugriffsregeln nicht fest codiert sind — sie sind dynamisch, überprüfbar und vollständig in Ihre Kettenlogik integriert. ##Das Team hinter SEAL SEAL wird vonSamczsungeleitet, einer bekannten Persönlichkeit in der Blockchain-Sicherheitsgemeinschaft. Ehemals Forschungspartner bei Paradigm hat er mehrere Ökosysteme geprüft und vor größeren Exploits bewahrt. Jetzt konzentriert er sich in Vollzeit darauf, SEAL zu einem Kernstück der Datenschutzinfrastruktur von Web3 zu machen. Mit seinem Hintergrund und seiner Glaubwürdigkeit ist SEAL nicht nur ein weiteres experimentelles Tool — es ist ein ernsthafter Versuch, den dezentralen Datenschutz sowohl praktisch als auch skalierbar zu machen. Da SEAL im Sui Testnet live geht, wird ein neuer Standard dafür eingeführt, wie Web3-Anwendungen Geheimnisse verwalten können. Durch die Kombination von On-Chain-Zugriffskontrolle, Schwellenwertverschlüsselung und clientseitigem Datenschutz bietet SEAL eine vertrauenswürdigere Grundlage für die dezentrale Datenverarbeitung. Egal, ob Sie DApps, DAOs oder dezentrale Spiele entwickeln — SEAL bietet ein leistungsstarkes Toolkit, um die Zugriffskontrolle durchzusetzen und Benutzerdaten zu schützen, ohne Kompromisse bei der Dezentralisierung einzugehen. Wenn Web3 voranschreiten soll, ist eine sichere Infrastruktur wie SEAL nicht optional — sie ist unerlässlich
- Sui
- Architecture
- SDKs and Developer Tools
4
Lokie13
Mar 16, 2025
Artikel
Step by step guide to create a Suiet wallet
Step by step guide to create a Suiet wallet: Download suiet extension: https://suiet.app/ After successful installation, click on the Suiet icon in your browser and select "Create New". Set a strong password to protect your wallet. Write down and save your recovery phrase in a safe place. This phrase is needed to recover your wallet if needed Done
- Sui
1
Bahador85
Mar 15, 2025
Artikel
Reise als SUI Move Smart Contract-Entwickler
Im heutigen Artikel möchte ich auf einen Roadmap-Vorschlag für diejenigen eingehen, die den SUI Move-Entwicklungsweg einschlagen möchten. 1. Verstehen Sie die Grundlagen der Blockchain Kernkonzepte:* Machen Sie sich mit wichtigen Blockchain-Konzepten wie Dezentralisierung, Konsensmechanismen, kryptografischen Primitiven und intelligenten Verträgen vertraut. SUI-Blockchain im Überblick:* Erfahren Sie, was SUI einzigartig macht — das objektzentrierte Datenmodell, die Leistungsziele und die Art und Weise, wie das Unternehmen das Zustandsmanagement handhabt. 2. Lerne die Move-Sprache Grundlagen der Sprache:* Beginne mit den Grundlagen der Programmiersprache Move. Konzentrieren Sie sich auf: Ressourcentypen:* Wie Ressourcen funktionieren, um Sicherheit und Eigenverantwortung zu gewährleisten. Module und Strukturen:* So definieren Sie Module und Datenstrukturen. Eingabefunktionen:* Wie Transaktionen über bestimmte Einstiegspunkte ausgeführt werden. Empfohlene Ressourcen: Nutzen Sie offizielle Move-Sprach-Tutorials, Dokumentationen und Beispielcode-Repositorys. 3. Richten Sie Ihre Entwicklungsumgebung ein Tools und CLI:* Installieren Sie die SUI CLI und richten Sie die Move-Toolchain auf Ihrem lokalen Computer ein. Lokale Testumgebung:* Konfigurieren Sie ein lokales SUI-Entwicklungsnetzwerk oder verwenden Sie verfügbare Testnetze. Dies hilft Ihnen, mit der Bereitstellung und dem Testen intelligenter Verträge zu experimentieren, bevor Sie live gehen. IDE und Debugging:* Wählen Sie eine integrierte Entwicklungsumgebung (IDE), die Move unterstützt (z. B. VSCode mit Move-Erweiterungen), und machen Sie sich mit dem Debuggen und Testen Ihrer Verträge vertraut. 4. Erstellen Sie Ihren ersten einfachen Vertrag Praktische Tutorials:* Beginnen Sie mit einem einfachen Projekt wie einem Token-Vertrag. Auf diese Weise können Sie die grundlegenden Move-Konstrukte anwenden. Entdecke SUI-spezifische Muster:* Arbeiten Sie mit dem Objektmodell von SUI und erfahren Sie, wie Transaktionen innerhalb des SUI-Ökosystems verarbeitet werden. Dokumentation und Beispiele:* Nutzen Sie die Entwicklerdokumentation und die Beispielprojekte von SUI, um sich ein Bild von Best Practices zu machen. 5. Tauchen Sie tief in die SUI-spezifischen Funktionen ein Objektzentriertes Modell:* Verstehe, wie SUI Objekte anders behandelt als kontobasierte Blockchains wie Ethereum. Gas- und Transaktionsmodell:* Erfahren Sie, wie Gasgebühren berechnet werden und wie die Transaktionsausführung in SUI verwaltet wird. Staatsverwaltung:* Erfahren Sie mehr über den Ansatz von SUI in Bezug auf Statusspeicher, modulare Updates und Objektlebenszyklusmanagement. 6 Testen, Debuggen und Bereitstellen Einheiten- und Integrationstests:* Schreiben Sie Tests, um die Logik und Sicherheit Ihrer Smart Contracts zu überprüfen. Stellen Sie sicher, dass Sie Randfälle und potenzielle Sicherheitslücken abdecken. Lokaler und Testnet-Einsatz:* Stellen Sie Ihre Verträge in einer kontrollierten Umgebung bereit, um zu sehen, wie sie unter realen Bedingungen funktionieren. Werkzeuge:* Nutzen Sie die Debugging-Tools und Logging-Funktionen von SUI, um Ihren Code zu iterieren und zu verbessern. 7. Bewährte Sicherheitsmethoden und Code-Audits Verstehen Sie die häufigsten Fallstricke:* Untersuchen Sie die häufigsten Sicherheitslücken in intelligenten Verträgen (z. B. Wiedereintritte, unangemessene Zugangskontrollen) und wie das Design von Move diese abschwächt. Code-Bewertungen:* Nehmen Sie an Code-Reviews der Community teil oder arbeiten Sie mit Kollegen zusammen, um Ihren Code zu überprüfen und zu verbessern. Formale Überprüfung:* Erkunden Sie alle verfügbaren Tools zur formalen Überprüfung von Move, um die Richtigkeit Ihrer Verträge mathematisch nachzuweisen. 8 Treten Sie der SUI Developer Community bei Community-Kanäle:* Tauschen Sie sich über Foren, Discord-Kanäle oder Community-Aufrufe mit anderen Entwicklern aus. Der Austausch von Erfahrungen und Herausforderungen ist von unschätzbarem Wert. Open-Source-Beiträge:* Tragen Sie zu Open-Source-Projekten oder Entwickler-Repositorys im Zusammenhang mit SUI und Move bei. Bleiben Sie auf dem Laufenden:* Folgen Sie den Blogs von SUI und Move, GitHub-Repositorys und Social-Media-Kanälen, um über neue Entwicklungen, Updates und bewährte Verfahren auf dem Laufenden zu bleiben. 9. Erkunden Sie Themen für Fortgeschrittene Komplexe Anwendungen:* Wenn Sie sich wohler fühlen, experimentieren Sie mit fortschrittlicheren intelligenten Vertragsdesigns wie Protokollen für dezentrale Finanzen (DeFi), NFTs oder Wallets mit mehreren Signaturen. Interoperabilität und Integration:* Erfahren Sie, wie Sie mit anderen intelligenten Verträgen interagieren und SUI Move-Module in Off-Chain-Systeme integrieren können. Leistung und Skalierbarkeit:* Erkunden Sie Techniken zur Optimierung Ihrer Verträge im Hinblick auf Geschwindigkeit und Kosteneffizienz auf der SUI-Blockchain. 10. Erstellen Sie ein Portfolio und üben Sie weiter Projekte vorstellen:* Entwickeln und dokumentieren Sie eine Reihe von Projekten, die Ihr Verständnis und Ihre Expertise unter Beweis stellen. Kontinuierliches Lernen:* Blockchain und Move entwickeln sich rasant. Machen Sie kontinuierliches Lernen zur Gewohnheit, indem Sie die Dokumentation erneut lesen, an Workshops teilnehmen und an Hackathons teilnehmen. Feedback-Schleife:* Nutzen Sie das Feedback der Community, um Ihre Fähigkeiten zu verfeinern und bei der Entwicklung intelligenter Verträge immer einen Schritt voraus zu sein. Obwohl die oben genannten Punkte Vorschläge sind und nicht die einzige Möglichkeit sind, ein SUI-Entwickler zu werden, hoffe ich, dass sie für euch hilfreich sind. Viel Spaß beim Programmieren. Viel Spaß beim Benutzen!
- Sui
- SDKs and Developer Tools
- Move
2
0xduckmove135
Mar 12, 2025
Artikel
Setting Up a Project to Test the SUI Name Service (SuiNS)
The SUI Name Service (SuiNS) is a decentralized naming system on the SUI blockchain that allows users to map human-readable names (e.g., "0xduck.sui") to blockchain addresses or other data, enhancing usability and accessibility. For developers, testing the SuiNS SDK is an essential step to ensure applications can resolve these names correctly. In this article, we’ll walk you through the process of setting up a project to test the SuiNS SDK, from preparing your development environment to querying a name record like "0xduck.sui" and understanding the results. Introduction to SUI Name Service The SUI Name Service (SuiNS) simplifies blockchain interactions by allowing users to register memorable names instead of using complex cryptographic addresses. For example, instead of sending tokens to "0x1234...abcd", you could send them to "0xduck.sui". Testing the SuiNS SDK ensures that your application can correctly interact with this system, retrieving and interpreting name records as needed. In this project, we’ll set up a Node.js environment, connect to the SUI mainnet, and write a script to query the name record for "0xduck.sui". By the end, you’ll have a working setup to explore SuiNS further. Prerequisites Before starting, ensure you have the following: Node.js (version 14 or higher) and npm (version 6 or higher) installed. Download them from nodejs.org if needed. Basic understanding of JavaScript, particularly asynchronous programming (e.g., async/await). A code editor like Visual Studio Code (VS Code) for writing and running scripts. An internet connection to install packages and connect to the SUI. Setting Up the Development Environment Let’s create a new project directory and initialize it as a Node.js project. This will provide a clean workspace for our test. Step-by-Step Instructions: Open your terminal (e.g., Command Prompt, PowerShell, or a Unix shell). Create a new directory: mkdir suins-test-project cd suins-test-project Initialize a Node.js project: Run this command to create a package.json file with default settings: npm init -y Your project is now set up with a basic structure. Installing Dependencies Run the following in your terminal: npm install @mysten/suins @mysten/sui Verify the Installation: Check that the packages are added to package.json under dependencies. You can also confirm the installed versions by running: npm list @mysten/suins @mysten/sui This should output something like: suins-test-project@1.0.0 ├── @mysten/sui@x.x.x └── @mysten/suins@y.y.y Configuring the SUI Client The SUI client connects your project to the SUI blockchain. For testing, we’ll use the mainnet. Create a Script File: In your project directory, create a file named test-suins.js: touch test-suins.js # On Unix/macOS echo. > test-suins.js # On Windows Open test-suins.js in your editor and add the following: import { getFullnodeUrl, SuiClient } from '@mysten/sui/client'; // Create a SUI client connected to the testnet const suiClient = new SuiClient({ url: getFullnodeUrl('testnet') }); Note: If you encounter an error about ES modules (e.g., "Cannot use import statement outside a module"), add "type": "module" to your package.json: { "name": "suins-test-project", "version": "1.0.0", "type": "module", ... } Testing the Name Service Now, let’s write a script to query the name record for "0xduck.sui" and log the result. import { getFullnodeUrl, SuiClient } from '@mysten/sui/client'; import { SuinsClient } from '@mysten/suins'; // Create a SUI client connected to the testnet // const suiClient = new SuiClient({ url: getFullnodeUrl('mainnet') }); const client = new SuiClient({ url: getFullnodeUrl('mainnet') }); // Create a SuiNS client using the SUI client const suinsClient = new SuinsClient({ client, network: 'mainnet', }); // Function to test the name service async function testNameService() { try { // Query the name record for 'demo.sui' const nameRecord = await suinsClient.getNameRecord('0xduck.sui'); // Log the result console.log('Name Record for "0xduck.sui":', nameRecord); } catch (error) { console.error('Error fetching name record:', error.message); } } testNameService(); In your terminal, execute: node test-suins.js
- SDKs and Developer Tools
3
Bahador85
Mar 11, 2025
Artikel
Suibase, a great tool to experience the SUI
As I was checking some resources for the SUI development, I faced a tool named, suibase. In my exploration on that, I found it very helpful, especially when using localnet which a local explorer will be set up on our local system. I loved it so much. as there is stated in the official website of Suibase: Suibase makes it easy to create "workdirs", each defining a distinct development environment targeting a network. It seems like virtual env in python programming. As far as I found this tool, there are many usefull functionalities which we can take benefit of: Key functionalities of Suibase include: Workdir Management: Suibase enables the creation of isolated workdirs for each network, ensuring that configurations and dependencies are maintained separately. This isolation facilitates organized and efficient development workflows. Suibase Simplified Command-Line Interface:* The tool provides scripts such as lsui, dsui, tsui, and msui, which serve as frontends to the Mysten Labs sui binaries for localnet, devnet, testnet, and mainnet, respectively. These scripts eliminate the need to manually switch environments, as they automatically execute the appropriate sui client and keystore for the targeted network. Localnet Operations:* Suibase offers commands like localnet start, localnet stop, and localnet status to manage the local network. Additionally, the localnet regen command allows developers to reset the network to its initial state, complete with predefined addresses and aliases, which is particularly useful for testing purposes. Faucet Functionality:* The localnet faucet command enables the distribution of Sui coins to specified addresses or all addresses within the localnet, facilitating testing and development activities. Independent Installation:* Suibase operates independently of other Mysten Labs installations and keystores, ensuring that it does not interfere with existing setups. This design allows Suibase to coexist safely with standard installations on the same system. By providing these features, Suibase enhances the development experience on the Sui network, offering a structured and efficient environment for building and testing applications. I recommend testing it!
- Sui
- SDKs and Developer Tools
3
Bahador85
Mar 11, 2025
Artikel
How to fix the SUI installation error?
When I try to install and build the SUI binary on my local system with this command: cargo install --git https://github.com/MystenLabs/sui.git --bin sui --branch devnet I face this error: Please specify a package, e.g. cargo install --git https://github.com/MystenLabs/sui.git anemo-benchmark. After some digging, I found the solution and was able to install and build it error-free and completely using some modification in the above command: For Devnet: cargo install --locked --git https://github.com/MystenLabs/sui.git sui --branch devnet For Testnet: cargo install --locked --git https://github.com/MystenLabs/sui.git sui --branch devnet This way, you can install and build SUI on your local machine and start on your way! Best of luck.
- Sui
- Move
3