AgentStack
SKILL verified MIT Self-run

Sui Move Object

skill-widnyana-eyay-toolkits-sui-move-object · by widnyana

Sui object model — struct declarations, abilities (key/store/copy/drop), object ownership, naming conventions, and dynamic fields.

No reviews yet
0 installs
11 views
0.0% view→install

Install

$ agentstack add skill-widnyana-eyay-toolkits-sui-move-object

✓ scanned · ✓ verified — works with Claude Code, Cursor, and more.

Security review

✓ Passed

No issues found. Passed automated security review. · v0.1.0 How review works →

  • Prompt-injection patterns
  • Secret / credential exfiltration
  • Dangerous shell & filesystem operations
  • Untrusted network calls
  • Known-malicious package signatures

What it can access

  • Network access No
  • Filesystem access No
  • Shell / process execution No
  • Environment & secrets No
  • Dynamic code execution No

From automated source analysis of v0.1.0. “Used” means the capability is present in the source — more access means more to trust, not that it’s unsafe.

Are you the author of Sui Move Object? Claim this listing to set pricing, connect Stripe payouts, and keep 70% of every sale.
Sign up to claim

About

1. Structs

All structs must be declared public. Ability declarations go after the fields:

// ✅
public struct Pool has key {
    id: UID,
    balance_x: Balance,
    balance_y: Balance,
}

public struct PoolCap has key, store {
    id: UID,
    pool_id: ID,
}

// ❌ Legacy — no public keyword
struct Pool has key {
    id: UID,
}

Object rule: Any struct with the key ability must have id: UID as its first field. Use object::new(ctx) to create UIDs — never reuse or fabricate them.

Naming conventions

Capabilities must be suffixed with Cap:

// ✅
public struct AdminCap has key, store { id: UID }

// ❌ Unclear it's a capability
public struct Admin has key, store { id: UID }

No Potato suffix — a struct's lack of abilities already communicates it's a hot potato:

// ✅
public struct Promise {}

// ❌
public struct PromisePotato {}

Events named in past tense — they describe something that already happened:

// ✅
public struct LiquidityAdded has copy, drop { ... }
public struct FeesCollected has copy, drop { ... }

// ❌
public struct AddLiquidity has copy, drop { ... }
public struct CollectFees has copy, drop { ... }

Dynamic field keys — use positional structs (no named fields):

// ✅
public struct BalanceKey() has copy, drop, store;

// ⚠️ Acceptable but not canonical
public struct BalanceKey has copy, drop, store {}

Constants naming

Error constants use EPascalCase. All other constants use ALL_CAPS:

// ✅
const ENotAuthorized: u64 = 0;
const MAX_FEE_BPS: u64 = 10_000;

// ❌
const NOT_AUTHORIZED: u64 = 0;   // error should be EPascalCase
const MaxFeeBps: u64 = 10_000;   // non-error should be ALL_CAPS

2. Object Abilities Cheat Sheet

| Ability | Meaning in Sui | | ------- | -------------------------------------------------------------------------------------------------------------- | | key | Struct is an on-chain object; requires id: UID as first field | | store | Can be embedded inside other objects; enables public_transfer, public_share_object, public_freeze_object | | copy | Value can be duplicated (not valid on objects with key) | | drop | Value can be silently discarded |

Object ownership model:

// Transfer to an address (owned object)
transfer::transfer(obj, recipient);             // key only — module-restricted
transfer::public_transfer(obj, recipient);      // key + store — usable anywhere

// Share (accessible by anyone, goes through consensus)
transfer::share_object(obj);                    // key only — module-restricted
transfer::public_share_object(obj);             // key + store

// Freeze (immutable forever)
transfer::freeze_object(obj);                   // key only — module-restricted
transfer::public_freeze_object(obj);            // key + store

Only call transfer, share_object, and freeze_object (the non-public_ variants) inside the module that defines that object's type.

Never construct an object struct literal outside of its defining module.


3. Dynamic Fields

Use dynamic fields for extensible storage or when the key set is not known at compile time:

use sui::dynamic_field as df;
use sui::dynamic_object_field as dof;

// Add a dynamic field (value stored inline with parent)
df::add(&mut parent.id, key, value);

// Add a dynamic object field (value is an independent object)
dof::add(&mut parent.id, key, child_obj);

// Access
let val: &MyType = df::borrow(&parent.id, key);
let val: &mut MyType = df::borrow_mut(&mut parent.id, key);

// Remove
let val: MyType = df::remove(&mut parent.id, key);

Routing

| Task | Load | | ------------------------------------------------ | ----------------------- | | Capability pattern, OTW, events | sui-move-patterns | | Coin / Balance types and their abilities | sui-move-stdlib | | Function parameter ordering with objects | sui-move-syntax | | Package config, building, testing | sui-move-setup |

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

Install and usage instructions live in the source repository linked above.

Reviews

No reviews yet — be the first.

Versions

  • v0.1.0 Imported from the upstream source.