@medialane/sdk 0.120.0 → 0.122.0

package/dist/starknet/index.cjs

@@ -12329,6 +12329,548 @@ function signWithPrivateKey(privateKeyHex, msgHash) {
   return [starknet.num.toHex(sig.r), starknet.num.toHex(sig.s)];
 }
 
+// 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 {
+    starknet.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 starknet.Account({ provider, address, signer: privateKeyHex, cairoVersion: "1" });
+}
+async function estimateSelfFundedFee(provider, address, calls) {
+  const account = new starknet.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, starknet.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 starknet.Account({
+    provider: input.provider,
+    address: input.ownerAddress,
+    signer: input.privateKeyHex,
+    cairoVersion: "1"
+  });
+  const signature = starknet.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 starknet.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, starknet.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, starknet.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);
+    }
+  };
+}
+
 exports.ADMIN_HEADERS = ADMIN_HEADERS;
 exports.ADMIN_SCOPE = ADMIN_SCOPE;
 exports.COIN_MAX_SUPPLY = MAX_SUPPLY;
@@ -12351,6 +12893,7 @@ exports.IPNftABI = IPNftABI;
 exports.IPSponsorshipABI = IPSponsorshipABI;
 exports.IPTicketCollectionABI = IPTicketCollectionABI;
 exports.IPTicketCollectionFactoryABI = IPTicketCollectionFactoryABI;
+exports.InvalidPairingPayloadError = InvalidPairingPayloadError;
 exports.InvalidStarkPrivateKeyError = InvalidStarkPrivateKeyError;
 exports.MAX_HOLDERS_AT_LAUNCH = MAX_HOLDERS_AT_LAUNCH;
 exports.MAX_TEAM_ALLOCATION_PERCENT = MAX_TEAM_ALLOCATION_PERCENT;
@@ -12359,6 +12902,7 @@ exports.MedialaneClient = MedialaneClient;
 exports.MedialaneError = MedialaneError;
 exports.POPCollectionABI = POPCollectionABI;
 exports.POPFactoryABI = POPFactoryABI;
+exports.PasskeyCancelledError = PasskeyCancelledError;
 exports.PopService = PopService;
 exports.SUGGESTED_DEFAULT_PRICE = SUGGESTED_DEFAULT_PRICE;
 exports.SponsoredCallRejectedError = SponsoredCallRejectedError;
@@ -12366,6 +12910,7 @@ exports.SponsorshipService = SponsorshipService;
 exports.StarknetVenue = StarknetVenue;
 exports.TicketService = TicketService;
 exports.VALIDATED_EKUBO_PARAMS = VALIDATED_EKUBO_PARAMS;
+exports.accountFor = accountFor;
 exports.adminRequestDigest = adminRequestDigest;
 exports.assertTransactionSucceeded = assertTransactionSucceeded;
 exports.build1155CancellationTypedData = build1155CancellationTypedData;
@@ -12386,18 +12931,31 @@ exports.buildRemoveOwnerCall = buildRemoveOwnerCall;
 exports.buildSetFirstGuardianCall = buildSetFirstGuardianCall;
 exports.buildTriggerEscapeOwnerCall = buildTriggerEscapeOwnerCall;
 exports.buybackQuoteRaw = buybackQuoteRaw;
+exports.canRemoveDevice = canRemoveDevice;
 exports.coinToRaw = toRaw;
+exports.completeDeployment = completeDeployment;
 exports.computeAccountAddress = computeAccountAddress;
 exports.computeOwnerGuid = computeOwnerGuid;
 exports.confirmIntentBestEffort = confirmIntentBestEffort;
 exports.createAdminSessionGrant = createAdminSessionGrant;
+exports.createMediaWallet = createMediaWallet;
+exports.createOwnerStore = createOwnerStore;
+exports.createPasskeyOwner = createPasskeyOwner;
+exports.createSelfFundConsent = createSelfFundConsent;
 exports.decodeEscapeAndStatus = decodeEscapeAndStatus;
 exports.decodeGuardiansInfo = decodeGuardiansInfo;
+exports.deploySelfFunded = deploySelfFunded;
+exports.deploySponsored = deploySponsored;
 exports.deployedCollectionFromReceipt = deployedCollectionFromReceipt;
 exports.deriveAesKey = deriveAesKey;
 exports.deriveOwnerKeyPair = deriveOwnerKeyPair;
+exports.describeDevices = describeDevices;
+exports.describeGuardianStatus = describeGuardianStatus;
+exports.describeRecoveryAction = describeRecoveryAction;
 exports.encodeAdminHeaders = encodeAdminHeaders;
 exports.encodeByteArray = encodeByteArray;
+exports.encodePairingPayload = encodePairingPayload;
+exports.estimateSelfFundedFee = estimateSelfFundedFee;
 exports.executeIntent = executeIntent;
 exports.executeIntents = executeIntents;
 exports.executeSponsored = executeSponsored;
@@ -12414,20 +12972,28 @@ exports.getOrderDetails1155 = getOrderDetails1155;
 exports.getOwners = getOwners;
 exports.getSiwsStorageKey = getSiwsStorageKey;
 exports.getStoredSiwsToken = getStoredSiwsToken;
+exports.isDeployed = isDeployed;
+exports.isRecoveryKeyForWallet = isRecoveryKeyForWallet;
 exports.isSiwsTokenValid = isSiwsTokenValid;
+exports.isValidStarknetAddress = isValidStarknetAddress;
 exports.mintedTokenIdFromReceipt = mintedTokenIdFromReceipt;
 exports.normalizeSiwsSignature = normalizeSiwsSignature;
+exports.normalizeWalletAddress = normalizeWalletAddress;
 exports.ownerAliveTypedData = ownerAliveTypedData;
 exports.ownerConstructorCalldata = ownerConstructorCalldata;
+exports.parseAccountAddress = parseAccountAddress;
 exports.parseAdminHeaders = parseAdminHeaders;
 exports.parseCreatorCoinCreated = parseCreatorCoinCreated;
+exports.parsePairingPayload = parsePairingPayload;
 exports.priceToEkuboParams = priceToEkuboParams;
 exports.randomNonce = randomNonce;
 exports.requestSiwsToken = requestSiwsToken;
 exports.sealPrivateKey = sealPrivateKey;
+exports.selfFundedExecutor = selfFundedExecutor;
 exports.sessionKeyHashOf = sessionKeyHashOf;
 exports.signAdminRequest = signAdminRequest;
 exports.signWithPrivateKey = signWithPrivateKey;
+exports.sponsoredExecutor = sponsoredExecutor;
 exports.starkKeyPairFromPrivateKey = starkKeyPairFromPrivateKey;
 exports.storeSiwsToken = storeSiwsToken;
 exports.syncTransactionBestEffort = syncTransactionBestEffort;