Dans Sui, un contrat intelligent ne peut pas directement posséder ou modifier l'état de son propre objet. Au lieu de cela, le contrat interagit avec les objets via le modèle de propriété, dans lequel les objets sont détenus par des adresses spécifiques (par exemple, le portefeuille ou un compte de l'utilisateur). Les contrats intelligents dans Sui peuvent définir et modifier l'état d'objets appartenant à d'autres parties (par exemple, des utilisateurs), mais ils ne peuvent pas posséder d'objets eux-mêmes.

Concepts clés :

*Propriété de l'objet : les objets appartiennent à des adresses et non à des contrats. *Interaction avec les objets : Un contrat peut manipuler l'état d'un objet, mais uniquement s'il y a accès via la propriété ou des références modifiables.

Exemple de code :

module MyModule {
    use sui::object::{Object, move_to};

    public fun update_object_state(obj: &mut Object) {
        // Modify the state of the object owned by someone else
        obj.some_field = 42;
    }
}

Utilisation de la CLI :

Lors du déploiement, le contrat ne peut manipuler que des objets appartenant à une adresse, pas à elle-même.

Meilleures pratiques :

• Assurez-vous que les contrats respectent le modèle de propriété de Sui, en transmettant des objets entre les contrats et les comptes utilisateurs.
• Gérez toujours les autorisations de manière sécurisée pour éviter tout accès non autorisé à l'état de l'objet.

Un contrat intelligent peut-il posséder et muter son propre état d'objet dans Sui ?

Non, en Sui,les contrats intelligents ne peuvent pas directement posséder ou muter leur propre état. La propriété et la mutation des ressources (comme les pièces de monnaie ou les objets personnalisés) sont régies par les comptes utilisateurs ou les adresses autorisées, et non par le contrat lui-même.

Points clés :

*Propriété : Les contrats intelligents en Sui sont apatrides ; ils définissent la logique mais ne possèdent ni ne stockent l'État eux-mêmes. *Propriété des ressources : Les ressources (comme les pièces ou les objets personnalisés) doivent appartenir à une adresse ou à une entité, et non au contrat.

Débit typique :

1.Propriété du compte : une adresse ou un utilisateur est propriétaire de l'objet (par exemple, une pièce de monnaie). 2.Exécution intelligente des contrats : le contrat peut modifier l'état des objets qui lui sont transmis par le propriétaire.

Exemple de flux :

1.L'utilisateur crée un objet(par exemple, une pièce de monnaie). 2.L'utilisateur transmet l'objetau contrat pour mutation. 3. Le contrat modifie l'objet mais n'en est pas propriétaire.

Exemple de code de déplacement :

public fun mutate_object(owner: &mut Address, coin: &mut Coin) {
    Coin::transfer(coin, &mut owner);
}

Exemple de CLI :

Déployez un contrat et invoquez une fonction pour modifier l'état d'un objet :

sui client publish --gas-budget 10000 --module <module-path>

Erreurs courantes :

*Confusion de propriété : Toute tentative de modification ou d'accès à un état qui n'est pas la propriété du contrat entraînera des erreurs. &mut*Mutabilité incorrecte : assurez-vous que l'objet transmis au contrat est mutable ().

Meilleures pratiques :

*Garantir une propriété appropriée : Assurez-vous que les objets à transmettre au contrat appartiennent à la bonne adresse. *Testez avec Localnet/Testnet : vérifiez toujours la logique du contrat et les changements d'état avant le déploiement sur le réseau principal.

Dans Sui, les contrats intelligents (Move packages)ne peuvent pasposséder ou muter directement des objets eux-mêmes en raison du modèle de propriété centré sur les objets de Sui. Les objets doivent appartenir à uneadresse, à unautre objetou être marqués commepartagé/immuable— les packages ne contiennent que de la logique de code. Pour une mutation autonome, vous utilisez généralement desobjets partagés(avec consensus) ou deschamps dynamiquesoù les objets parents contrôlent les objets enfants. Cela diffère fondamentalement du stockage des contrats d'EVM, qui nécessite des transferts de propriété explicites via des transactions plutôt que des actions contractuelles internes. Les modèles courants impliquentle conditionnement des objetsdans des conteneurs contrôlés par l'administrateur ou l'utilisation d'uneconception basée sur les capacitéspour gérer les mutations d'état en toute sécurité.

