@medialane/sdk 0.85.4 → 0.85.6

package/dist/starknet/index.d.ts

@@ -1,6 +1,6 @@
-import { b6 as ResolvedConfig, bf as TxResult, at as CreatePopCollectionParams, ae as ClaimConditions, ap as CreateDropParams, ay as CreateTicketParams, aT as MintTicketsParams, ar as CreateMembershipParams, aS as MintMembershipsParams, aw as CreateSponsorshipOfferParams, b3 as ProposeSponsorshipParams, l as ApiClient, aQ as MedialaneConfig, aR as MedialaneErrorCode, aY as OrderDetails, b7 as ResolvedFeeConfig } from '../services-CovenF1m.js';
+import { b6 as ResolvedConfig, bf as TxResult, at as CreatePopCollectionParams, ae as ClaimConditions, ap as CreateDropParams, ay as CreateTicketParams, aT as MintTicketsParams, ar as CreateMembershipParams, aS as MintMembershipsParams, aw as CreateSponsorshipOfferParams, b3 as ProposeSponsorshipParams, l as ApiClient, aQ as MedialaneConfig, aR as MedialaneErrorCode, aY as OrderDetails, b7 as ResolvedFeeConfig } from '../services-okgZ2AMD.js';
 import { AccountInterface, Call, ProviderInterface, TypedData, constants, BigNumberish, DeployAccountContractPayload } from 'starknet';
