@meddleware/nft-gate-client 0.0.5 → 0.0.7

package/dist/index.d.ts

@@ -4,7 +4,7 @@
  * Client-side only: ownership queries, purchase/consume PTB builders, challenge signing,
  * and access-proof assembly. Server-side verification lives in the Rust gateway.
  */
-export type { AccessGateConfig, GateAdminContext, OwnedGate, Challenge, AccessProof, OwnedAccessNft, OwnedObjectsClient, SuiObjectClient, } from './types.js';
+export type { AccessGateConfig, CoreObject, GateAdminContext, OwnedGate, Challenge, AccessProof, OwnedAccessNft, OwnedObjectsClient, SuiObjectClient, } from './types.js';
 export { fetchAccessNfts, ownsAccessNft, parseOwnedAccessNft, fetchAccessNftById, parseAdminCap, parseGate, fetchAdminCaps, fetchGate, fetchOwnedGates, } from './ownership.js';
 export { buildPurchaseTx, buildConsumeTx, buildCreateGateTx, buildSetPriceTx, buildSetPaymentRecipientTx, buildSetPausedTx, buildSetDefaultUsesTx, buildSetSoulboundTx, buildSetAutoBurnAtZeroTx, buildSetNftNameTx, buildSetNftImageUrlTx, buildSetNftDescriptionTx, buildAirdropTx, buildMakeGateImmutableTx, } from './ptb.js';
 export { fetchChallenge } from './challenge.js';

package/dist/ownership.d.ts

@@ -1,8 +1,8 @@
 import type { OwnedAccessNft, OwnedGate, OwnedObjectsClient, SuiObjectClient } from './types.js';
 /**
- * Parse a single `getOwnedObjects`/`getObject` entry into an {@link OwnedAccessNft}, or `null`
- * if it is not an access NFT. Validates the object **type** when present (typed), and reads the
- * nested `data.fields` deterministically.
+ * Parse a single core-API object (a `listOwnedObjects` item or a `getObject`'s `{ object }`) into
+ * an {@link OwnedAccessNft}, or `null` if it is not an access NFT. Validates the object **type**
+ * when present (typed), and reads the nested `data` fields deterministically.
  */
 export declare function parseOwnedAccessNft(entry: any): OwnedAccessNft | null;
 /**

package/dist/types.d.ts

@@ -89,32 +89,44 @@ export interface OwnedAccessNft {
     /** `null` for an unlimited pass; otherwise remaining single-use count. */
     usesRemaining: number | null;
 }
-/** Minimal structural subset of a Sui client used for ownership queries (grpc or json-rpc). */
+/**
+ * A single owned/read object as returned by the unified core API (`SuiGrpcClient`): the id and
+ * Move struct type are top-level; the struct fields come back under `json` (opt-in). Kept as a
+ * structural subset so any client exposing the core API satisfies it without importing the SDK.
+ */
+export interface CoreObject {
+    objectId: string;
+    type?: string;
+    json?: Record<string, unknown> | null;
+}
+/** Minimal structural subset of a core Sui client used for owned-object listing (`SuiGrpcClient`). */
 export interface OwnedObjectsClient {
-    getOwnedObjects(params: {
-        owner: string;
-        filter?: {
-            StructType: string;
-        };
-        options?: {
-            showContent?: boolean;
-            showType?: boolean;
-        };
-        cursor?: string | null;
-        limit?: number | null;
-    }): Promise<{
-        data: unknown[];
-        hasNextPage?: boolean;
-        nextCursor?: string | null;
-    }>;
+    core: {
+        listOwnedObjects(options: {
+            owner: string;
+            type?: string;
+            cursor?: string | null;
+            limit?: number;
+            include?: {
+                json?: boolean;
+            };
+        }): Promise<{
+            objects: CoreObject[];
+            hasNextPage: boolean;
+            cursor: string | null;
+        }>;
+    };
 }