Oui, dans Sui, un contrat intelligentpeut modifier son propre état d'objet, maisil ne peut pas posséder d'objets indépendamment. Dans le modèle centré sur les objets de Sui,chaque objet doit appartenir à une adresse, à un autre objet ou être marqué comme partagé. Les contrats intelligents n'ont pas d'adresse comme dans les chaînes EVM (par exemple, Ethereum), vous devez donc vous fier à des modèles de propriété de l'objet tels que lesstructures de données encapsulées dans les objetsou lesobjets partagéspour persister et muter l'état d'une transaction à l'autre.

Pour mettre à jour l'état interne d'un contrat, vous concevez généralement un struct(keycapable) de conserver les données d'état, de les transmettre à votre entryfonction et d'effectuer des mises à jour par le biais de références. La propriété de cette structure appartient à un utilisateur ou est marquée comme partagée pour permettre un accès plus large.

Exemple — Mutation de l'état interne via un objet possédé

module example::counter {
    use sui::object::{Self, UID};
    use sui::tx_context::{Self, TxContext};

    struct Counter has key {
        id: UID,
        value: u64,
    }

    public entry fun create(ctx: &mut TxContext): Counter {
        Counter { id: object::new(ctx), value: 0 }
    }

    public entry fun increment(counter: &mut Counter) {
        counter.value = counter.value + 1;
    }
}

Dans cet exemple, createinitialise un Counterobjet. incrementne peut être appelé qu'en transmettant une référence mutable à cet objet. La propriété appartient à un utilisateur ou à un autre objet, et non au contrat lui-même.

Objets partagés pour un accès global

sharedSi votre contrat nécessite queplusieurs utilisateurs interagissent avec le même objet, marquez-le comme. Exemples de cas d'utilisation : DAO, compteurs mondiaux, jeux en chaîne.

public entry fun increment_shared(counter: &mut Counter) {
    counter.value = counter.value + 1;
}

Lors du déploiement ou via une fonction explicite, vous devez partager l'objet :

sui client call \
  --function share_object \
  --module counter \
  --package <package_id> \
  --args <counter_id>

Conseils CLI :

• Pour voir la propriété : sui client object <object_id>
• Pour muter : utilisez --mutflag ou définissez &mutdans la fonction de saisie
• Pour une mutation partagée : assurez-vous que l'objet est publié comme sharedavant la mutation

Intégration du SDK (TS) :

tx.moveCall({
  target: `${packageId}::counter::increment`,
  arguments: [tx.object(counterId)]
});

Meilleures pratiques :

• Évitez d'essayer de stocker des références d'objets dans d'autres objets, sauf si cela est nécessaire.
• Si vous avez besoin d'une mutabilité globale, lesobjets partagéssont la bonne approche.
• Utilisation UIDet keycapacité à garantir la persistance des objets d'une transaction à l'autre.
• Vérifiez toujours que l'appelant a le droit de muter, en particulier pour les objets partagés.

Erreurs courantes :

• Cannot find mutable reference— Vous transmettez un objet immuable où mutable est obligatoire.
• Object is not shared— Vous essayez de muter un objet qui n'a pas été partagé.
• Type mismatch— Souvent causé par des génériques incorrects ou une mauvaise utilisation de références.

Vous pouvez en savoir plus sur la propriété et les objets partagés dans la documentation destinée aux développeurs de Sui.

Dans le réseau Sui, les contrats intelligents ne peuvent pas « posséder » des objets au sens traditionnel de l'EVM, car la propriété est toujours liée à une adresse ou à un autre objet. Cependant, les contrats intelligents écrits dans Move peuvent définir et modifier leurs propres objets d'état personnalisés. Il s'agit généralement d'objets partagés ou d'objets détenus transmis par les utilisateurs.

Concepts clés

1. Propriété de l'objet à Sui : Chaque objet est la propriété de :

Une adresse utilisateur (adresse),

Un autre objet (propriété imbriquée),

Partagé (accessible à tous),

Immuable (ne peut pas changer après la publication).

2. État du contrat intelligent : Pour créer un état de contrat, les développeurs définissent des structures dans les modules Move et publient des instances de ces structures sous forme d'objets. Ces objets sont ensuite transmis à des fonctions de saisie où leur état peut être lu ou modifié.

