@medialane/sdk 0.120.0 → 0.122.0

package/dist/starknet/index.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { keccak_256 } from '@noble/hashes/sha3.js';
 import { base32, base58 } from '@scure/base';
-import { hash, cairo, uint256, RpcProvider, CairoOption, CairoOptionVariant, num, ec, encode, Contract, TypedDataRevision, constants, shortString } from 'starknet';
+import { hash, cairo, uint256, RpcProvider, CairoOption, CairoOptionVariant, num, ec, encode, validateAndParseAddress, Account, typedData, stark, Contract, TypedDataRevision, constants, shortString } from 'starknet';
 import { extract, expand } from '@noble/hashes/hkdf.js';
 import { sha256 } from '@noble/hashes/sha2.js';
 
@@ -12327,6 +12327,548 @@ function signWithPrivateKey(privateKeyHex, msgHash) {
   return [num.toHex(sig.r), num.toHex(sig.s)];
 }
 
-export { ADMIN_HEADERS, ADMIN_SCOPE, MAX_SUPPLY as COIN_MAX_SUPPLY, MIN_SUPPLY as COIN_MIN_SUPPLY, ClubService, CreatorCoinFactoryABI, CreatorCoinService, DropCollectionABI, DropFactoryABI, DropService, ERC1155CollectionService, IPClubCollectionABI, IPClubFactoryABI, IPCollection1155ABI, IPCollection1155FactoryABI, IPCollectionABI, IPGenesisABI, IPMarketplaceABI, IPNftABI, IPSponsorshipABI, IPTicketCollectionABI, IPTicketCollectionFactoryABI, InvalidStarkPrivateKeyError, MAX_HOLDERS_AT_LAUNCH, MAX_TEAM_ALLOCATION_PERCENT, Medialane1155ABI, MedialaneClient, MedialaneError, POPCollectionABI, POPFactoryABI, PopService, SUGGESTED_DEFAULT_PRICE, SponsoredCallRejectedError, SponsorshipService, StarknetVenue, TicketService, VALIDATED_EKUBO_PARAMS, adminRequestDigest, assertTransactionSucceeded, build1155CancellationTypedData, build1155OrderTypedData, buildAddOwnerCall, buildAdminSessionTypedData, buildCancelEscapeCall, buildCancellationTypedData, buildChangeOwnersCall, buildCompleteEscapeOwnerCall, buildCreateCreatorCoinCall, buildDeployAccountParams, buildFeeCall, buildLaunchOnEkuboCalls, buildOrderTypedData, buildRemoveOwnerByGuidCall, buildRemoveOwnerCall, buildSetFirstGuardianCall, buildTriggerEscapeOwnerCall, buybackQuoteRaw, toRaw as coinToRaw, computeAccountAddress, computeOwnerGuid, confirmIntentBestEffort, createAdminSessionGrant, decodeEscapeAndStatus, decodeGuardiansInfo, deployedCollectionFromReceipt, deriveAesKey, deriveOwnerKeyPair, encodeAdminHeaders, encodeByteArray, executeIntent, executeIntents, executeSponsored, fdvHuman, generateStarkKeyPair, getCounter, getCounter1155, getCreatorCoinGuarantees, getEscape, getEscapeSecurityPeriod, getGuardians, getOrderDetails, getOrderDetails1155, getOwners, getSiwsStorageKey, getStoredSiwsToken, isSiwsTokenValid, mintedTokenIdFromReceipt, normalizeSiwsSignature, ownerAliveTypedData, ownerConstructorCalldata, parseAdminHeaders, parseCreatorCoinCreated, priceToEkuboParams, randomNonce, requestSiwsToken, sealPrivateKey, sessionKeyHashOf, signAdminRequest, signWithPrivateKey, starkKeyPairFromPrivateKey, storeSiwsToken, syncTransactionBestEffort, teamCoinsRaw, toContractConditions as toDropContractConditions, unsealPrivateKey, userMayPayInstead, validateName as validateCoinName, validateSupply as validateCoinSupply, validateSymbol as validateCoinSymbol, validatePrice, verifyAdminRequestSig };
+// src/wallet/store.ts
+function createOwnerStore(config) {
+  const { storeKey, changeEvent } = config;
+  const announce = () => {
+    if (typeof window === "undefined") return;
+    window.dispatchEvent(new Event(changeEvent));
+  };
+  return {
+    load() {
+      if (typeof window === "undefined") return null;
+      try {
+        const raw = localStorage.getItem(storeKey);
+        return raw ? JSON.parse(raw) : null;
+      } catch {
+        return null;
+      }
+    },
+    loadAddress() {
+      return this.load()?.address ?? null;
+    },
+    save(sealed) {
+      localStorage.setItem(storeKey, JSON.stringify(sealed));
+      announce();
+    },
+    clear() {
+      localStorage.removeItem(storeKey);
+      announce();
+    },
+    notifyChange: announce,
+    onChange(listener) {
+      window.addEventListener(changeEvent, listener);
+      return () => window.removeEventListener(changeEvent, listener);
+    }
+  };
+}
+
+// src/wallet/pairing.ts
+var SCHEME = "medialane-device";
+var VERSION = 1;
+var LABEL_MAX = 32;
+var STARK_PRIME = (1n << 251n) + 17n * (1n << 192n) + 1n;
+var InvalidPairingPayloadError = class extends Error {
+  constructor(message = "This code is not a Medialane device request.") {
+    super(message);
+    this.name = "InvalidPairingPayloadError";
+  }
+};
+function normalisePublicKey(input) {
+  if (typeof input !== "string" || !/^0x[0-9a-fA-F]+$/.test(input)) {
+    throw new InvalidPairingPayloadError("That device key is not valid.");
+  }
+  const value = BigInt(input);
+  if (value === 0n || value >= STARK_PRIME) {
+    throw new InvalidPairingPayloadError("That device key is not valid.");
+  }
+  return `0x${value.toString(16)}`;
+}
+function sanitiseLabel(input) {
+  const raw = typeof input === "string" ? input : "";
+  return raw.replace(/\s+/g, " ").trim().slice(0, LABEL_MAX);
+}
+function encodePairingPayload(payload) {
+  return JSON.stringify({
+    scheme: SCHEME,
+    version: VERSION,
+    publicKey: normalisePublicKey(payload.publicKey),
+    label: sanitiseLabel(payload.label)
+  });
+}
+function parsePairingPayload(encoded) {
+  let data;
+  try {
+    data = JSON.parse(encoded);
+  } catch {
+    throw new InvalidPairingPayloadError();
+  }
+  if (data === null || typeof data !== "object") throw new InvalidPairingPayloadError();
+  if (data.scheme !== SCHEME || data.version !== VERSION) throw new InvalidPairingPayloadError();
+  return {
+    publicKey: normalisePublicKey(data.publicKey),
+    label: sanitiseLabel(data.label)
+  };
+}
+function parseAccountAddress(input) {
+  const trimmed = typeof input === "string" ? input.trim() : "";
+  if (!/^0x[0-9a-fA-F]{50,64}$/.test(trimmed)) {
+    throw new InvalidPairingPayloadError("That does not look like an account address.");
+  }
+  if (BigInt(trimmed) === 0n) {
+    throw new InvalidPairingPayloadError("That does not look like an account address.");
+  }
+  return trimmed;
+}
+
+// src/wallet/recovery-key.ts
+function isRecoveryKeyForWallet(sealed) {
+  try {
+    return BigInt(computeAccountAddress(sealed.ownerPubKey, 0)) === BigInt(sealed.address);
+  } catch {
+    return false;
+  }
+}
+
+// src/wallet/guardian-status.ts
+function describeGuardianStatus(guardians) {
+  if (guardians.length === 0) return { kind: "none" };
+  return { kind: "active", guardian: guardians[0] };
+}
+function describeRecoveryAction(escape) {
+  if (escape.escapeType !== "Owner") return "none";
+  if (escape.status === "Ready") return "complete";
+  if (escape.status === "Expired") return "start";
+  return "none";
+}
+function normalizeWalletAddress(address) {
+  return normalizeAddress("STARKNET", address);
+}
+function isValidStarknetAddress(address) {
+  try {
+    validateAndParseAddress(address.trim());
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDeployed(provider, address) {
+  try {
+    await provider.getClassHashAt(normalizeWalletAddress(address));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/wallet/self-fund-consent.ts
+function createSelfFundConsent(estimateFee) {
+  let handler = null;
+  return {
+    registerHandler(next) {
+      handler = next;
+    },
+    async request({ address, calls }) {
+      if (!handler) return false;
+      const feeEstimate = address && calls ? estimateFee(address, calls).catch(() => null) : Promise.resolve(null);
+      return handler(feeEstimate);
+    }
+  };
+}
+
+// src/wallet/passkey.ts
+var PasskeyCancelledError = class extends Error {
+  constructor(message = "Passkey prompt was cancelled.") {
+    super(message);
+    this.name = "PasskeyCancelledError";
+  }
+};
+var encodeBase64 = (buf) => {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+var decodeBase64 = (value) => {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+};
+function isPasskeyCancellation(err) {
+  const name = err?.name;
+  return name === "NotAllowedError" || name === "AbortError";
+}
+function createPasskeyOwner(config) {
+  const randomBytes = config.randomBytes ?? ((length) => crypto.getRandomValues(new Uint8Array(length)));
+  const credentialsApi = () => {
+    const api = config.credentials ?? (typeof navigator === "undefined" ? void 0 : navigator.credentials);
+    if (!api) throw new Error("Passkeys are only available in a browser.");
+    return api;
+  };
+  const prfUnsupportedMessage = () => {
+    const isBrave = typeof navigator !== "undefined" && "brave" in navigator;
+    const cause = isBrave ? "Brave doesn't currently support the WebAuthn PRF extension." : "This browser didn't return a passkey PRF secret.";
+    return `${cause} ${config.appName} needs it to seal your key. Your device passkey (Touch ID) is fine, the limitation is the browser. Please open this in Safari or Chrome on an up-to-date OS.`;
+  };
+  async function registerPasskey() {
+    let credential;
+    try {
+      credential = await credentialsApi().create({
+        publicKey: {
+          challenge: randomBytes(32),
+          rp: { name: config.relyingPartyName, id: config.relyingPartyId() },
+          user: await config.passkeyUser(),
+          excludeCredentials: config.knownCredentials(),
+          pubKeyCredParams: [
+            { type: "public-key", alg: -7 },
+            { type: "public-key", alg: -257 }
+          ],
+          authenticatorSelection: {
+            residentKey: "required",
+            userVerification: "required",
+            authenticatorAttachment: "platform"
+          },
+          extensions: { prf: { eval: { first: config.prfSalt } } }
+        }
+      });
+    } catch (err) {
+      if (isPasskeyCancellation(err)) throw new PasskeyCancelledError();
+      throw err;
+    }
+    const prf = credential.getClientExtensionResults().prf;
+    return { credentialId: encodeBase64(credential.rawId), prfFirst: prf?.results?.first ?? null };
+  }
+  async function prfSecret(credentialId) {
+    let assertion;
+    try {
+      assertion = await credentialsApi().get({
+        publicKey: {
+          challenge: randomBytes(32),
+          rpId: config.relyingPartyId(),
+          allowCredentials: [{ type: "public-key", id: decodeBase64(credentialId) }],
+          userVerification: "required",
+          extensions: { prf: { eval: { first: config.prfSalt } } }
+        }
+      });
+    } catch (err) {
+      if (isPasskeyCancellation(err)) throw new PasskeyCancelledError();
+      throw err;
+    }
+    const result = assertion.getClientExtensionResults().prf?.results?.first;
+    if (!result) throw new Error("Passkey PRF unavailable on this device/browser.");
+    return new Uint8Array(result);
+  }
+  async function secretFromRegistration(registration) {
+    if (registration.prfFirst) return new Uint8Array(registration.prfFirst);
+    try {
+      return await prfSecret(registration.credentialId);
+    } catch {
+      throw new Error(prfUnsupportedMessage());
+    }
+  }
+  async function seal(secret, privateKeyHex) {
+    const aes = await deriveAesKey(secret, config.hkdfInfo);
+    const iv = randomBytes(12);
+    const ciphertext = await sealPrivateKey(aes, iv, privateKeyHex);
+    return { iv: encodeBase64(iv), ciphertext: encodeBase64(ciphertext) };
+  }
+  return {
+    async createOwnerKey() {
+      const registration = await registerPasskey();
+      const secret = await secretFromRegistration(registration);
+      const { privateKeyHex, publicKeyHex } = generateStarkKeyPair();
+      const { iv, ciphertext } = await seal(secret, privateKeyHex);
+      return {
+        sealed: {
+          credentialId: registration.credentialId,
+          ownerPubKey: publicKeyHex,
+          address: computeAccountAddress(publicKeyHex, 0),
+          iv,
+          ciphertext
+        },
+        privateKeyHex
+      };
+    },
+    async unlockOwnerKey(sealed) {
+      const secret = await prfSecret(sealed.credentialId);
+      const aes = await deriveAesKey(secret, config.hkdfInfo);
+      return unsealPrivateKey(aes, decodeBase64(sealed.iv), decodeBase64(sealed.ciphertext));
+    },
+    async sealImportedOwnerKey(privateKeyInput) {
+      const { privateKeyHex, publicKeyHex } = starkKeyPairFromPrivateKey(privateKeyInput);
+      const registration = await registerPasskey();
+      const secret = await secretFromRegistration(registration);
+      const { iv, ciphertext } = await seal(secret, privateKeyHex);
+      return {
+        credentialId: registration.credentialId,
+        ownerPubKey: publicKeyHex,
+        address: computeAccountAddress(publicKeyHex, 0),
+        iv,
+        ciphertext
+      };
+    },
+    walletAddressForPrivateKey(privateKeyInput) {
+      return computeAccountAddress(starkKeyPairFromPrivateKey(privateKeyInput).publicKeyHex, 0);
+    }
+  };
+}
+function accountFor(provider, address, privateKeyHex) {
+  return new Account({ provider, address, signer: privateKeyHex, cairoVersion: "1" });
+}
+async function estimateSelfFundedFee(provider, address, calls) {
+  const account = new Account({ provider, address, signer: "0x1", cairoVersion: "1" });
+  const estimate = await account.estimateInvokeFee(calls);
+  return { feeRaw: estimate.overall_fee, unit: estimate.unit };
+}
+function selfFundedExecutor(deps) {
+  return {
+    async execute({ userAddress, privateKeyHex, calls }) {
+      const account = accountFor(deps.provider(), userAddress, privateKeyHex);
+      const { transaction_hash } = await account.execute(calls);
+      return { transactionHash: transaction_hash };
+    }
+  };
+}
+function sponsoredExecutor(deps) {
+  const fallback = deps.fallback ?? selfFundedExecutor(deps);
+  return {
+    async execute(input) {
+      const { userAddress, privateKeyHex, calls } = input;
+      const result = await executeSponsored(
+        { proxyUrl: deps.proxyUrl, fetchImpl: deps.fetchImpl },
+        {
+          address: userAddress,
+          signTypedData: async (data) => signWithPrivateKey(privateKeyHex, typedData.getMessageHash(data, userAddress))
+        },
+        calls
+      );
+      if (result.status === "sponsored") return { transactionHash: result.transactionHash };
+      const consented = await deps.consent.request({ address: userAddress, calls });
+      if (!consented) throw new SponsoredCallRejectedError(result.reason);
+      return fallback.execute(input);
+    }
+  };
+}
+async function describeFailure(res, fallback) {
+  const body = await res.json().catch(() => null);
+  throw new Error(body?.error || fallback);
+}
+async function deploySponsored(input) {
+  const doFetch = input.fetchImpl ?? fetch;
+  const base = input.proxyUrl.replace(/\/$/, "");
+  const buildRes = await doFetch(`${base}/build`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      ownerPubkey: input.ownerPubKey,
+      ownerAddress: input.ownerAddress,
+      salt: input.salt ?? "0x0"
+    })
+  });
+  if (!buildRes.ok) {
+    await describeFailure(buildRes, "We couldn't prepare your wallet deployment. Please try again.");
+  }
+  const { typedData, deployment, calls } = await buildRes.json();
+  const account = new Account({
+    provider: input.provider,
+    address: input.ownerAddress,
+    signer: input.privateKeyHex,
+    cairoVersion: "1"
+  });
+  const signature = stark.signatureToHexArray(await account.signMessage(typedData));
+  const executeRes = await doFetch(`${base}/execute`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ownerAddress: input.ownerAddress, typedData, signature, deployment, calls })
+  });
+  if (!executeRes.ok) {
+    await describeFailure(executeRes, "We couldn't complete your wallet deployment. Please try again.");
+  }
+  const { transactionHash } = await executeRes.json();
+  return { transactionHash };
+}
+async function deploySelfFunded(input) {
+  const classHash = getCoordinates("STARKNET").mediaWalletClassHash;
+  if (!classHash) throw new Error("Media Wallet class hash is not configured");
+  const account = new Account({
+    provider: input.provider,
+    address: input.ownerAddress,
+    signer: input.privateKeyHex,
+    cairoVersion: "1"
+  });
+  const { transaction_hash } = await account.deployAccount({
+    classHash,
+    constructorCalldata: ownerConstructorCalldata(input.ownerPubKey),
+    addressSalt: 0,
+    contractAddress: input.ownerAddress
+  });
+  return { transactionHash: transaction_hash };
+}
+async function completeDeployment(deps, onStep, options = {}) {
+  let sealed = options.forceNew ? null : deps.store.load();
+  let privateKeyHex;
+  if (!sealed) {
+    onStep("creating-passkey");
+    const created = await deps.passkey.createOwnerKey();
+    sealed = created.sealed;
+    privateKeyHex = created.privateKeyHex;
+    deps.store.save(sealed);
+  } else {
+    privateKeyHex = await deps.passkey.unlockOwnerKey(sealed);
+  }
+  onStep("deploying");
+  const wallet = { ownerAddress: sealed.address, ownerPubKey: sealed.ownerPubKey, privateKeyHex };
+  const sponsored = deps.deploySponsoredImpl ?? deploySponsored;
+  const selfFunded = deps.deploySelfFundedImpl ?? deploySelfFunded;
+  if (deps.deployProxyUrl) {
+    try {
+      await sponsored({
+        proxyUrl: deps.deployProxyUrl,
+        provider: deps.provider(),
+        fetchImpl: deps.fetchImpl,
+        ...wallet
+      });
+    } catch (sponsoredErr) {
+      try {
+        await selfFunded({ provider: deps.provider(), ...wallet });
+      } catch (selfFundedErr) {
+        const sponsored2 = sponsoredErr instanceof Error ? sponsoredErr.message : String(sponsoredErr);
+        const selfFunded2 = selfFundedErr instanceof Error ? selfFundedErr.message : String(selfFundedErr);
+        throw new Error(`Sponsored deploy failed: ${sponsored2}. Self-funded fallback failed: ${selfFunded2}`);
+      }
+    }
+  } else {
+    await selfFunded({ provider: deps.provider(), ...wallet });
+  }
+  onStep("signing-in");
+  const address = sealed.address;
+  const siwsToken = await (deps.requestSiwsTokenImpl ?? requestSiwsToken)({
+    backendUrl: deps.backendUrl,
+    walletAddress: address,
+    signer: {
+      signMessage: async (td) => signWithPrivateKey(privateKeyHex, typedData.getMessageHash(td, address))
+    }
+  });
+  deps.store.notifyChange();
+  return { sealed, siwsToken };
+}
+
+// src/wallet/client.ts
+function describeDevices(owners, thisDevicePubkey) {
+  const mine = computeOwnerGuid(thisDevicePubkey);
+  return owners.map((owner) => ({
+    guid: owner.guid,
+    type: owner.type,
+    isThisDevice: BigInt(owner.guid) === BigInt(mine)
+  }));
+}
+function canRemoveDevice(devices, guid) {
+  if (devices.length <= 1) return false;
+  return devices.some((device) => BigInt(device.guid) === BigInt(guid));
+}
+function createMediaWallet(config) {
+  const ttl = config.unlockTtlMs ?? 2e4;
+  const unlockCache = /* @__PURE__ */ new Map();
+  const lock = (address) => {
+    const entry = unlockCache.get(address);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    unlockCache.delete(address);
+  };
+  const unlockOnce = (sealed) => {
+    const existing = unlockCache.get(sealed.address);
+    if (existing) return existing.promise;
+    const promise = config.passkey.unlockOwnerKey(sealed).catch((err) => {
+      lock(sealed.address);
+      throw err;
+    });
+    const timer = setTimeout(() => lock(sealed.address), ttl);
+    unlockCache.set(sealed.address, { promise, timer });
+    return promise;
+  };
+  const run = async (sealed, calls, userAddress) => {
+    const privateKeyHex = await unlockOnce(sealed);
+    return config.executor.execute({
+      userAddress: userAddress ?? sealed.address,
+      privateKeyHex,
+      calls
+    });
+  };
+  return {
+    store: config.store,
+    passkey: config.passkey,
+    lock,
+    signerFor(sealed) {
+      return {
+        address: sealed.address,
+        signTypedData: async (data) => {
+          const privateKeyHex = await unlockOnce(sealed);
+          return signWithPrivateKey(privateKeyHex, typedData.getMessageHash(data, sealed.address));
+        },
+        execute: async (calls) => {
+          const { transactionHash } = await run(sealed, calls);
+          return { txHash: transactionHash };
+        }
+      };
+    },
+    run,
+    getGuardians: (address) => getGuardians(config.provider(), address),
+    getEscape: (address) => getEscape(config.provider(), address),
+    getEscapeSecurityPeriod: (address) => getEscapeSecurityPeriod(config.provider(), address),
+    getOwners: (address) => getOwners(config.provider(), address),
+    async isOwnerOf(accountAddress, devicePubkey) {
+      const owners = await getOwners(config.provider(), accountAddress);
+      const guid = BigInt(computeOwnerGuid(devicePubkey));
+      return owners.some((owner) => BigInt(owner.guid) === guid);
+    },
+    async setFirstGuardian(sealed, guardianPubkey) {
+      const { transactionHash } = await run(sealed, [buildSetFirstGuardianCall(sealed.address, guardianPubkey)]);
+      return transactionHash;
+    },
+    async triggerEscapeOwner(guardianSealed, targetAddress, newOwnerPubkey) {
+      const { transactionHash } = await run(
+        guardianSealed,
+        [buildTriggerEscapeOwnerCall(targetAddress, newOwnerPubkey)],
+        normalizeWalletAddress(targetAddress)
+      );
+      return transactionHash;
+    },
+    async completeEscapeOwner(guardianSealed, targetAddress) {
+      const { transactionHash } = await run(
+        guardianSealed,
+        [buildCompleteEscapeOwnerCall(targetAddress)],
+        normalizeWalletAddress(targetAddress)
+      );
+      return transactionHash;
+    },
+    async cancelEscape(sealed) {
+      const { transactionHash } = await run(sealed, [buildCancelEscapeCall(sealed.address)]);
+      return transactionHash;
+    },
+    async addDevice(sealed, devicePubkey) {
+      const { transactionHash } = await run(sealed, [buildAddOwnerCall(sealed.address, devicePubkey)]);
+      return transactionHash;
+    },
+    async removeDevice(sealed, ownerGuid) {
+      const { transactionHash } = await run(sealed, [buildRemoveOwnerByGuidCall(sealed.address, ownerGuid)]);
+      return transactionHash;
+    },
+    completeDeployment(onStep, options = {}) {
+      if (!config.backendUrl) throw new Error("This wallet has no backend url configured for sign-in");
+      const deps = {
+        store: config.store,
+        passkey: config.passkey,
+        provider: config.provider,
+        backendUrl: config.backendUrl,
+        deployProxyUrl: config.deployProxyUrl,
+        fetchImpl: config.fetchImpl
+      };
+      return completeDeployment(deps, onStep, options);
+    }
+  };
+}
+
+export { ADMIN_HEADERS, ADMIN_SCOPE, MAX_SUPPLY as COIN_MAX_SUPPLY, MIN_SUPPLY as COIN_MIN_SUPPLY, ClubService, CreatorCoinFactoryABI, CreatorCoinService, DropCollectionABI, DropFactoryABI, DropService, ERC1155CollectionService, IPClubCollectionABI, IPClubFactoryABI, IPCollection1155ABI, IPCollection1155FactoryABI, IPCollectionABI, IPGenesisABI, IPMarketplaceABI, IPNftABI, IPSponsorshipABI, IPTicketCollectionABI, IPTicketCollectionFactoryABI, InvalidPairingPayloadError, InvalidStarkPrivateKeyError, MAX_HOLDERS_AT_LAUNCH, MAX_TEAM_ALLOCATION_PERCENT, Medialane1155ABI, MedialaneClient, MedialaneError, POPCollectionABI, POPFactoryABI, PasskeyCancelledError, PopService, SUGGESTED_DEFAULT_PRICE, SponsoredCallRejectedError, SponsorshipService, StarknetVenue, TicketService, VALIDATED_EKUBO_PARAMS, accountFor, adminRequestDigest, assertTransactionSucceeded, build1155CancellationTypedData, build1155OrderTypedData, buildAddOwnerCall, buildAdminSessionTypedData, buildCancelEscapeCall, buildCancellationTypedData, buildChangeOwnersCall, buildCompleteEscapeOwnerCall, buildCreateCreatorCoinCall, buildDeployAccountParams, buildFeeCall, buildLaunchOnEkuboCalls, buildOrderTypedData, buildRemoveOwnerByGuidCall, buildRemoveOwnerCall, buildSetFirstGuardianCall, buildTriggerEscapeOwnerCall, buybackQuoteRaw, canRemoveDevice, toRaw as coinToRaw, completeDeployment, computeAccountAddress, computeOwnerGuid, confirmIntentBestEffort, createAdminSessionGrant, createMediaWallet, createOwnerStore, createPasskeyOwner, createSelfFundConsent, decodeEscapeAndStatus, decodeGuardiansInfo, deploySelfFunded, deploySponsored, deployedCollectionFromReceipt, deriveAesKey, deriveOwnerKeyPair, describeDevices, describeGuardianStatus, describeRecoveryAction, encodeAdminHeaders, encodeByteArray, encodePairingPayload, estimateSelfFundedFee, executeIntent, executeIntents, executeSponsored, fdvHuman, generateStarkKeyPair, getCounter, getCounter1155, getCreatorCoinGuarantees, getEscape, getEscapeSecurityPeriod, getGuardians, getOrderDetails, getOrderDetails1155, getOwners, getSiwsStorageKey, getStoredSiwsToken, isDeployed, isRecoveryKeyForWallet, isSiwsTokenValid, isValidStarknetAddress, mintedTokenIdFromReceipt, normalizeSiwsSignature, normalizeWalletAddress, ownerAliveTypedData, ownerConstructorCalldata, parseAccountAddress, parseAdminHeaders, parseCreatorCoinCreated, parsePairingPayload, priceToEkuboParams, randomNonce, requestSiwsToken, sealPrivateKey, selfFundedExecutor, sessionKeyHashOf, signAdminRequest, signWithPrivateKey, sponsoredExecutor, starkKeyPairFromPrivateKey, storeSiwsToken, syncTransactionBestEffort, teamCoinsRaw, toContractConditions as toDropContractConditions, unsealPrivateKey, userMayPayInstead, validateName as validateCoinName, validateSupply as validateCoinSupply, validateSymbol as validateCoinSymbol, validatePrice, verifyAdminRequestSig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map