-/** Minimal structural subset of a Sui client used for a typed single-object read. */
+/** Minimal structural subset of a core Sui client used for a typed single-object read. */
 export interface SuiObjectClient {
-    getObject(params: {
-        id: string;
-        options?: {
-            showContent?: boolean;
-            showType?: boolean;
-        };
-    }): Promise<unknown>;
+    core: {
+        getObject(options: {
+            objectId: string;
+            include?: {
+                json?: boolean;
+            };
+        }): Promise<{
+            object: CoreObject;
+        }>;
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meddleware/nft-gate-client",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "type": "module",
   "description": "Client-side helpers for the access_gate NFT access primitive: ownership queries, purchase/consume PTB builders, challenge signing, and access-proof assembly.",
   "author": "MeddleWare <meddleware@proton.me>",
@@ -28,14 +28,15 @@
     }
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "prepublishOnly": "npm run build",
     "type-check": "tsc --noEmit",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "test:integration": "vitest run --config vitest.integration.config.ts"
   },
   "dependencies": {
-    "@mysten/sui": "~2.17.0"
+    "@mysten/sui": "^2.28.0"
   },
   "devDependencies": {
     "@types/node": "~24.12.2",

package/src/index.ts

@@ -7,6 +7,7 @@
 
 export type {
   AccessGateConfig,
+  CoreObject,
   GateAdminContext,
   OwnedGate,
   Challenge,

package/src/ownership.ts

@@ -1,7 +1,19 @@
-import type { OwnedAccessNft, OwnedGate, OwnedObjectsClient, SuiObjectClient } from './types.js'
+import type { CoreObject, OwnedAccessNft, OwnedGate, OwnedObjectsClient, SuiObjectClient } from './types.js'
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+/**
+ * Unwrap a Move-struct field bag from a core `json` value. The gRPC/core API returns struct
+ * fields flat; the old JSON-RPC shape nested them under `.fields`. Tolerate both so parsing is
+ * robust to the transport and to the SDK's documented caveat that the `json` shape may vary.
+ */
+function structFields(v: unknown): Record<string, any> | undefined {
+  if (!v || typeof v !== 'object') return undefined
+  const o = v as Record<string, any>
+  const nested = o.fields
+  return nested && typeof nested === 'object' ? (nested as Record<string, any>) : o
+}
+
 /**
  * Extract `uses_remaining` from a Move enum `AccessVariant` as rendered by RPC, driven by the
  * enum **variant tag** (typed) rather than guessing from field presence. Sui renders a Move
@@ -25,18 +37,18 @@ function isAccessNftType(type: unknown): boolean {
 }
 
 /**
- * Parse a single `getOwnedObjects`/`getObject` entry into an {@link OwnedAccessNft}, or `null`
- * if it is not an access NFT. Validates the object **type** when present (typed), and reads the
- * nested `data.fields` deterministically.
+ * Parse a single core-API object (a `listOwnedObjects` item or a `getObject`'s `{ object }`) into
+ * an {@link OwnedAccessNft}, or `null` if it is not an access NFT. Validates the object **type**
+ * when present (typed), and reads the nested `data` fields deterministically.
  */
 export function parseOwnedAccessNft(entry: any): OwnedAccessNft | null {
-  const obj = entry?.data ?? entry
-  const objectId: string | undefined = obj?.objectId ?? obj?.content?.fields?.id?.id
-  const type: unknown = obj?.type ?? obj?.content?.type
+  const obj: CoreObject | undefined = entry?.object ?? entry
+  const objectId: string | undefined = obj?.objectId
+  const type: unknown = obj?.type
   // When the type is present it MUST be an access NFT; when absent (some node shapes) fall back
   // to structural checks below.
   if (type !== undefined && !isAccessNftType(type)) return null
-  const inner = obj?.content?.fields?.data?.fields
+  const inner = structFields(structFields(obj?.json)?.data)
   const gateId: string | undefined = inner?.gate_id ?? inner?.gateId
   if (!objectId || !gateId) return null
   return {
@@ -57,10 +69,7 @@ export async function fetchAccessNftById(
   client: SuiObjectClient,
   objectId: string,
 ): Promise<OwnedAccessNft | null> {
-  const res = await client.getObject({
-    id: objectId,
-    options: { showType: true, showContent: true },
-  })
+  const res = await client.core.getObject({ objectId, include: { json: true } })
   return parseOwnedAccessNft(res)
 }
 
@@ -76,12 +85,12 @@ export async function fetchAccessNfts(
   nftType: string,
   gateId?: string,
 ): Promise<OwnedAccessNft[]> {
-  const { data } = await client.getOwnedObjects({
+  const { objects } = await client.core.listOwnedObjects({
     owner,
-    filter: { StructType: nftType },
-    options: { showContent: true, showType: true },
+    type: nftType,
+    include: { json: true },
   })
-  const parsed = (data ?? [])
+  const parsed = (objects ?? [])
     .map(parseOwnedAccessNft)
     .filter((n): n is OwnedAccessNft => n !== null)
   return gateId ? parsed.filter((n) => n.gateId === gateId) : parsed
@@ -118,11 +127,12 @@ function isAdminCapType(type: unknown): boolean {
  * it is not an `AdminCap`. Validates the object **type** when present and reads `fields.gate_id`.
  */
 export function parseAdminCap(entry: any): { adminCapId: string; gateId: string } | null {
-  const obj = entry?.data ?? entry
-  const adminCapId: string | undefined = obj?.objectId ?? obj?.content?.fields?.id?.id
-  const type: unknown = obj?.type ?? obj?.content?.type
+  const obj: CoreObject | undefined = entry?.object ?? entry
+  const adminCapId: string | undefined = obj?.objectId
+  const type: unknown = obj?.type
   if (type !== undefined && !isAdminCapType(type)) return null
-  const gateId: string | undefined = obj?.content?.fields?.gate_id ?? obj?.content?.fields?.gateId
+  const f = structFields(obj?.json)
+  const gateId: string | undefined = f?.gate_id ?? f?.gateId
   if (!adminCapId || !gateId) return null
   return { adminCapId, gateId }
 }
@@ -133,9 +143,9 @@ export function parseAdminCap(entry: any): { adminCapId: string; gateId: string
  * expected `Gate` fields.
  */
 export function parseGate(entry: any): Omit<OwnedGate, 'adminCapId'> | null {
-  const obj = entry?.data ?? entry
-  const gateId: string | undefined = obj?.objectId ?? obj?.content?.fields?.id?.id
-  const f = obj?.content?.fields
+  const obj: CoreObject | undefined = entry?.object ?? entry
+  const gateId: string | undefined = obj?.objectId
+  const f = structFields(obj?.json)
   if (!gateId || !f) return null
   return {
     gateId,
@@ -163,12 +173,12 @@ export async function fetchAdminCaps(
   owner: string,
   packageId: string,
 ): Promise<{ adminCapId: string; gateId: string }[]> {
-  const { data } = await client.getOwnedObjects({
+  const { objects } = await client.core.listOwnedObjects({
     owner,
-    filter: { StructType: `${packageId}::access_gate::AdminCap` },
-    options: { showContent: true, showType: true },
+    type: `${packageId}::access_gate::AdminCap`,
+    include: { json: true },
   })
-  return (data ?? [])
+  return (objects ?? [])
     .map(parseAdminCap)
     .filter((c): c is { adminCapId: string; gateId: string } => c !== null)
 }
@@ -183,7 +193,7 @@ export async function fetchGate(
   client: SuiObjectClient,
   gateId: string,
 ): Promise<Omit<OwnedGate, 'adminCapId'> | null> {
-  const res = await client.getObject({ id: gateId, options: { showType: true, showContent: true } })
+  const res = await client.core.getObject({ objectId: gateId, include: { json: true } })
   return parseGate(res)
 }
 

package/src/types.ts

@@ -96,21 +96,33 @@ export interface OwnedAccessNft {
   usesRemaining: number | null
 }
 
-/** Minimal structural subset of a Sui client used for ownership queries (grpc or json-rpc). */
+/**
+ * A single owned/read object as returned by the unified core API (`SuiGrpcClient`): the id and
+ * Move struct type are top-level; the struct fields come back under `json` (opt-in). Kept as a
+ * structural subset so any client exposing the core API satisfies it without importing the SDK.
+ */
+export interface CoreObject {
+  objectId: string
+  type?: string
+  json?: Record<string, unknown> | null
+}
+
+/** Minimal structural subset of a core Sui client used for owned-object listing (`SuiGrpcClient`). */
 export interface OwnedObjectsClient {
-  getOwnedObjects(params: {
-    owner: string
-    filter?: { StructType: string }
-    options?: { showContent?: boolean; showType?: boolean }
-    cursor?: string | null
-    limit?: number | null
-  }): Promise<{ data: unknown[]; hasNextPage?: boolean; nextCursor?: string | null }>
+  core: {
+    listOwnedObjects(options: {
+      owner: string
+      type?: string
+      cursor?: string | null
+      limit?: number
+      include?: { json?: boolean }
+    }): Promise<{ objects: CoreObject[]; hasNextPage: boolean; cursor: string | null }>
+  }
 }
 
-/** Minimal structural subset of a Sui client used for a typed single-object read. */
+/** Minimal structural subset of a core Sui client used for a typed single-object read. */
 export interface SuiObjectClient {
-  getObject(params: {
-    id: string
-    options?: { showContent?: boolean; showType?: boolean }
-  }): Promise<unknown>
+  core: {
+    getObject(options: { objectId: string; include?: { json?: boolean } }): Promise<{ object: CoreObject }>
+  }
 }

package/dist/src/challenge.d.ts

@@ -1,11 +0,0 @@
-import type { Challenge } from './types.js';
-/**
- * Fetch a fresh challenge from a gateway's `GET /v1/challenge` endpoint. Tolerates both
- * `expiresAt` (camelCase) and `expires_at` (snake_case) response shapes.
- *
- * @throws {Error} if the network request fails or the gateway returns a non-2xx status.
- * @throws {Error} if the response body is missing the required `nonce` field.
- */
-export declare function fetchChallenge(gatewayHost: string, opts?: {
-    signal?: AbortSignal;
-}): Promise<Challenge>;

package/dist/src/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * `@meddleware/nft-gate-client` — client-side helpers for the `access_gate` primitive.
- *
- * Client-side only: ownership queries, purchase/consume PTB builders, challenge signing,
- * and access-proof assembly. Server-side verification lives in the Rust gateway.
- */
-export type { AccessGateConfig, GateAdminContext, OwnedGate, Challenge, AccessProof, OwnedAccessNft, OwnedObjectsClient, SuiObjectClient, } from './types.js';
-export { fetchAccessNfts, ownsAccessNft, parseOwnedAccessNft, fetchAccessNftById, parseAdminCap, parseGate, fetchAdminCaps, fetchGate, fetchOwnedGates, } from './ownership.js';
-export { buildPurchaseTx, buildConsumeTx, buildCreateGateTx, buildSetPriceTx, buildSetPaymentRecipientTx, buildSetPausedTx, buildSetDefaultUsesTx, buildSetSoulboundTx, buildSetAutoBurnAtZeroTx, buildSetNftNameTx, buildSetNftImageUrlTx, buildSetNftDescriptionTx, buildAirdropTx, buildMakeGateImmutableTx, } from './ptb.js';
-export { fetchChallenge } from './challenge.js';
-export { personalMessageForNonce, encodeAccessProof, decodeAccessProof, buildAccessProof, } from './proof.js';
-export type { PersonalMessageSigner } from './proof.js';

package/dist/src/ownership.d.ts

@@ -1,69 +0,0 @@
-import type { OwnedAccessNft, OwnedGate, OwnedObjectsClient, SuiObjectClient } from './types.js';
-/**
- * Parse a single `getOwnedObjects`/`getObject` entry into an {@link OwnedAccessNft}, or `null`
- * if it is not an access NFT. Validates the object **type** when present (typed), and reads the
- * nested `data.fields` deterministically.
- */
-export declare function parseOwnedAccessNft(entry: any): OwnedAccessNft | null;
-/**
- * Typed single-object read of one access NFT by id (`getObject` with `showType`+`showContent`),
- * used when a UI needs the **exact** `usesRemaining` reliably rather than the best-effort parse
- * of an owned-objects page. Returns `null` if the object is missing or not an access NFT.
- *
- * @throws {Error} if the RPC call fails at the network or transport layer.
- */
-export declare function fetchAccessNftById(client: SuiObjectClient, objectId: string): Promise<OwnedAccessNft | null>;
-/**
- * Fetch all access NFTs of `nftType` owned by `owner`, optionally restricted to a specific
- * `gateId`. Uses `getOwnedObjects` filtered by `StructType` (the standard owned-objects query).
- *
- * @throws {Error} if the RPC call fails at the network or transport layer.
- */
-export declare function fetchAccessNfts(client: OwnedObjectsClient, owner: string, nftType: string, gateId?: string): Promise<OwnedAccessNft[]>;
-/**
- * True if `owner` holds at least one access NFT of `nftType` (optionally for `gateId`).
- * This is the cheap check a frontend runs to decide whether to show a gated option, and a
- * gateway runs (server-side) as part of access verification.
- *
- * @throws {Error} if the underlying RPC call fails.
- */
-export declare function ownsAccessNft(client: OwnedObjectsClient, owner: string, nftType: string, gateId?: string): Promise<boolean>;
-/**
- * Parse a single `getOwnedObjects`/`getObject` entry into `{ adminCapId, gateId }`, or `null` if
- * it is not an `AdminCap`. Validates the object **type** when present and reads `fields.gate_id`.
- */
-export declare function parseAdminCap(entry: any): {
-    adminCapId: string;
-    gateId: string;
-} | null;
-/**
- * Parse a `getObject` entry for a `Gate` shared object into an {@link OwnedGate} (minus
- * `adminCapId`, which comes from the owning cap). Returns `null` if the object is missing its
- * expected `Gate` fields.
- */
-export declare function parseGate(entry: any): Omit<OwnedGate, 'adminCapId'> | null;
-/**
- * List the `{ adminCapId, gateId }` pairs for every `access_gate::AdminCap` owned by `owner`
- * under `packageId`. Uses `getOwnedObjects` filtered by `StructType` (the standard query).
- *
- * @throws {Error} if the underlying RPC call fails.
- */
-export declare function fetchAdminCaps(client: OwnedObjectsClient, owner: string, packageId: string): Promise<{
-    adminCapId: string;
-    gateId: string;
-}[]>;
-/**
- * Typed single-object read of one `Gate` by id, returning its parsed state (without `adminCapId`).
- * Returns `null` if the object is missing or not a `Gate`.
- *
- * @throws {Error} if the RPC call fails at the network or transport layer.
- */
-export declare function fetchGate(client: SuiObjectClient, gateId: string): Promise<Omit<OwnedGate, 'adminCapId'> | null>;
-/**
- * Fetch every gate `owner` administers: list their owned `AdminCap`s, then fetch each referenced
- * `Gate` shared object and merge in the owning `adminCapId`. Gates whose object can no longer be
- * read (e.g. deleted) are skipped.
- *
- * @throws {Error} if an underlying RPC call fails at the network or transport layer.
- */
-export declare function fetchOwnedGates(client: OwnedObjectsClient & SuiObjectClient, owner: string, packageId: string): Promise<OwnedGate[]>;

package/dist/src/proof.d.ts

@@ -1,27 +0,0 @@
-import type { AccessProof, Challenge } from './types.js';
-/**
- * The exact bytes a wallet signs (as a personal message) to answer a challenge. Both the
- * client (signing) and the gateway (verifying) MUST derive the message identically.
- */
-export declare function personalMessageForNonce(nonce: string): Uint8Array;
-/** Encode a proof as the compact Bearer token carried in the relay auth header. */
-export declare function encodeAccessProof(proof: AccessProof): string;
-/** Decode a proof token produced by {@link encodeAccessProof}. Throws on malformed input. */
-export declare function decodeAccessProof(token: string): AccessProof;
-/** A wallet-provided personal-message signer (e.g. wallet-standard `sui:signPersonalMessage`). */
-export type PersonalMessageSigner = (message: Uint8Array) => Promise<{
-    signature: string;
-}>;
-/**
- * Sign a challenge and assemble the encoded access-proof token to hand to any gateway as its
- * auth bearer (e.g. an upload-relay client's auth-token option, an `Authorization` header).
- *
- * @throws {Error} if the wallet signer rejects or fails to sign the message.
- */
-export declare function buildAccessProof(opts: {
-    address: string;
-    challenge: Challenge;
-    sign: PersonalMessageSigner;
-    /** Present for single-use gates: the `consume` tx digest. */
-    consumeDigest?: string;
-}): Promise<string>;

package/dist/src/ptb.d.ts

@@ -1,54 +0,0 @@
-import { Transaction } from '@mysten/sui/transactions';
-import type { AccessGateConfig, GateAdminContext } from './types.js';
-/**
- * Build a PTB that purchases access: split `priceMist` from the gas coin and call
- * `access_gate::purchase(gate, payment)`. Overpayment is refunded on-chain, so the split
- * must be exactly the price. The caller signs + executes with their wallet.
- */
-export declare function buildPurchaseTx(cfg: AccessGateConfig, priceMist: bigint | number): Transaction;
-/**
- * Build a PTB that consumes one use of a single-use NFT, binding it to `nonce`. Selects
- * `consume` or `consume_soulbound` from `cfg.soulbound`. For unlimited passes there is
- * nothing to consume — do not call this.
- */
-export declare function buildConsumeTx(cfg: AccessGateConfig, nftId: string, nonce: string): Transaction;
-/**
- * Build a PTB that creates a new gate. Mostly for tooling/operators; the frontend usually
- * only purchases/consumes an existing gate.
- */
-export declare function buildCreateGateTx(packageId: string, opts: {
-    priceMist: bigint | number;
-    paymentRecipient: string;
-    defaultUses: bigint | number;
-    soulbound: boolean;
-    autoBurnAtZero: boolean;
-    nftName: string;
-    nftImageUrl: string;
-    nftDescription: string;
-}): Transaction;
-/** Set the gate price (in MIST) charged by future `purchase` calls (0 = free). */
-export declare function buildSetPriceTx(ctx: GateAdminContext, priceMist: bigint | number): Transaction;
-/** Redirect future purchase payments to a new recipient address. */
-export declare function buildSetPaymentRecipientTx(ctx: GateAdminContext, recipient: string): Transaction;
-/** Pause or unpause `purchase` (paused ⇒ `purchase` aborts with `E_PAUSED`). */
-export declare function buildSetPausedTx(ctx: GateAdminContext, paused: boolean): Transaction;
-/** Change the default uses for future mints (0 ⇒ unlimited pass; N ⇒ single-use with N). */
-export declare function buildSetDefaultUsesTx(ctx: GateAdminContext, defaultUses: bigint | number): Transaction;
-/** Switch the soulbound flag for future mints (does not affect already-minted NFTs). */
-export declare function buildSetSoulboundTx(ctx: GateAdminContext, soulbound: boolean): Transaction;
-/** Toggle the auto-burn-at-zero policy for future mints. */
-export declare function buildSetAutoBurnAtZeroTx(ctx: GateAdminContext, autoBurn: boolean): Transaction;
-/** Update the default NFT display name for future mints. */
-export declare function buildSetNftNameTx(ctx: GateAdminContext, name: string): Transaction;
-/** Update the default NFT image URL for future mints. */
-export declare function buildSetNftImageUrlTx(ctx: GateAdminContext, url: string): Transaction;
-/** Update the default NFT description for future mints. */
-export declare function buildSetNftDescriptionTx(ctx: GateAdminContext, description: string): Transaction;
-/** AdminCap-gated free grant (airdrop) of the gate's NFT flavour to `recipient`. */
-export declare function buildAirdropTx(ctx: GateAdminContext, recipient: string): Transaction;
-/**
- * Make the gate immutable — **irreversible**. Consumes the `AdminCap` (passed by value) and sets
- * `Gate.frozen = true`, permanently ending all setters and `airdrop`. `purchase`/`consume` remain
- * permissionless. Grant everything first, then freeze.
- */
-export declare function buildMakeGateImmutableTx(ctx: GateAdminContext): Transaction;

package/dist/src/types.d.ts

@@ -1,120 +0,0 @@
-/**
- * Shared wire + config types for the access-gate client.
- *
- * These mirror the on-chain `access_gate` Move package and the challenge/proof wire
- * protocol implemented by the generic Rust gateway. Keep the three in sync.
- */
-/** Identifies a deployed gate and the NFT type that satisfies it. */
-export interface AccessGateConfig {
-    /** Published `access_gate` package ID. */
-    packageId: string;
-    /** The shared `Gate` object ID. */
-    gateId: string;
-    /** The shared `PlatformConfig` object ID. Required for `buildPurchaseTx`. */
-    platformConfigId: string;
-    /**
-     * Fully-qualified NFT type string to filter ownership by, e.g.
-     * `<pkg>::access_gate::AccessNFT` or `<pkg>::access_gate::SoulboundAccessNFT`.
-     * Choose the variant matching the gate's `soulbound` flag.
-     */
-    nftType: string;
-    /** Whether this gate mints soulbound NFTs (selects `consume` vs `consume_soulbound`). */
-    soulbound?: boolean;
-}
-/**
- * Identifies a gate an operator administers, for the AdminCap-gated management PTB builders
- * (setters, airdrop, freeze). The three ids together authorise a call: `adminCapId` must be the
- * `AdminCap` whose `gate_id` matches `gateId`, under the published `packageId`.
- */
-export interface GateAdminContext {
-    /** Published `access_gate` package ID. */
-    packageId: string;
-    /** The shared `Gate` object ID being administered. */
-    gateId: string;
-    /** The `AdminCap` object ID authorised over `gateId` (held by the operator). */
-    adminCapId: string;
-}
-/** A gate an operator administers, parsed from its on-chain `Gate` object + owning `AdminCap`. */
-export interface OwnedGate {
-    /** The shared `Gate` object ID. */
-    gateId: string;
-    /** The `AdminCap` object ID that authorises administering this gate. */
-    adminCapId: string;
-    /** Price in MIST charged by `purchase` (0 = free). */
-    priceMist: bigint;
-    /** Address that receives the operator share of each paid `purchase`. */
-    paymentRecipient: string;
-    /** 0 ⇒ unlimited passes; N ⇒ single-use NFTs with N uses. */
-    defaultUses: bigint;
-    /** Whether newly-minted NFTs are soulbound. */
-    soulbound: boolean;
-    /** Whether a single-use NFT is deleted (vs. kept as a receipt) at zero uses. */
-    autoBurnAtZero: boolean;
-    /** Whether `purchase` is currently disabled. */
-    paused: boolean;
-    /** Whether the gate has been made immutable (all admin/airdrop permanently disabled). */
-    frozen: boolean;
-    /** Default NFT display name minted into future NFTs. */
-    nftName: string;
-    /** Default NFT image URL minted into future NFTs. */
-    nftImageUrl: string;
-    /** Default NFT description minted into future NFTs. */
-    nftDescription: string;
-}
-/** A server-issued, time-bound challenge the wallet signs to prove control of an address. */
-export interface Challenge {
-    /** Opaque nonce (as issued by the gateway; treated as a UTF-8 string end-to-end). */
-    nonce: string;
-    /** Unix epoch milliseconds after which the challenge is rejected. */
-    expiresAt: number;
-}
-/** The proof a client presents to a gateway to demonstrate gated access. */
-export interface AccessProof {
-    /** The Sui address claimed by the caller. */
-    address: string;
-    /** The challenge nonce that was signed. */
-    nonce: string;
-    /** Base64 personal-message signature over {@link personalMessageForNonce}. */
-    signature: string;
-    /**
-     * For single-use gates: the digest of the on-chain `consume(nft, nonce)` transaction, so
-     * the gateway can confirm the matching `AccessConsumedEvent` before allowing the request.
-     */
-    consumeDigest?: string;
-}
-/** A parsed owned access NFT. */
-export interface OwnedAccessNft {
-    objectId: string;
-    gateId: string;
-    /** `null` for an unlimited pass; otherwise remaining single-use count. */
-    usesRemaining: number | null;
-}
-/** Minimal structural subset of a Sui client used for ownership queries (grpc or json-rpc). */
-export interface OwnedObjectsClient {
-    getOwnedObjects(params: {
-        owner: string;
-        filter?: {
-            StructType: string;
-        };
-        options?: {
-            showContent?: boolean;
-            showType?: boolean;
-        };
-        cursor?: string | null;
-        limit?: number | null;
-    }): Promise<{
-        data: unknown[];
-        hasNextPage?: boolean;
-        nextCursor?: string | null;
-    }>;
-}
-/** Minimal structural subset of a Sui client used for a typed single-object read. */
-export interface SuiObjectClient {
-    getObject(params: {
-        id: string;
-        options?: {
-            showContent?: boolean;
-            showType?: boolean;
-        };
-    }): Promise<unknown>;
-}