3. État de mutation : Pour modifier l'état de l'objet d'un contrat intelligent, vous devez :

Passez l'objet dans la fonction sous la forme &mut.

Assurez-vous qu'il est mutable et possédé/partagé selon les besoins.

Disposez des droits d'accès appropriés.

4. Objets partagés pour Global State : Si vous souhaitez un état global à l'échelle du contrat, vous utilisez des objets partagés :

struct Counter a une clé, un stockage, une copie { valeur : u64, }

incrément de fonds d'entrée publique (compteur : &mut Counter) { valeur de compteur = valeur de compteur + 1 ; }

5. Publication d'objets partagés :

Les objets partagés doivent être créés et partagés de manière explicite lors de l'initialisation.

Utilisez move call ou Sui CLI --gas-budget et --shared-object-inputs pour interagir avec eux.

6. Exemple de flux de déploiement :

Module de déploiement avec Sui Move Publish.

Appelez une fonction de saisie pour créer un objet partagé :

appel client sui 
<PACKAGE_ID>--paquet 
--compteur de modules 
--function create_counter 
--arguments 0 
--budget gazier 10000

Appelez ensuite increment avec l'ID d'objet de l'objet partagé.

7. Limites :

Les contrats intelligents ne stockent pas l'état interne comme dans Solidity.

Ils opèrent sur des objets qui leur sont explicitement transmis.

Il n'existe aucun « stockage des contrats » permanent dans le module.

8. Sécurité et propriété :

Vous devez valider la propriété manuellement ou par le biais de fonctionnalités.

Il est courant d'utiliser des modèles de contrôle d'accès tels que AdminCap ou Whitelist pour détecter les mutations.

9. Meilleures pratiques :

Évitez de partager inutilement des objets afin de limiter la consommation de gaz et les conflits.

Tirez parti des fonctionnalités ou des vérifications d'adresses pour gérer les accès en toute sécurité.

Utilisez la clé has et stockez-la correctement pour permettre la persistance et la mutabilité des objets.

10. Commandes CLI à surveiller :

appel client sui pour les appels de fonction.

objet client sui pour inspecter les données/l'état de l'objet.

test sui move pour la logique d'état des tests unitaires.

Dans Sui, un contrat intelligent écrit dans Move ne peut pas vraiment posséder son propre objet au même titre qu'un contrat EVM autoréférencé pourrait conserver et muter son état interne de manière autonome. L'architecture centrée sur les objets de Sui signifie que tous les objets doivent être explicitement transmis dans le contexte de la transaction et que leur propriété est soit basée sur un compte, soit partagée. Les contrats intelligents eux-mêmes sont apatrides : ils ne font que définir la logique. L'état réel existe dans les objets Move, qui doivent être transmis aux fonctions pour la lecture ou la mutation.

Pour modifier l'objet d'état d'un contrat, vous devez structurer votre module de telle sorte que ses données (généralement stockées dans une has keystructure) soient soit :

*Détenu par une adresse utilisateur(utile pour la logique délimitée au compte), *Partagé via share_object()(pour prendre en charge plusieurs acteurs comme dans DeFi, les DAO, les jeux, etc.).

Lorsque vous utilisez des objets partagés, vous devez marquer vos fonctions avec entryl'objet partagé et le transmettre comme &mutréférence.

Voici un exemple d'état partagé qui peut être muté :

module my_app::vault {
    use sui::object::{UID, ID};
    use sui::tx_context::TxContext;

    struct Vault has key {
        id: UID,
        balance: u64,
    }

    public fun init(ctx: &mut TxContext): Vault {
        Vault { id: object::new(ctx), balance: 0 }
    }

    public entry fun deposit(vault: &mut Vault, amount: u64) {
        vault.balance = vault.balance + amount;
    }
}

Dans cet exemple, Vaultil doit s'agir d'un objet partagé si vous souhaitez qu'il soit accessible par plusieurs utilisateurs via entrydes fonctions. Lors du déploiement, vous partagez l'objet comme suit :

sui client call --function share_object --args <vault_id>

Une fois partagé, n'importe quelle entryfonction peut muter l'objet, à condition qu'elle le reçoive en entrée. Sui garantit la sécurité grâce à des règles de propriété et à la gestion des versions pour éviter les conditions de course.

