@meddleware/nft-gate-client 0.0.4 → 0.0.5

package/dist/challenge.d.ts

@@ -0,0 +1,11 @@
+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/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@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/ownership.d.ts

@@ -0,0 +1,69 @@
+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/proof.d.ts

@@ -0,0 +1,27 @@
+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/ptb.d.ts

@@ -0,0 +1,54 @@
+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/challenge.d.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,12 @@
+/**
+ * `@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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,120 @@
+/**
+ * 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>;
+}

package/dist/types.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 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>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meddleware/nft-gate-client",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "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>",
@@ -18,15 +18,18 @@
   ],
   "files": [
     "src",
+    "dist",
     "CHANGELOG.md"
   ],
   "exports": {
     ".": {
-      "types": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "default": "./src/index.ts"
     }
   },
   "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
     "type-check": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest"
@@ -42,4 +45,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}