@meddleware/docs 0.0.1

package/docs/sealed-storage/api/interfaces/PolicyDescriptor.md

@@ -0,0 +1,49 @@
+# Interface: PolicyDescriptor
+
+Defined in: types.ts:54
+
+UI-facing description of a policy: label + which fields encrypt vs decrypt need.
+
+## Properties
+
+### decryptFields
+
+> **decryptFields**: [`FieldSpec`](FieldSpec.md)[]
+
+Defined in: types.ts:61
+
+Fields required to DECRYPT (feed `buildApprove`), in addition to the stored identity.
+
+***
+
+### encryptFields
+
+> **encryptFields**: [`FieldSpec`](FieldSpec.md)[]
+
+Defined in: types.ts:59
+
+Fields required to ENCRYPT under this policy (feed `buildId`).
+
+***
+
+### help
+
+> **help**: `string`
+
+Defined in: types.ts:57
+
+***
+
+### label
+
+> **label**: `string`
+
+Defined in: types.ts:56
+
+***
+
+### type
+
+> **type**: `string`
+
+Defined in: types.ts:55

package/docs/sealed-storage/api/interfaces/SealControllerConfig.md

@@ -0,0 +1,63 @@
+# Interface: SealControllerConfig
+
+Defined in: controller.ts:17
+
+## Properties
+
+### packageId
+
+> **packageId**: `string`
+
+Defined in: controller.ts:21
+
+Published `seal_policies` package id (feeds encrypt, SessionKey, and the approve PTB).
+
+***
+
+### serverConfigs
+
+> **serverConfigs**: [`KeyServerConfig`](KeyServerConfig.md)[]
+
+Defined in: controller.ts:23
+
+Committee of key servers: encryption targets all; decryption needs `threshold` of them.
+
+***
+
+### sessionTtlMin?
+
+> `optional` **sessionTtlMin?**: `number`
+
+Defined in: controller.ts:27
+
+SessionKey time-to-live in minutes (default 10).
+
+***
+
+### suiClient
+
+> **suiClient**: `SealCompatibleClient`
+
+Defined in: controller.ts:19
+
+A Sui client exposing the core API (e.g. `SuiGrpcClient` from `@mysten/sui/grpc`).
+
+***
+
+### threshold
+
+> **threshold**: `number`
+
+Defined in: controller.ts:25
+
+`t` in t-of-n. With a 3-server committee, 2 tolerates any one server being offline.
+
+***
+
+### verifyKeyServers?
+
+> `optional` **verifyKeyServers?**: `boolean`
+
+Defined in: controller.ts:29
+
+Verify key server object ids on-chain (default false; committee mode is testnet-only).

package/docs/sealed-storage/api/interfaces/SealPolicyProvider.md

@@ -0,0 +1,115 @@
+# Interface: SealPolicyProvider\<P\>
+
+Defined in: types.ts:69
+
+A Seal access policy, mirrored 1:1 with a `seal_policies` Move module. Providers are peers —
+none is privileged. Adding a policy type is a new provider here + a new Move module; existing
+code is untouched.
+
+## Type Parameters
+
+### P
+
+`P` = `Record`\<`string`, `unknown`\>
+
+## Properties
+
+### type
+
+> `readonly` **type**: `string`
+
+Defined in: types.ts:71
+
+Stable machine id, e.g. 'nft-gate' | 'time-lock'.
+
+## Methods
+
+### buildApprove()
+
+> **buildApprove**(`tx`, `packageId`, `idBytes`, `params`): `void`
+
+Defined in: types.ts:84
+
+Append the `seal_approve*` move call (target + the identity as the first arg + policy
+objects) to `tx`. Called at decrypt time to produce the PTB the key servers dry-run.
+
+#### Parameters
+
+##### tx
+
+`Transaction`
+
+##### packageId
+
+`string`
+
+##### idBytes
+
+`Uint8Array`
+
+##### params
+
+`P`
+
+#### Returns
+
+`void`
+
+***
+
+### buildId()
+
+> **buildId**(`params`): `Uint8Array`
+
+Defined in: types.ts:78
+
+Build the Seal identity bytes for a new ciphertext (namespace prefix + a random nonce).
+Called once at encrypt time; the result is persisted in the manifest and reused verbatim
+to decrypt.
+
+#### Parameters
+
+##### params
+
+`P`
+
+#### Returns
+
+`Uint8Array`
+
+***
+
+### describe()
+
+> **describe**(): [`PolicyDescriptor`](PolicyDescriptor.md)
+
+Defined in: types.ts:87
+
+Form/rendering metadata (drives a generic, registry-driven UI).
+
+#### Returns
+
+[`PolicyDescriptor`](PolicyDescriptor.md)
+
+***
+
+### suggest()?
+
+> `optional` **suggest**(`context`): `Promise`\<`Partial`\<`Record`\<`string`, [`FieldSuggestion`](FieldSuggestion.md)[]\>\>\>
+
+Defined in: types.ts:95
+
+Optional: suggest values for form fields by querying chain state (e.g. objects owned by the
+connected wallet). Returns a map of `fieldName → suggestions[]`. Only fields with non-empty
+suggestion arrays need be included. The UI renders a picker for those fields and falls back
+to a plain text input when no suggestions are available or the user opts out.
+
+#### Parameters
+
+##### context
+
+[`SuggestContext`](SuggestContext.md)
+
+#### Returns
+
+`Promise`\<`Partial`\<`Record`\<`string`, [`FieldSuggestion`](FieldSuggestion.md)[]\>\>\>