Pour en savoir plus sur la façon dont les contrats intelligents de Sui interagissent avec l'état de l'objet, l'accès partagé et la propriété, rendez-vous sur : https://docs.sui.io/build/programming-model/object-basics

C'est cette approche qui distingue Sui des chaînes EVM. Vous ne modifiez pas directement le stockage interne des contrats. Au lieu de cela, vous mutez les objets Move transmis explicitement à vos fonctions logiques, ce qui améliore la simultanéité et la vérifiabilité.

Non, un contrat intelligent (module Move) ne peut pas directement posséder ou modifier l'état de son propre objet dans Sui.

Les objets sont des entités de première classe détenues par des adresses, d'autres objets ou partagées,paspar des modules. La mutation d'état se produit via des fonctions qui prennent les objets comme paramètres modifiables, les règles de propriété étant appliquées au niveau de la transaction.

Exemple :

struct Counter has key { id: UID, value: u64 }
public entry fun increment(counter: &mut Counter) { counter.value = counter.value + 1 }

La incrementfonction ne peut muter Counterque lorsque la transaction transmet une référence mutable à un objet appartenant à l'expéditeur. Le module lui-même ne possède aucun état.

Utilisez sharedobjects (transfer::share_object) pour un état persistant et accessible dans le monde entier. Validez toujours la propriété à l'aide object::is_owner()des règles de type linéaire et suivez-les.

Oui, un contrat intelligent Sui (package Move) peut posséder et modifier son propre état via desobjets partagésou deschamps d'objets dynamiques, contrairement à la conception sans état d'EVM.

####Mécanismes clés 1.Objets partagés :

• Modifiable dans le monde entier par n'importe qui (avec des règles).
• Défini key + storeet détenu par 0x0(adresse du colis).

  struct ContractState has key, store {
      id: UID,
      value: u64,
  }

2.Champs d'objets dynamiques :

• Le package peut « posséder » des objets en stockant leurs identifiants.

  fun add_state(ctx: &mut TxContext) {
      let state = ContractState { id: object::new(ctx), value: 42 };
      transfer::share_object(state); // Make it globally mutable
  }

###Pourquoi Sui est unique -Pas de « msg.sender" : le contrôle d'accès se fait via le système de types de Move, pas via EOA. -Mutations parallèles : les objets partagés permettent des écritures simultanées (contrairement aux TX sérialisés d'EVM).

###Exemple de CLI

# Call a function that mutates shared state
sui client call \
    --function update_state \
    --module your_module \
    --package 0xYOUR_PACKAGE \
    --args 0xSHARED_OBJECT_ID 100 \ # New value
    --gas-budget 10000000

###Pièges courants 1.Partage excessif : à éviter share_objectsauf si cela est vraiment nécessaire (utilisation transfer::transferpour une propriété privée). 2. sui::lockConditions de course : Conception pour un accès parallèle (par exemple, utilisation).

Oui, un contrat intelligent dans Sui peut modifier son propre état d'objet, mais il doit le faire via des objets explicitement transmis à ses fonctions. Dans le modèle d'objet de Sui, il n'y a pas de stockage interne des contrats comme dans Ethereum ; au lieu de cela, l'état est maintenu via des objets mutables. Ces objets peuvent appartenir à des utilisateurs ou être partagés sur le réseau. Pour modifier l'état, vous définissez une structure avec la capacité has key, puis vous écrivez des fonctions d'entrée qui acceptent une référence &mut à l'objet. Les objets partagés permettent un accès global et sont nécessaires lorsque plusieurs utilisateurs doivent interagir avec le même état. La mutation d'objets partagés nécessite de marquer la fonction comme entrée publique et de transmettre l'ID d'objet correct lors des appels. Les contrats ne « possèdent » pas directement l'État ; ils fonctionnent plutôt sur les données qui leur sont transmises via des arguments. Vous pouvez appliquer le contrôle d'accès à l'aide de fonctionnalités ou en vérifiant les adresses des expéditeurs. Cette conception permet un parallélisme élevé, une meilleure évolutivité et des autorisations précises. Dans l'ensemble, les contrats intelligents en mode Sui mutent en modifiant les objets définis par Move selon des règles de propriété et d'accès strictes.

Oui, un contrat intelligent Sui (module Move) peut posséder et muter ses propres objets via :