-import { V as VenueAdapter, O as OrderRef, A as AdapterTxResult, R as RegisterOrderParams, j as VenueSigner } from '../types-sIc3OCpo.js';
+import { V as VenueAdapter, O as OrderRef, A as AdapterTxResult, R as RegisterOrderParams, j as VenueSigner } from '../types-nPIXtCF5.js';
 import 'zod';
 
 declare class PopService {
@@ -37,8 +37,6 @@ declare class PopService {
     createCollection(account: AccountInterface, params: CreatePopCollectionParams): Promise<TxResult>;
 }
 
-/** Exported so the backend orchestrator can build `create_drop`/`set_claim_conditions`
- *  calldata with the exact same conversion this service uses client-side. */
 declare function toContractConditions(c: ClaimConditions): {
     start_time: number;
     end_time: number;
@@ -85,50 +83,28 @@ declare class DropService {
 }
 
 interface DeployCollectionParams {
-    /** Human-readable collection name (e.g. "My IP Collection") */
     name: string;
-    /** Short ticker symbol (e.g. "MIP") */
     symbol: string;
-    /**
-     * Collection-level metadata URI (e.g. "ipfs://Qm…/collection.json").
-     * Should point to a JSON containing `name`, `description`, `image`, and `external_link`.
-     * Stored on-chain at deploy time. Pass an empty string if not available.
-     */
     baseUri: string;
 }
 interface MintEditionParams {
-    /** ERC-1155 collection contract address */
     collection: string;
-    /** Recipient wallet address */
     to: string;
-    /** Number of copies of this new edition to mint */
     value: bigint | string;
-    /**
-     * Metadata URI — must start with `ipfs://` or `ar://`.
-     * Immutable: validated and stored at mint. The token id is assigned on-chain
-     * (sequential from 1); read it from the `IPMinted` event of the returned tx.
-     */
     tokenUri: string;
 }
 interface BatchMintEditionParams {
-    /** ERC-1155 collection contract address */
     collection: string;
-    /** Recipient wallet address */
     to: string;
-    /** New editions to create; ids are assigned sequentially on-chain. */
     items: Array<{
         value: bigint | string;
         tokenUri: string;
     }>;
 }
 interface AddSupplyParams {
-    /** ERC-1155 collection contract address */
     collection: string;
-    /** Recipient wallet address */
     to: string;
-    /** Existing edition id to mint more copies of (reverts if it doesn't exist) */
     tokenId: bigint | string;
-    /** Number of additional copies */
     value: bigint | string;
 }
 declare class ERC1155CollectionService {
@@ -136,56 +112,21 @@ declare class ERC1155CollectionService {
     constructor(config: ResolvedConfig);
     private _factory;
     private _collection;
-    /**
-     * Deploy a new ERC-1155 IP collection.
-     * Caller becomes the collection owner and can mint items.
-     * Returns the transaction hash; the deployed collection address is emitted
-     * in the `CollectionDeployed` event of the factory.
-     */
     deployCollection(account: AccountInterface, params: DeployCollectionParams): Promise<TxResult>;
-    /**
-     * Mint a new edition into an existing ERC-1155 collection.
-     * Caller must be the collection owner. The token id is assigned on-chain
-     * (sequential from 1) — read it from the `IPMinted` event of the returned tx.
-     * The `tokenUri` is immutable.
-     */
     mintEdition(account: AccountInterface, params: MintEditionParams): Promise<TxResult>;
-    /**
-     * Batch-mint multiple new editions into an existing ERC-1155 collection.
-     * All editions go to the same `to` address; ids are assigned sequentially
-     * on-chain. Caller must be the collection owner.
-     */
     batchMintEdition(account: AccountInterface, params: BatchMintEditionParams): Promise<TxResult>;
-    /**
-     * Mint additional copies of an EXISTING edition into an ERC-1155 collection.
-     * Reverts on-chain if `tokenId` has never been minted. Provenance/URI unchanged.
-     * Caller must be the collection owner.
-     */
     addSupply(account: AccountInterface, params: AddSupplyParams): Promise<TxResult>;
-    /**
-     * Set the default ERC-2981 royalty for the entire collection.
-     * `feeNumerator` is out of 10 000 (e.g. 500 = 5%).
-     * Caller must be the collection owner.
-     */
     setDefaultRoyalty(account: AccountInterface, params: {
         collection: string;
         receiver: string;
         feeNumerator: number;
     }): Promise<TxResult>;
-    /**
-     * Set a per-token ERC-2981 royalty override.
-     * `feeNumerator` is out of 10 000. Caller must be the collection owner.
-     */
     setTokenRoyalty(account: AccountInterface, params: {
         collection: string;
         tokenId: bigint | string;
         receiver: string;
         feeNumerator: number;
     }): Promise<TxResult>;
-    /**
-     * Approve the Medialane1155 marketplace (or any operator) to transfer
-     * all tokens on behalf of `account`. Required before listing.
-     */
     setApprovalForAll(account: AccountInterface, params: {
         collection: string;
         operator: string;
@@ -194,16 +135,12 @@ declare class ERC1155CollectionService {
 }
 
 interface CreateCreatorCoinParams {
-    /** Owner of the new coin — the only address allowed to launch it. */
     owner: string;
     name: string;
     symbol: string;
-    /** Full fixed supply (raw, 18 decimals). Minted to the Factory until launch. */
     initialSupply: bigint | string;
-    /** Deterministic deploy salt. Defaults to a timestamp-derived value. */
     salt?: bigint | string;
 }
-/** Ekubo pool params (off-chain tick). The `startingPrice` is an Ekubo i129 tick. */
 interface EkuboPoolParams {
     fee: bigint | string;
     tickSpacing: bigint | string;
@@ -215,91 +152,25 @@ interface EkuboPoolParams {
 }
 interface EkuboLaunchParams {
     creatorCoin: string;
-    /** Quote token (e.g. STRK). Must NOT itself be a Creator Coin. */
     quoteToken: string;
-    /** Team-allocation recipients (≤10% of supply, summed). */
     initialHolders: string[];
     initialHoldersAmounts: (bigint | string)[];
-    /** Anti-snipe window in seconds. 0 = none. */
     transferRestrictionDelay?: number;
-    /** Max % of supply buyable per tx during the window, in bps (≥50 = 0.5%). */
     maxPercentageBuyLaunch?: number;
-    /** Ekubo pool params. Defaults to {@link VALIDATED_EKUBO_PARAMS} (0.01 quote/coin). */
     ekubo?: EkuboPoolParams;
-    /**
-     * Quote (raw units) to transfer to the Factory in the same multicall, used to
-     * buy the team allocation back out of the pool. Must cover
-     * `sum(initialHoldersAmounts) × price` (leftover is returned to the caller).
-     * If omitted, the Factory must already hold enough quote.
-     */
     quoteFundAmount?: bigint | string;
 }
-/**
- * Smoke-validated Ekubo params (mainnet 2026-06-04): 0.01 quote/coin for an
- * 18-decimal quote. `sign: true` yields 0.01 quote/coin regardless of token0/1
- * ordering — the launcher compensates internally.
- *
- * TODO: a `priceToEkuboParams(price, quoteDecimals, tickSpacing)` helper (port of
- * unrug's `ekubo/helpers.cairo` tick math) so callers can pick an arbitrary price.
- */
 declare const VALIDATED_EKUBO_PARAMS: EkuboPoolParams;
-/**
- * Compute the Ekubo `EkuboPoolParams` for launching a coin at `price`
- * (default: the fixed 0.01 quote/coin every launch already uses) against a
- * quote token of any decimals — not just the 18-decimal case
- * `VALIDATED_EKUBO_PARAMS` was smoke-tested for.
- *
- * No address/ordering parameters: the contract itself determines
- * `is_token1_quote` on-chain (`launcher.cairo`) and flips the tick's SIGN
- * accordingly — magnitude never changes with ordering. This function
- * always computes the tick as if quote were token1; the contract
- * compensates sign itself if that assumption doesn't hold for the real
- * deployed addresses (this is exactly what "sign: true yields 0.01
- * quote/coin regardless of token0/1 ordering" already meant).
- *
- * `fee`/`tickSpacing`/`bound` are decimal-independent (bound is a pure
- * tick-count offset, not a price) and reused from `VALIDATED_EKUBO_PARAMS`
- * as-is. Only `startingPrice` is computed:
- *   decAdj   = 10^(coinDecimals − quoteDecimals)
- *   rawRatio = price / decAdj
- *   tick     = trunc(log(rawRatio) / log(1.000001) / tickSpacing) × tickSpacing
- *              (rounds toward zero, not nearest — confirmed against the
- *              known-good on-chain constant, which is 769×tickSpacing,
- *              not the nearer 770×tickSpacing)
- *   sign     = tick < 0
- *
- * Cross-verified against the real on-chain constant: for an 18-decimal
- * quote this reproduces `VALIDATED_EKUBO_PARAMS.startingPrice` exactly
- * (mag 4600158 = 769 × tickSpacing 5982).
- */
 declare function priceToEkuboParams(quoteDecimals: number, price?: number): EkuboPoolParams;
-/** A Creator Coin's live spot price, read from its Ekubo pool. */
 interface CreatorCoinPrice {
-    /** Quote tokens per 1 coin, human units (e.g. 0.0101 = 0.0101 STRK/coin). */
     quotePerCoin: number;
-    /** The quote token the coin is paired against on Ekubo. */
     quoteToken: string;
     quoteSymbol: string | null;
     quoteDecimals: number;
 }
-/**
- * Read a Creator Coin's live spot price directly from its Ekubo pool (read-only).
- *
- * Self-contained: discovers the pool params (quote token, fee, tick spacing) from the
- * coin's own `launched_with_liquidity_parameters`, reads `Core.get_pool_price`, and
- * converts the `sqrt_ratio` to quote-per-coin (handling token0/1 ordering + decimals).
- * Returns `null` if the coin isn't launched on Ekubo. No backend, no swap-quote
- * dependency — works for day-one coins that AVNU doesn't index yet.
- */
 declare function getCreatorCoinPrice(coinAddress: string, provider: ProviderInterface): Promise<CreatorCoinPrice | null>;
-/** Build the `create_creator_coin` call (full supply minted to the Factory). */
 declare function buildCreateCreatorCoinCall(params: CreateCreatorCoinParams): Call;
-/**
- * Build the Ekubo launch multicall: optional quote `transfer` (pre-funds the
- * Factory for the team-allocation buyback) + `launch_on_ekubo`.
- */
 declare function buildLaunchOnEkuboCalls(params: EkuboLaunchParams): Call[];
-/** Minimal receipt shape — works with any starknet.js receipt version. */
 interface CreatorCoinReceiptLike {
     events?: Array<{
         from_address?: string;
@@ -307,33 +178,15 @@ interface CreatorCoinReceiptLike {
         data?: string[];
     }>;
 }
-/**
- * Pull the deployed coin address from a `create_creator_coin` tx receipt.
- * Event data = [owner, name, symbol, supply_low, supply_high, coin_address].
- * Throws when the receipt carries no matching Factory event.
- */
 declare function parseCreatorCoinCreated(receipt: CreatorCoinReceiptLike): string;
-/**
- * On-chain Creator Coin interactions (Ekubo-only launchpad).
- * Faithful fork of unruggable.meme — permanent LP lock + team-allocation buyback.
- */
 declare class CreatorCoinService {
     private readonly factoryAddress;
     private readonly config;
     constructor(config: ResolvedConfig);
     private _factory;
-    /** Deploy a fixed-supply CreatorCoin (full supply minted to the Factory). */
     createCreatorCoin(account: AccountInterface, params: CreateCreatorCoinParams): Promise<TxResult>;
-    /**
-     * Launch a coin on Ekubo (owner-only). Optionally pre-funds the Factory with
-     * quote (for the buyback) in the same multicall. Liquidity is permanently
-     * locked in the EkuboLauncher.
-     */
     launchOnEkubo(account: AccountInterface, params: EkuboLaunchParams): Promise<TxResult>;
-    /** View: is this address a Factory-deployed Creator Coin? */
     isCreatorCoin(address: string, account: AccountInterface): Promise<boolean>;
-    /** Read a coin's live Ekubo spot price (quote-per-coin) via the configured RPC.
-     *  Read-only; returns null if the coin isn't launched on Ekubo. */
     getPrice(coinAddress: string): Promise<CreatorCoinPrice | null>;
 }
 
@@ -352,32 +205,22 @@ declare class TicketService {
     private _factory;
     private _collection;
     private _collectionRead;
-    /**
-     * Deploys a new IPTicketCollection via the factory. Caller becomes owner.
-     * `baseUri` is the collection-level metadata URI, embedded on-chain in the
-     * deploy transaction.
-     */
     deployCollection(account: AccountInterface, params: {
         name: string;
         symbol: string;
         baseUri: string;
         factoryAddress?: string;
     }): Promise<TxResult>;
-    /** Owner-only. Creates a new ticket inside the caller's deployed collection. */
     createTicket(account: AccountInterface, params: CreateTicketParams): Promise<TxResult>;
-    /** Owner-only. Mints `amount` of `tokenId` to `to`. */
     mint(account: AccountInterface, params: MintTicketsParams): Promise<TxResult>;
-    /** Read — true if holder has balance > 0 and current time is within the ticket window. */
     isValid(params: {
         collection: string;
         tokenId: bigint | string;
         holder: string;
     }): Promise<boolean>;
-    /** Read — number of tickets created so far (ids are sequential from 1). */
     getTicketCount(params: {
         collection: string;
     }): Promise<bigint>;
-    /** Read — returns the Ticket record for a token ID. */
     getTicket(params: {
         collection: string;
         tokenId: bigint | string;
@@ -399,36 +242,23 @@ declare class ClubService {
     private _factory;
     private _collection;
     private _collectionRead;
-    /**
-     * Deploys a new IPClubCollection via the factory. Caller becomes owner.
-     * `baseUri` is the collection-level metadata URI, embedded on-chain in the
-     * deploy transaction.
-     */
     deployCollection(account: AccountInterface, params: {
         name: string;
         symbol: string;
         baseUri: string;
         factoryAddress?: string;
     }): Promise<TxResult>;
-    /** Owner-only. Creates a new membership tier inside the caller's deployed collection. */
     createMembership(account: AccountInterface, params: CreateMembershipParams): Promise<TxResult>;
-    /**
-     * Owner-only. Mints `amount` of `tokenId` to `to`. The validity window
-     * gates membership, never minting — future-window tiers mint fine.
-     */
     mint(account: AccountInterface, params: MintMembershipsParams): Promise<TxResult>;
-    /** Read — true if holder holds any tier currently inside its validity window. */
     isMember(params: {
         collection: string;
         holder: string;
     }): Promise<boolean>;
-    /** Read — true if holder holds `tokenId` and the current time is inside its window. */
     isMemberOf(params: {
         collection: string;
         tokenId: bigint | string;
         holder: string;
     }): Promise<boolean>;
-    /** Read — returns the Membership record for a token ID. */
     getMembership(params: {
         collection: string;
         tokenId: bigint | string;
@@ -454,7 +284,6 @@ interface SponsorshipProposalRecord {
     tokenId: bigint;
     amount: bigint;
     duration: number;
-    /** Unix seconds; 0 = no deadline. */
     validUntil: number;
     paymentToken: string;
     licenseTermsUri: string;
@@ -462,34 +291,20 @@ interface SponsorshipProposalRecord {
     open: boolean;
     royaltyBps: bigint;
 }
-/**
- * IP Sponsorship v3 — one contract is both the offer/bid/proposal registry
- * AND the issued license collection (a standard ERC-721; embeds
- * ERC721Component directly, no separate receipt contract, no `set_minter`
- * bootstrap). `transferable`/expiry are declarative terms only — never
- * contract-enforced against a transfer — carried in `license_terms_uri`
- * metadata and the `LicenseMinted` event; the indexer, not this contract,
- * derives validity. A license moves through the standard ERC-721
- * `transfer_from`/`safe_transfer_from` on this same contract address, so
- * there is no bespoke transfer wrapper here.
- */
 declare class SponsorshipService {
     private readonly sponsorshipAddress?;
     private readonly config;
     constructor(config: ResolvedConfig);
     private _contract;
     private _contractRead;
-    /** The offer author must currently own (nftContract, tokenId) — enforced on-chain at create and accept. */
     createOffer(account: AccountInterface, params: CreateSponsorshipOfferParams & {
         sponsorshipAddress?: string;
     }): Promise<TxResult>;
-    /** Reversible — gates new bids/acceptance only. */
     setOfferOpen(account: AccountInterface, params: {
         offerId: bigint | string;
         open: boolean;
         sponsorshipAddress?: string;
     }): Promise<TxResult>;
-    /** A bid is a signal plus an open ERC-20 allowance — no tokens move until accepted. Prepends the approve. */
     placeBid(account: AccountInterface, params: {
         offerId: bigint | string;
         amount: bigint | string;
@@ -500,11 +315,6 @@ declare class SponsorshipService {
         offerId: bigint | string;
         sponsorshipAddress?: string;
     }): Promise<TxResult>;
-    /**
-     * Author-only. Re-verifies IP ownership, settles the sponsor's payment
-     * (allowance pull, no escrow), and mints the license — a real ERC-721 on
-     * this same contract — to the sponsor, all atomically in one call.
-     */
     acceptBid(account: AccountInterface, params: {
         offerId: bigint | string;
         sponsor: string;
@@ -513,22 +323,14 @@ declare class SponsorshipService {
     proposeSponsorship(account: AccountInterface, params: ProposeSponsorshipParams & {
         sponsorshipAddress?: string;
     }): Promise<TxResult>;
-    /** Proposer-only. Advisory against an acceptance in flight in the same block. */
     withdrawProposal(account: AccountInterface, params: {
         proposalId: bigint | string;
         sponsorshipAddress?: string;
     }): Promise<TxResult>;
-    /**
-     * Asset-owner-only (re-verified on-chain — a proposal binds to the asset,
-     * not a person: whoever owns it at acceptance time is paid and issues the
-     * license). Settles payment and mints the license atomically, same as
-     * `acceptBid`.
-     */
     acceptProposal(account: AccountInterface, params: {
         proposalId: bigint | string;
         sponsorshipAddress?: string;
     }): Promise<TxResult>;
-    /** Asset-owner-only. */
     rejectProposal(account: AccountInterface, params: {
         proposalId: bigint | string;
         sponsorshipAddress?: string;
@@ -555,7 +357,6 @@ declare class SponsorshipService {
     getLastLicenseId(params?: {
         sponsorshipAddress?: string;
     }): Promise<bigint>;
-    /** EIP-2981 — royalty recipient (the license's issuing author) and amount owed on a resale at `salePrice`. */
     royaltyInfo(params: {
         licenseId: bigint | string;
         salePrice: bigint | string;
@@ -567,10 +368,6 @@ declare class SponsorshipService {
 }
 
 declare class MedialaneClient {
-    /**
-     * Off-chain API client — covers all /v1/* backend endpoints.
-     * Requires `backendUrl` in config; pass `apiKey` for authenticated routes.
-     */
     readonly api: ApiClient;
     readonly services: {
         readonly pop: PopService;
@@ -600,40 +397,17 @@ declare function getCounter(address: string, config: ResolvedConfig): Promise<bi
 declare function getOrderDetails1155(orderHash: string, config: ResolvedConfig): Promise<OrderDetails>;
 declare function getCounter1155(address: string, config: ResolvedConfig): Promise<bigint>;
 
-/** What a stored/registered order resolves to for fulfilment/cancellation. */
 interface ResolvedOrder {
-    /** ERC-20 consideration token address. */
     paymentToken: string;
-    /** Per-unit price in raw token units, as a decimal string. The total paid is
-     *  `unitPrice × quantity` (quantity is 1 for ERC-721). */
     unitPrice: string;
-    /** Which venue the order lives on. */
     standard: "ERC721" | "ERC1155";
 }
-/**
- * Dependencies for {@link StarknetVenue}. The token standard is resolved through
- * injected reads (the backend already tracks it per collection) rather than an
- * on-chain interface probe — Starknet has no single canonical ERC-1155 interface
- * id and the app already carries the standard from the indexer.
- */
 interface StarknetVenueDeps {
     config: ResolvedConfig;
-    /** Read provider for building (counter/approval reads) and the post-tx receipt. */
     provider: ProviderInterface;
-    /** Resolve a registered order (payment token, per-unit price, venue) from its digest. */
     resolveOrder: (orderRef: OrderRef) => Promise<ResolvedOrder>;
-    /** Resolve a collection's token standard (from the indexer). */
     resolveStandard: (contract: string) => Promise<"ERC721" | "ERC1155">;
 }
-/**
- * First-class Starknet venue adapter. It orchestrates the marketplace protocol
- * over the chain-neutral {@link StarknetVenueSigner} capability port: it *builds*
- * typed data + calldata via the pure marketplace builders and *reads* chain state
- * (counter, approvals, receipt) on `deps.provider`, but it never signs or executes
- * itself — the app's signer does that (sign + submit + confirm). This is what lets
- * a single adapter drive every wallet (injected/Cartridge/Privy) and the AVNU
- * paymaster without knowing they differ.
- */
 declare class StarknetVenue implements VenueAdapter<StarknetVenueSigner> {
     private readonly deps;
     readonly chain: "STARKNET";
@@ -649,36 +423,21 @@ declare class StarknetVenue implements VenueAdapter<StarknetVenueSigner> {
         orderRef: OrderRef;
     }>;
     private readCounter;
-    /** 721 listing approval: `get_approved(tokenId) == marketplace` ⇒ no approve. */
     private approval721ForListing;
-    /** 1155 listing approval: `is_approved_for_all(owner, marketplace)`. */
     private approval1155ForListing;
-    /** Offers always approve the ERC-20 spend (no read). */
     private approvalForErc20;
-    /** The canonical Starknet order id = the contract-emitted `OrderCreated`
-     *  hash (`keys[1]`), which is exactly what the indexer stores. */
     private orderRefFromReceipt;
 }
 
 type FeeSurface = "marketplace" | "launchpad" | "sponsorship";
 interface BuildFeeCallParams {
     surface: FeeSurface;
-    /** ERC-20 address the gross amount is denominated in. */
     token: string;
-    /** Gross amount in raw token units (e.g. price in wei, or price * quantity). */
     grossAmount: bigint;
 }
-/**
- * The single source of truth for the platform fee. Returns one ERC-20
- * `transfer(fundAddress, feeAmount)` Call to bundle into the settlement
- * multicall, or `null` when no fee should be charged.
- *
- * Fail-safe: returns null if disabled, no fund address, or the fee floors to 0.
- */
 declare function buildFeeCall(p: BuildFeeCallParams, cfg: ResolvedFeeConfig): Call | null;
 
 declare const ADMIN_SCOPE = "admin-api";
-/** The wallet-signed authorization for a session key. */
 interface AdminGrant {
     wallet: string;
     chain: string;
@@ -700,19 +459,11 @@ interface AdminRequest {
     nonce: string;
     ts: number;
 }
-/** Compact session-key signature over adminRequestDigest. */
 type AdminRequestSig = string;
 
-/**
- * Canonical felt digest of a request — the SINGLE definition shared by signer
- * (portal/agent) and verifier (backend). Binds method+path+query+body+nonce+ts,
- * so a captured request cannot be retargeted or mutated without invalidating it.
- */
 declare function adminRequestDigest(req: AdminRequest): string;
 
-/** Sign a request with the session private key. */
 declare function signAdminRequest(sessionPrivateKey: string, req: AdminRequest): AdminRequestSig;
-/** Verify a request signature against the full session public key. */
 declare function verifyAdminRequestSig(sessionPublicKey: string, req: AdminRequest, sig: AdminRequestSig): boolean;
 
 interface AdminSessionTypedDataInput {
@@ -722,7 +473,6 @@ interface AdminSessionTypedDataInput {
     expiresAt: number;
     chainId?: string;
 }
-/** The SNIP-12 typed data the wallet signs — rebuilt identically on the backend. */
 declare function buildAdminSessionTypedData(p: AdminSessionTypedDataInput): {
     readonly types: {
         readonly StarknetDomain: readonly [{
@@ -766,7 +516,6 @@ declare function buildAdminSessionTypedData(p: AdminSessionTypedDataInput): {
         readonly expiresAt: string;
     };
 };
-/** felt commitment to a full session public key (fits in the signed message). */
 declare function sessionKeyHashOf(sessionPublicKey: string): string;
 interface CreateGrantOpts {
     wallet: string;
@@ -775,10 +524,6 @@ interface CreateGrantOpts {
     ttlSeconds?: number;
     now?: () => number;
 }
-/**
- * Generate an ephemeral session keypair and have `signTypedData` (the connected
- * wallet's signMessage) sign the grant. The private key never leaves the caller.
- */
 declare function createAdminSessionGrant(signTypedData: (data: ReturnType<typeof buildAdminSessionTypedData>) => Promise<string[]>, opts: CreateGrantOpts): Promise<AdminSession>;
 
 declare const ADMIN_HEADERS: {
@@ -788,7 +533,6 @@ declare const ADMIN_HEADERS: {
     readonly ts: "x-ml-admin-ts";
 };
 declare function randomNonce(): string;
-/** Build the four request headers from a session + (method, path, body). */
 declare function encodeAdminHeaders(session: AdminSession, reqInit: {
     method: string;
     path: string;
@@ -801,15 +545,12 @@ interface ParsedAdminHeaders {
     nonce: string;
     ts: number;
 }
-/** Parse + shape-check the headers on the backend. Returns null if malformed. */
 declare function parseAdminHeaders(get: (name: string) => string | null | undefined): ParsedAdminHeaders | null;
 
-/** Anything that can produce a Starknet signature over SNIP-12 typed data. */
 interface SiwsSigner {
     signMessage: (typedData: TypedData) => Promise<unknown>;
 }
 interface RequestSiwsTokenArgs {
-    /** Medialane backend base URL (each app resolves this per its own env/proxy setup). */
     backendUrl: string;
     walletAddress: string;
     signer: SiwsSigner;
@@ -817,18 +558,9 @@ interface RequestSiwsTokenArgs {
 
 declare function getSiwsStorageKey(address: string): string;
 declare function isSiwsTokenValid(token: string | null | undefined): token is string;
-/** Browser-only (returns null server-side, same as a cache miss). */
 declare function getStoredSiwsToken(address: string): string | null;
-/** Browser-only (no-op server-side). */
 declare function storeSiwsToken(address: string, token: string): void;
 declare function normalizeSiwsSignature(signature: unknown): string[];
-/**
- * Request a nonce, sign it with `signer`, verify with the backend, and cache
- * the resulting token in localStorage (expiry-aware). Single source for the
- * SIWS client protocol — medialane-starknet and medialane-io both delegate
- * to this instead of keeping their own copies (see medialane-core/docs/specs/
- * 2026-06-30-remove-clerk-from-backend-design.md §IX).
- */
 declare function requestSiwsToken({ backendUrl, walletAddress, signer, }: RequestSiwsTokenArgs): Promise<string>;
 
 declare const IPMarketplaceABI: readonly [{
@@ -8099,93 +7831,29 @@ declare const MAX_SUPPLY = 1000000000000n;
 declare function validateName(s: string): string | null;
 declare function validateSymbol(s: string): string | null;
 declare function validateSupply(human: string): string | null;
-/** Human integer → raw base units (default 18-dec coin). */
 declare function toRaw(human: bigint, decimals?: number): bigint;
-/** Team allocation in raw coin units. `pct` is whole-percent 0–10. */
 declare function teamCoinsRaw(supplyRaw: bigint, pct: number): bigint;
-/** Quote (raw) needed to buy the team allocation back out of the pool:
- *  teamCoins(human) × 0.01, in the quote token's raw units.
- *  = teamCoinsRaw × 10^quoteDecimals / (100 × 10^18). For 18-dec quote → /100. */
 declare function buybackQuoteRaw(teamCoinsRawValue: bigint, quoteDecimals: number): bigint;
-/** Fully-diluted value (human, in quote) for the live preview. */
 declare function fdvHuman(supplyHuman: number): number;
 
-/**
- * Serialize a string as Cairo ByteArray calldata felts using UTF-8 encoding.
- *
- * starknet.js byteArray.byteArrayFromString calls encodeShortString internally
- * which rejects non-ASCII characters (accented letters, CJK, Arabic, etc.).
- * This implementation packs raw UTF-8 bytes into 31-byte chunks as big-endian
- * felts, matching the Cairo ByteArray struct layout.
- *
- * Return layout: [chunks_len, ...chunk_felts, pending_word, pending_word_len]
- */
 declare function encodeByteArray(str: string): string[];
 
-/**
- * Build SNIP-12 typed data for signing an OrderParameters struct.
- * The shape is identical across ERC-721 and ERC-1155 (nested OfferItem +
- * ConsiderationItem) — only the domain version differs.
- */
 declare function buildOrderTypedData(message: Record<string, unknown>, chainId: constants.StarknetChainId | string): TypedData;
 declare function build1155OrderTypedData(message: Record<string, unknown>, chainId: constants.StarknetChainId | string): TypedData;
-/** OrderCancellation typed data — identical shape across both standards. */
 declare function buildCancellationTypedData(message: Record<string, unknown>, chainId: constants.StarknetChainId | string): TypedData;
 declare function build1155CancellationTypedData(message: Record<string, unknown>, chainId: constants.StarknetChainId | string): TypedData;
 
-/**
- * Derive a MediaWallet owner key pair from a business-held secret and a
- * per-recipient identifier (typically their email) — deterministic, so the
- * business never has to store a per-recipient key: recompute it from the one
- * secret it already holds whenever it's needed (deploy time, handoff time),
- * then discard it. HKDF-SHA256(secret, recipientId), reduced mod the Stark
- * curve order to get a valid scalar (never zero).
- */
 declare function deriveOwnerKeyPair(secret: Uint8Array, recipientId: string): {
     privateKey: string;
     publicKey: string;
 };
 
-/**
- * Account constructor calldata for a Stark-curve owner and no guardian:
- * `serialize((Signer::Starknet(owner_pubkey), Option::None))` = `[0, owner_pubkey, 1]`.
- * Verified against `medialane-contracts/contracts/MediaWallet`'s factory
- * `build_constructor_calldata`.
- */
 declare function ownerConstructorCalldata(ownerPubkey: BigNumberish): string[];
-/**
- * Counterfactual MediaWallet account address for `(ownerPubkey, salt)` —
- * standard Starknet derivation with `deploy_from_zero` (deployer address = 0).
- * With `salt = 0` the address is a pure function of the owner key, so it can
- * be computed before anything is deployed on-chain.
- */
 declare function computeAccountAddress(ownerPubkey: BigNumberish, salt?: BigNumberish): string;
 
-/**
- * GUID of a Stark-curve owner, matching MediaWallet's
- * `SignerTrait::into_guid` for `Signer::Starknet` — `poseidon_2("Starknet
- * Signer", pubkey)`. `change_owners` removes owners by GUID, not by raw
- * pubkey.
- */
 declare function computeOwnerGuid(ownerPubkey: BigNumberish): string;
-/**
- * The `change_owners` call that hands a provisioned account off to its real
- * owner: removes the business-derived interim owner (by GUID) and adds the
- * recipient's own new owner key (by pubkey) — one call, immediate, no
- * timelock. Must be signed by a *current* owner (the interim key) to
- * succeed on-chain.
- */
 declare function buildChangeOwnersCall(accountAddress: string, removeOwnerPubkey: BigNumberish, addOwnerPubkey: BigNumberish): Call;
 
-/**
- * The exact payload starknet.js's `Account.deployAccount()` expects — the
- * caller constructs a signing `Account` from the derived private key
- * (`deriveOwnerKeyPair`) against a **pre-funded** counterfactual address
- * (`computeAccountAddress`) and calls
- * `account.deployAccount(buildDeployAccountParams(ownerPubkey))` directly.
- * This function only builds the payload — it never signs or submits
- * anything itself.
- */
 declare function buildDeployAccountParams(ownerPubkey: BigNumberish, salt?: BigNumberish): DeployAccountContractPayload;
 
 type StarknetVenueSigner = VenueSigner<TypedData, Call>;