package/docs/sealed-storage/api/interfaces/SealSuggestClient.md

@@ -0,0 +1,74 @@
+# Interface: SealSuggestClient
+
+Defined in: types.ts:13
+
+Minimal structural subset of a Sui gRPC core client needed by `suggest`.
+Compatible with `SuiGrpcClient.core` from `@mysten/sui/grpc` without importing it directly.
+
+## Properties
+
+### core
+
+> **core**: `object`
+
+Defined in: types.ts:14
+
+#### getObject()
+
+> **getObject**(`options`): `Promise`\<\{ `object`: \{ `json?`: `Record`\<`string`, `unknown`\>; `objectId`: `string`; `type?`: `string`; \}; \}\>
+
+##### Parameters
+
+###### options
+
+###### include?
+
+\{ `json?`: `boolean`; \}
+
+###### include.json?
+
+`boolean`
+
+###### objectId
+
+`string`
+
+##### Returns
+
+`Promise`\<\{ `object`: \{ `json?`: `Record`\<`string`, `unknown`\>; `objectId`: `string`; `type?`: `string`; \}; \}\>
+
+#### listOwnedObjects()
+
+> **listOwnedObjects**(`options`): `Promise`\<\{ `cursor`: `string`; `hasNextPage`: `boolean`; `objects`: `object`[]; \}\>
+
+##### Parameters
+
+###### options
+
+###### cursor?
+
+`string`
+
+###### include?
+
+\{ `json?`: `boolean`; \}
+
+###### include.json?
+
+`boolean`
+
+###### limit?
+
+`number`
+
+###### owner
+
+`string`
+
+###### type?
+
+`string`
+
+##### Returns
+
+`Promise`\<\{ `cursor`: `string`; `hasNextPage`: `boolean`; `objects`: `object`[]; \}\>

package/docs/sealed-storage/api/interfaces/SealedContentInput.md

@@ -0,0 +1,45 @@
+# Interface: SealedContentInput
+
+Defined in: sealed-content.ts:4
+
+Fields needed to publish an on-chain pointer binding sealed content to a gate.
+
+## Properties
+
+### blobId
+
+> **blobId**: `string`
+
+Defined in: sealed-content.ts:8
+
+Walrus blob id of the ciphertext.
+
+***
+
+### gateId
+
+> **gateId**: `string`
+
+Defined in: sealed-content.ts:6
+
+The access gate object id the content is sealed to.
+
+***
+
+### label
+
+> **label**: `string`
+
+Defined in: sealed-content.ts:12
+
+Human-readable label shown in unlock UIs.
+
+***
+
+### sealId
+
+> **sealId**: `string`
+
+Defined in: sealed-content.ts:10
+
+Seal identity (hex) the content was encrypted under.

package/docs/sealed-storage/api/interfaces/SealedContentPointer.md

@@ -0,0 +1,53 @@
+# Interface: SealedContentPointer
+
+Defined in: sealed-content.ts:37
+
+A discovered on-chain pointer to gate-unlockable sealed content.
+
+## Properties
+
+### blobId
+
+> **blobId**: `string`
+
+Defined in: sealed-content.ts:40
+
+***
+
+### contentId
+
+> **contentId**: `string`
+
+Defined in: sealed-content.ts:38
+
+***
+
+### gateId
+
+> **gateId**: `string`
+
+Defined in: sealed-content.ts:39
+
+***
+
+### label
+
+> **label**: `string`
+
+Defined in: sealed-content.ts:42
+
+***
+
+### publisher
+
+> **publisher**: `string`
+
+Defined in: sealed-content.ts:43
+
+***
+
+### sealId
+
+> **sealId**: `string`
+
+Defined in: sealed-content.ts:41