1.Objets possédés— Créés lors de l'initialisation du module (stockés sous l'ID du package). 2.Objets partagés— Marqué sharedpour un accès multi-rédacteurs.

###Principales différences par rapport à l'EVM : ✔Aucun propriétaire externe— Les objets peuvent appartenir au package lui-même. ✔Mutation directe— Aucun système d'approbation n'est nécessaire (contrairement à l'ERC-20).

Exemple de motif :

struct MyState has key { id: UID, value: u64 }  

// Module can mutate its own object  
public fun update(self: &mut MyState) { self.value += 1 }  

Surveillez :

• Coûts de stockage des objets possédés.
• À utiliser sharedpour l'état global.

• (Le modèle objet de Sui permet des contrats autonomes, aucun portefeuille proxy n'est requis. ) *

###1. Concept de base : propriété centrée sur l'objet Contrairement aux variables de stockage d'EVM, les contrats intelligents Sui fonctionnent via desobjets possédésqui peuvent être mutés en fonction de règles de propriété strictes.

####Principales caractéristiques

###2. Move de mise en œuvre

####Contrat d'autosuffisance

module my_contract::state {
    use sui::object::{Self, UID};
    use sui::transfer;
    use sui::tx_context;

    // Contract's state object
    struct ContractState has key, store {
        id: UID,
        counter: u64
    }

    // Initialize and own the state
    public fun init(ctx: &mut tx_context::TxContext) {
        let state = ContractState {
            id: object::new(ctx),
            counter: 0
        };
        transfer::share_object(state); // Make shared for mutability
    }

    // Mutate owned state
    public entry fun increment(state: &mut ContractState) {
        state.counter = state.counter + 1;
    }
}

####Modèles de propriété

###3. Interactions CLI

####Déploiement de contrats avec staté

sui client publish --gas-budget 1000000000
# Output: 
# - Package ID: 0x123...
# - Shared Object ID: 0x456...

####État de mutation

sui client call \
  --package 0x123 \
  --module state \
  --function increment \
  --args 0x456 \  # Shared object ID
  --gas-budget 100000000

###4. Considérations architecturales

####Contrôle de simultanité

// Use `version` field for optimistic concurrency
struct ConcurrentState has key {
    id: UID,
    value: u64,
    version: u64
}

public fun update(
    state: &mut ConcurrentState,
    new_value: u64,
    expected_version: u64
) {
    assert!(state.version == expected_version, EVERSION);
    state.value = new_value;
    state.version = state.version + 1;
}

####Migration d'État (mises à niveau)

module my_contract::v2 {
    use my_contract::state::ContractState;

    // Migrate V1 state to V2
    public entry fun upgrade_state(
        old_state: ContractState,
        ctx: &mut tx_context::TxContext
    ) {
        let new_state = V2State {
            id: object::new(ctx),
            counter: old_state.counter,
            new_field: 0
        };
        transfer::share_object(new_state);
    }
}

###5. Modèles de sécurité

####Accès basé sur les capacités

struct AdminCap has key, store {
    id: UID
}

public entry fun secure_update(
    state: &mut ContractState,
    _cap: &AdminCap
) {
    // Only callable with capability
    state.counter += 1;
}

####Protection contre la réentrée

struct Lock has key {
    id: UID,
    locked: bool
}

public entry fun guarded_update(
    state: &mut ContractState,
    lock: &mut Lock
) {
    assert!(!lock.locked, ELOCKED);
    lock.locked = true;
    state.counter += 1;
    lock.locked = false;
}

###6. Pièges et solutions courants

###7. Optimisation des performances

####Mutations par lots

public entry fun batch_update(
    states: vector<&mut ContractState>,
    delta: u64
) {
    let i = 0;
    while (i < vector::length(&states)) {
        let state = vector::borrow_mut(states, i);
        state.counter = state.counter + delta;
        i = i + 1;
    }
}

####Comparaison des coûts du gaz

###Principaux différenciateurs de l'EVM 1.Propriété explicite : les objets doivent être transférés délibérément 2. key + store``copy + dropMutabilité affinée : par rapport aux capacités 3.Traitement parallèle : les objets indépendants mutent simultanément

Pour une utilisation en production :

• Stockez l'état critique sous la forme d'objets partagés
• Utilisez lescapacitéspour les opérations privilégiées
• Implémentez les chemins demigration d'étatdès le départ