@misofm/sdk 0.8.1 → 0.10.0

package/src/contracts/release_snapshot_bundle/deps/ori/walrus_data.ts

@@ -0,0 +1,36 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveEnum, MoveStruct, MoveTuple } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'ori::walrus_data';
+/**
+ * Confidentiality of a stored blob: cleartext, or encrypted with an access policy.
+ * Only applies to standalone blobs — a quilt patch is a slice of a shared quilt
+ * blob and can never be the direct product of an encryption.
+ */
+export const Confidentiality = new MoveEnum({ name: `${$moduleName}::Confidentiality`, fields: {
+        /** The blob is stored in the clear. */
+        Unencrypted: null,
+        /**
+         * The blob is AES-encrypted. `dek` is the AES data-encryption key sealed via Seal
+         * — a small ciphertext stored on-chain, not the blob bytes. The sealed DEK is
+         * itself a Seal `EncryptedObject`, which already carries the decryption-policy
+         * package id, so no separate policy field is stored here. Decryption is gated by
+         * that policy package's `seal_approve`, not by this library.
+         */
+        Encrypted: new MoveStruct({ name: `Confidentiality.Encrypted`, fields: {
+                dek: bcs.vector(bcs.u8())
+            } })
+    } });
+/** Represents either a standalone Walrus blob or a patch within a quilt. */
+export const WalrusData = new MoveEnum({ name: `${$moduleName}::WalrusData`, fields: {
+        /** A standalone Walrus blob. Fields: blob_id, confidentiality. */
+        Blob: new MoveTuple({ name: `WalrusData.Blob`, fields: [bcs.u256(), Confidentiality] }),
+        /**
+         * A patch within a Walrus quilt. Fields: quilt_id, version, start_index,
+         * end_index. Always a plaintext reference into a (possibly separately encrypted)
+         * quilt blob.
+         */
+        QuiltPatch: new MoveTuple({ name: `WalrusData.QuiltPatch`, fields: [bcs.u256(), bcs.u8(), bcs.u16(), bcs.u16()] })
+    } });

package/src/contracts/release_snapshot_bundle/release_snapshot_bundle.ts