package/docs/sealed-storage/api/interfaces/SealedManifest.md

@@ -0,0 +1,65 @@
+# Interface: SealedManifest
+
+Defined in: types.ts:99
+
+Portable pointer to one sealed blob — the interchange format between encrypt and decrypt.
+
+## Properties
+
+### blobId
+
+> **blobId**: `string`
+
+Defined in: types.ts:105
+
+Storage pointer to the ciphertext (e.g. a Walrus blob id).
+
+***
+
+### id
+
+> **id**: `string`
+
+Defined in: types.ts:103
+
+Seal identity (hex, no 0x) produced by `buildId` — required to decrypt.
+
+***
+
+### label?
+
+> `optional` **label?**: `string`
+
+Defined in: types.ts:111
+
+Optional human label.
+
+***
+
+### network
+
+> **network**: `string`
+
+Defined in: types.ts:107
+
+Network the policy package + key servers live on.
+
+***
+
+### params?
+
+> `optional` **params?**: `Record`\<`string`, `unknown`\>
+
+Defined in: types.ts:109
+
+Non-secret policy params needed to rebuild the approve PTB (e.g. gateId).
+
+***
+
+### policyType
+
+> **policyType**: `string`
+
+Defined in: types.ts:101
+
+Policy `type` used to seal this content.

package/docs/sealed-storage/api/interfaces/SuggestContext.md

@@ -0,0 +1,25 @@
+# Interface: SuggestContext
+
+Defined in: types.ts:34
+
+Context passed to a provider's `suggest` method.
+
+## Properties
+
+### account
+
+> **account**: `string`
+
+Defined in: types.ts:36
+
+The connected wallet address.
+
+***
+
+### client
+
+> **client**: [`SealSuggestClient`](SealSuggestClient.md)
+
+Defined in: types.ts:38
+
+Sui gRPC client (structural — any compatible client is accepted).

package/docs/sealed-storage/api/interfaces/TimeLockParams.md

@@ -0,0 +1,13 @@
+# Interface: TimeLockParams
+
+Defined in: providers/timelock.ts:4
+
+## Properties
+
+### unlockMs?
+
+> `optional` **unlockMs?**: `number`
+
+Defined in: providers/timelock.ts:6
+
+Unlock time in epoch milliseconds. Needed to encrypt; not needed to decrypt.

package/docs/sealed-storage/api/type-aliases/SignPersonalMessage.md

@@ -0,0 +1,17 @@
+# Type Alias: SignPersonalMessage
+
+> **SignPersonalMessage** = (`message`) => `Promise`\<\{ `signature`: `string`; \}\>
+
+Defined in: controller.ts:33
+
+Wallet hook: sign a personal message, returning the signature (base64).
+
+## Parameters
+
+### message
+
+`Uint8Array`
+
+## Returns
+
+`Promise`\<\{ `signature`: `string`; \}\>

package/docs/sealed-storage/api/typedoc-sidebar.json

@@ -0,0 +1 @@
+[{"text":"Classes","collapsed":true,"items":[{"text":"PolicyRegistry","link":"/docs/sealed-storage/api/classes/PolicyRegistry.md"},{"text":"SealController","link":"/docs/sealed-storage/api/classes/SealController.md"}]},{"text":"Interfaces","collapsed":true,"items":[{"text":"EncryptResult","link":"/docs/sealed-storage/api/interfaces/EncryptResult.md"},{"text":"FieldSpec","link":"/docs/sealed-storage/api/interfaces/FieldSpec.md"},{"text":"FieldSuggestion","link":"/docs/sealed-storage/api/interfaces/FieldSuggestion.md"},{"text":"KeyServerConfig","link":"/docs/sealed-storage/api/interfaces/KeyServerConfig.md"},{"text":"NftGateParams","link":"/docs/sealed-storage/api/interfaces/NftGateParams.md"},{"text":"PolicyDescriptor","link":"/docs/sealed-storage/api/interfaces/PolicyDescriptor.md"},{"text":"SealControllerConfig","link":"/docs/sealed-storage/api/interfaces/SealControllerConfig.md"},{"text":"SealedContentInput","link":"/docs/sealed-storage/api/interfaces/SealedContentInput.md"},{"text":"SealedContentPointer","link":"/docs/sealed-storage/api/interfaces/SealedContentPointer.md"},{"text":"SealedManifest","link":"/docs/sealed-storage/api/interfaces/SealedManifest.md"},{"text":"SealPolicyProvider","link":"/docs/sealed-storage/api/interfaces/SealPolicyProvider.md"},{"text":"SealSuggestClient","link":"/docs/sealed-storage/api/interfaces/SealSuggestClient.md"},{"text":"SuggestContext","link":"/docs/sealed-storage/api/interfaces/SuggestContext.md"},{"text":"TimeLockParams","link":"/docs/sealed-storage/api/interfaces/TimeLockParams.md"}]},{"text":"Type Aliases","collapsed":true,"items":[{"text":"SignPersonalMessage","link":"/docs/sealed-storage/api/type-aliases/SignPersonalMessage.md"}]},{"text":"Variables","collapsed":true,"items":[{"text":"nftGateProvider","link":"/docs/sealed-storage/api/variables/nftGateProvider.md"},{"text":"timeLockProvider","link":"/docs/sealed-storage/api/variables/timeLockProvider.md"}]},{"text":"Functions","collapsed":true,"items":[{"text":"buildPublishSealedContentTx","link":"/docs/sealed-storage/api/functions/buildPublishSealedContentTx.md"},{"text":"bytesToHex","link":"/docs/sealed-storage/api/functions/bytesToHex.md"},{"text":"concatBytes","link":"/docs/sealed-storage/api/functions/concatBytes.md"},{"text":"createDefaultRegistry","link":"/docs/sealed-storage/api/functions/createDefaultRegistry.md"},{"text":"createNftGateProvider","link":"/docs/sealed-storage/api/functions/createNftGateProvider.md"},{"text":"hexToBytes","link":"/docs/sealed-storage/api/functions/hexToBytes.md"},{"text":"objectIdBytes","link":"/docs/sealed-storage/api/functions/objectIdBytes.md"},{"text":"randomBytes","link":"/docs/sealed-storage/api/functions/randomBytes.md"},{"text":"sealedContentEventType","link":"/docs/sealed-storage/api/functions/sealedContentEventType.md"},{"text":"u64beBytes","link":"/docs/sealed-storage/api/functions/u64beBytes.md"}]}]

package/docs/sealed-storage/api/variables/nftGateProvider.md

@@ -0,0 +1,9 @@
+# ~~Variable: nftGateProvider~~
+
+> `const` **nftGateProvider**: [`SealPolicyProvider`](../interfaces/SealPolicyProvider.md)\<[`NftGateParams`](../interfaces/NftGateParams.md)\>
+
+Defined in: providers/nft-gate.ts:110
+
+## Deprecated
+
+Use `createNftGateProvider(packageId)` — this zero-package-id fallback has no suggest capability.

package/docs/sealed-storage/api/variables/timeLockProvider.md

@@ -0,0 +1,9 @@
+# Variable: timeLockProvider
+
+> `const` **timeLockProvider**: [`SealPolicyProvider`](../interfaces/SealPolicyProvider.md)\<[`TimeLockParams`](../interfaces/TimeLockParams.md)\>
+
+Defined in: providers/timelock.ts:19
+
+Time-lock encryption: decryptable by anyone once the on-chain Clock passes the unlock time.
+Mirrors `seal_policies::timelock`. Identity layout: `[8-byte BE unlock_ms][8-byte nonce]`.
+Deliberately shares nothing with `nft-gate` — different fields, different args.

package/docs/sealed-storage/index.md