@@ -0,0 +1,124 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * The on-chain pointer to a release's snapshot bundle: which Walrus quilt is this
+ * release's bundle.
+ * 
+ * A snapshot bundle is curated bonus material a buyer gets access to — one Walrus
+ * quilt, assembled after the fact. The quilt is self-describing: its plaintext
+ * `manifest.json` patch carries all the metadata, its media patches are
+ * chunk-encrypted under one AES envelope key, and that key travels Seal-wrapped
+ * inside the quilt as its `key.seal` patch. This package therefore stores none of
+ * that — no ciphertext, no metadata, no access policy (unlocking by holding a
+ * Record is `miso_record_acl`'s concern, in miso-record-extensions). The stored
+ * value is the quilt's `WalrusData` blob reference, and nothing else.
+ * 
+ * The slot is write-once: `set_snapshot_bundle` aborts with `EBundleAlreadySet` if
+ * a bundle is already set, and there is NO unset, NO remove, and NO replace
+ * function. That absence is a product guarantee: the bundle a buyer's Record
+ * points at can never be swapped out from under them. More content later means a
+ * new Release.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as walrus_data from './deps/ori/walrus_data.js';
+const $moduleName = '@local-pkg/release_snapshot_bundle::release_snapshot_bundle';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const SnapshotBundleSetEvent = new MoveStruct({ name: `${$moduleName}::SnapshotBundleSetEvent`, fields: {
+        release_id: bcs.Address,
+        bundle: walrus_data.WalrusData
+    } });
+export interface SetSnapshotBundleArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    bundle: TransactionArgument;
+}
+export interface SetSnapshotBundleOptions {
+    package?: string;
+    arguments: SetSnapshotBundleArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        bundle: TransactionArgument
+    ];
+}
+/**
+ * Sets the release's snapshot bundle — once. Aborts with `EBundleAlreadySet` if a
+ * bundle is already set; there is no way to unset or replace it.
+ *
+ * The reference must be a plaintext standalone blob. A quilt patch is a slice of
+ * some other quilt, not the bundle's own quilt blob. And the outer quilt blob is
+ * plaintext by design: its `manifest.json` patch must be readable, encryption is
+ * per-patch inside the quilt, and the Seal-wrapped envelope key travels as the
+ * quilt's `key.seal` patch — so an encrypted outer reference is structurally
+ * wrong. With no replace function either mistake would be permanent, which is why
+ * both checks live on-chain rather than in the client.
+ */
+export function setSnapshotBundle(options: SetSnapshotBundleOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_snapshot_bundle';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "bundle"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_snapshot_bundle',
+        function: 'set_snapshot_bundle',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasSnapshotBundleArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasSnapshotBundleOptions {
+    package?: string;
+    arguments: HasSnapshotBundleArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Returns whether a snapshot bundle is set on this release. */
+export function hasSnapshotBundle(options: HasSnapshotBundleOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_snapshot_bundle';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_snapshot_bundle',
+        function: 'has_snapshot_bundle',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface SnapshotBundleArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface SnapshotBundleOptions {
+    package?: string;
+    arguments: SnapshotBundleArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/**
+ * The release's snapshot bundle reference. Aborts with `ENoSnapshotBundle` if none
+ * is set.
+ */
+export function snapshotBundle(options: SnapshotBundleOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_snapshot_bundle';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_snapshot_bundle',
+        function: 'snapshot_bundle',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/routed_stake/deps/royalty_pool/stake.ts

@@ -0,0 +1,39 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * A position holding share tokens registered against a `RoyaltyPool`.
+ * 
+ * Stakes are owned objects with an immutable balance — to increase a holder's
+ * total staked amount, mint additional Stake objects rather than modify an
+ * existing one. This mirrors Sui's native staking model.
+ * 
+ * Each stake tracks the royalty pools it is currently registered with via an
+ * inline `VecMap<TypeName, Registration>`, keyed by the pool's `Currency`
+ * `TypeName`. The stake cannot be destroyed while any registrations remain. Pool
+ * registrations are mutated by `royalty_pool::pool` through the package-private
+ * accessors below.
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import * as balance from '../sui/balance.js';
+import * as vec_map from '../sui/vec_map.js';
+import * as type_name from '../std/type_name.js';
+const $moduleName = 'royalty_pool::stake';
+export const Registration = new MoveStruct({ name: `${$moduleName}::Registration`, fields: {
+        pool_id: bcs.Address,
+        last_claim_index: bcs.u256()
+    } });
+export const Stake = new MoveStruct({ name: `${$moduleName}::Stake<phantom Share>`, fields: {
+        id: bcs.Address,
+        /** The staked balance. Immutable after creation. */
+        balance: balance.Balance,
+        /**
+         * Active royalty-pool registrations, keyed by `Currency` `TypeName`. Must be empty
+         * to destroy.
+         */
+        registrations: vec_map.VecMap(type_name.TypeName, Registration)
+    } });

package/src/contracts/routed_stake/deps/std/type_name.ts

@@ -0,0 +1,22 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/** Functionality for converting Move types into values. Use with care! */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'std::type_name';
+export const TypeName = new MoveStruct({ name: `${$moduleName}::TypeName`, fields: {
+        /**
+           * String representation of the type. All types are represented using their source
+           * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+           * Struct types are represented as fully qualified type names; e.g.
+           * `00000000000000000000000000000001::string::String` or
+           * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+           * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+           * 32 depending on the Move platform)
+           */
+        name: bcs.string()
+    } });

package/src/contracts/routed_stake/deps/sui/balance.ts

@@ -0,0 +1,17 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * A storable handler for Balances in general. Is used in the `Coin` module to
+ * allow balance operations and can be used to implement custom coins with `Supply`
+ * and `Balance`s.
+ */
+
+import { MoveStruct } from '../../../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '0x2::balance';
+export const Balance = new MoveStruct({ name: `${$moduleName}::Balance<phantom T>`, fields: {
+        value: bcs.u64()
+    } });

package/src/contracts/routed_stake/deps/sui/vec_map.ts

@@ -0,0 +1,33 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`, fields: {
+            key: typeParameters[0],
+            value: typeParameters[1]
+        } });
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`, fields: {
+            contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+        } });
+}