@@ -0,0 +1,68 @@
+# Sealed Storage
+
+Encrypt a file in your browser, store the ciphertext on [Walrus](/walrus-storage/), and let only the
+right people decrypt it — with the access rule enforced **on-chain**. Open the app at
+[sui-seal.meddleware.co.uk](https://sui-seal.meddleware.co.uk).
+
+## What it is
+
+Sealed Storage combines three things:
+
+- **[Seal](https://seal-docs.wal.app/)** — threshold encryption where the decryption keys are held by
+  a committee of independent **key servers**, not by any single party (or by Meddleware).
+- **[Walrus](/walrus-storage/)** — decentralised storage for the encrypted bytes.
+- A **policy** — an on-chain rule that decides who is allowed to decrypt.
+
+You encrypt under a policy, share a small **manifest** (a pointer), and anyone who satisfies the
+policy can decrypt. Nobody else can — even though the ciphertext itself is stored publicly.
+
+## When to use it
+
+- You want to store something **private** on public/decentralised storage.
+- You want access tied to an **on-chain condition** — for example, "only holders of this
+  [Access Gate](/access-gate/) pass" or "only after a certain time".
+- You want to **share** encrypted content without running your own key server or handing anyone a raw
+  key.
+
+When plain [Walrus Storage](/walrus-storage/) is enough: if the content isn't sensitive, skip
+encryption.
+
+## How it works, in three steps
+
+1. **Encrypt** — the file is encrypted in your browser under the policy you choose. No key material
+   ever touches a server.
+2. **Store** — the opaque ciphertext is uploaded to Walrus; you keep the returned blob ID in the
+   manifest.
+3. **Decrypt** — you sign **one** wallet message (which mints a short-lived session key); a threshold
+   of the key servers releases key shares **only if** the on-chain policy check passes.
+
+```
+ encrypt (browser)         store            decrypt (if policy allows)
+   file → ciphertext  →  Walrus blob  →  sign once → committee releases shares → file
+             ▲
+        policy: who may decrypt (NFT pass / time-lock / …)
+```
+
+## The manifest
+
+Sealing produces a small **manifest** — the portable pointer you share or save. It records the policy
+type, the encryption **identity**, the Walrus blob ID, the network, and any non-secret parameters
+(like which gate). It contains **no secrets**; it's just enough to locate the ciphertext and rebuild
+the on-chain access check. See [Reference](/sealed-storage/reference).
+
+## Who holds the keys?
+
+No one you have to trust unilaterally. Decryption keys are split across a **committee** of independent
+key servers; a configurable **threshold** (e.g. 2 of 3) must agree. Meddleware never holds your keys,
+and the app never sends key material to a server.
+
+::: tip Network availability
+Committee mode currently runs on **testnet**. Mainnet is enabled purely by configuration once the
+committee is available — the app shows a clear notice until then.
+:::
+
+## Next
+
+- **[Using it](/sealed-storage/using)** — encrypt, share, and decrypt step by step.
+- **[Policies](/sealed-storage/policies)** — the access rules you can choose, and when to use each.
+- **[Reference](/sealed-storage/reference)** — manifest shape and the SDK API.

package/docs/sealed-storage/policies.md

@@ -0,0 +1,52 @@
+# Sealed Storage — policies
+
+A **policy** is the on-chain rule that decides who may decrypt sealed content. You choose one when you
+encrypt. Each policy is a self-contained on-chain module with a matching option in the app.
+
+## Built-in policies
+
+### Access-gate NFT (`nft-gate`)
+
+**Only holders of a valid pass for a chosen [Access Gate](/access-gate/) can decrypt.**
+
+- **Encrypt with:** the gate's object ID.
+- **Decrypt with:** the pass NFT you hold for that gate (and whether it's soulbound).
+- **Use it when:** you want membership- or purchase-gated content — a paid community, subscriber-only
+  files, gated downloads. Combine it with the Access Gate tool to sell the passes.
+
+Content is namespaced to the specific gate, so a pass for one gate can never decrypt another gate's
+content. A single-use pass acts as **membership** here — decrypting doesn't consume a use — but an
+already-exhausted pass is rejected.
+
+### Time-lock (`time-lock`)
+
+**Anyone can decrypt once a chosen unlock time has passed.**
+
+- **Encrypt with:** an unlock time.
+- **Decrypt with:** nothing special — just wait until the time arrives.
+- **Use it when:** you want a timed reveal — embargoed announcements, scheduled disclosures, "open
+  after" content, commit-and-reveal schemes.
+
+The unlock time is checked against the on-chain clock, so it can't be faked by changing your device
+clock.
+
+## Choosing a policy
+
+| You want… | Use |
+| --- | --- |
+| Access limited to holders of a pass you sell or grant | **Access-gate NFT** |
+| A timed reveal open to everyone after a date | **Time-lock** |
+| Both (e.g. gated *and* not before a date) | Not a single built-in today — see roadmap |
+
+## Roadmap
+
+The policy system is **extensible** — each new policy is an additional on-chain module plus an app
+option, without touching existing ones. Planned policies (not yet available) include allowlists,
+time-bound subscriptions, owner-only, token/balance gating, and more. These will appear in the app's
+policy picker automatically as they ship.
+
+::: tip Developer note
+The mechanics of writing a new policy (the on-chain `seal_approve` module + the matching client
+provider) are `dev.meddleware.co.uk` material, planned in the `seal-policies` and `seal-client`
+package docs. The [Reference](/sealed-storage/reference) lists the current policy identifiers.
+:::