@unicitylabs/sphere-sdk 0.17.2-dev.1 → 0.17.2-dev.3

package/dist/connect/index.cjs

@@ -43,6 +43,8 @@ __export(connect_exports, {
   hasMethodPermission: () => hasMethodPermission,
   isAutoPushedEvent: () => isAutoPushedEvent,
   isSphereConnectMessage: () => isSphereConnectMessage,
+  nftContentFromWire: () => nftContentFromWire,
+  nftContentToWire: () => nftContentToWire,
   validatePermissions: () => validatePermissions
 });
 module.exports = __toCommonJS(connect_exports);
@@ -291,7 +293,7 @@ var HOST_READY_TIMEOUT = 3e4;
 
 // connect/protocol.ts
 var SPHERE_CONNECT_NAMESPACE = "sphere-connect";
-var SPHERE_CONNECT_VERSION = "2.2";
+var SPHERE_CONNECT_VERSION = "2.3";
 var DEFAULT_MIN_CLIENT_SDK_VERSION = "0.14.1-0";
 var RPC_METHODS = {
   GET_IDENTITY: "sphere_getIdentity",
@@ -318,7 +320,9 @@ var INTENT_ACTIONS = {
   MINT: "mint",
   // #777: params { to, tokenId, memo? }. Named NFT rather than 'send_token':
   // coins are tokens too, so 'token' does not say which kind moves.
-  SEND_NFT: "send_nft"
+  SEND_NFT: "send_nft",
+  // Connect 2.3: params MintNftIntentParams, result MintNftIntentResult (connect/nft-wire.ts).
+  MINT_NFT: "mint_nft"
 };
 var ERROR_CODES = {
   // Standard JSON-RPC
@@ -452,7 +456,7 @@ function checkCompatibility(input) {
 }
 
 // connect/version.ts
-var SDK_VERSION = "0.17.2-dev.1";
+var SDK_VERSION = "0.17.2-dev.3";
 
 // connect/permissions.ts
 var PERMISSION_SCOPES = {
@@ -470,7 +474,9 @@ var PERMISSION_SCOPES = {
   SIGN_REQUEST: "sign:request",
   MINT_REQUEST: "mint:request",
   /** #777: moving a coinless token (an NFT). Distinct from transfer:request. */
-  NFT_TRANSFER: "nft:transfer"
+  NFT_TRANSFER: "nft:transfer",
+  /** Minting an NFT signs dApp-chosen content as the user; mint:request and nft:transfer do not imply it. */
+  NFT_MINT: "nft:mint"
 };
 var ALL_PERMISSIONS = Object.values(PERMISSION_SCOPES);
 var DEFAULT_PERMISSIONS = [
@@ -498,7 +504,8 @@ var INTENT_PERMISSIONS = {
   [INTENT_ACTIONS.RECEIVE]: PERMISSION_SCOPES.IDENTITY_READ,
   [INTENT_ACTIONS.SIGN_MESSAGE]: PERMISSION_SCOPES.SIGN_REQUEST,
   [INTENT_ACTIONS.MINT]: PERMISSION_SCOPES.MINT_REQUEST,
-  [INTENT_ACTIONS.SEND_NFT]: PERMISSION_SCOPES.NFT_TRANSFER
+  [INTENT_ACTIONS.SEND_NFT]: PERMISSION_SCOPES.NFT_TRANSFER,
+  [INTENT_ACTIONS.MINT_NFT]: PERMISSION_SCOPES.NFT_MINT
 };
 function hasMethodPermission(granted, method) {
   const required = METHOD_PERMISSIONS[method];
@@ -778,6 +785,7 @@ var CHANNEL_ONLY_CODES = /* @__PURE__ */ new Set([
   ERROR_CODES.WALLET_LOCKED,
   ERROR_CODES.NOT_CONNECTED
 ]);
+var ALWAYS_ASK_INTENTS = /* @__PURE__ */ new Set([INTENT_ACTIONS.MINT_NFT]);
 var DEFAULT_REQUEST_DEADLINE_MS = 25e3;
 var DEFAULT_INTENT_DEADLINE_MS = 18e4;
 var DEFAULT_HANDSHAKE_DEADLINE_MS = 12e4;
@@ -863,8 +871,11 @@ var ConnectHost = class {
   getSession() {
     return this.session;
   }
-  /** Register an auto-approve handler for an intent action (session-scoped). */
+  /** Register an auto-approve handler for an intent action (session-scoped). Throws for an intent that always asks the user. */
   setIntentAutoApprove(action, handler) {
+    if (ALWAYS_ASK_INTENTS.has(action)) {
+      throw new SphereError(`Intent ${action} always asks the user and cannot be auto-approved`, "INVALID_CONFIG");
+    }
     this.autoApprovedIntents.set(action, handler);
   }
   /** Remove auto-approve for an intent action. */
@@ -1353,7 +1364,7 @@ var ConnectHost = class {
       signal: entry.controller.signal
     };
     try {
-      const autoHandler = this.autoApprovedIntents.get(msg.action);
+      const autoHandler = ALWAYS_ASK_INTENTS.has(msg.action) ? void 0 : this.autoApprovedIntents.get(msg.action);
       const response = autoHandler ? await autoHandler(msg.action, msg.params, session) : await this.config.onIntent(msg.action, msg.params, session, ctx);
       if (!this.inFlight.settle(msg.id)) return;
       if (response.error) {
@@ -1367,7 +1378,8 @@ var ConnectHost = class {
         this.sendIntentError(
           msg.id,
           asserts ? ERROR_CODES.INTENT_OUTCOME_UNKNOWN : response.error.code,
-          asserts ? INTENT_UNKNOWN_MESSAGE : response.error.message
+          asserts ? INTENT_UNKNOWN_MESSAGE : response.error.message,
+          asserts ? void 0 : response.error.data
         );
       } else {
         this.sendIntentResult(msg.id, response.result);
@@ -2050,4 +2062,186 @@ var ConnectClient = class {
     this.locked = false;
   }
 };
+
+// core/base64.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var INVALID = 255;
+var SEXTETS = new Uint8Array(128).fill(INVALID);
+for (let i = 0; i < ALPHABET.length; i++) SEXTETS[ALPHABET.charCodeAt(i)] = i;
+function base64Encode(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    const triple = bytes[i] << 16 | b1 << 8 | b2;
+    out += ALPHABET[triple >> 18] + ALPHABET[triple >> 12 & 63];
+    out += i + 1 < bytes.length ? ALPHABET[triple >> 6 & 63] : "=";
+    out += i + 2 < bytes.length ? ALPHABET[triple & 63] : "=";
+  }
+  return out;
+}
+function base64DecodeCanonical(text) {
+  if (text.length % 4 !== 0) return null;
+  const padding = text.endsWith("==") ? 2 : text.endsWith("=") ? 1 : 0;
+  const out = new Uint8Array(text.length / 4 * 3 - padding);
+  let buffer = 0;
+  let bits = 0;
+  let offset = 0;
+  for (let i = 0; i < text.length - padding; i++) {
+    const code = text.charCodeAt(i);
+    const sextet = code < SEXTETS.length ? SEXTETS[code] : INVALID;
+    if (sextet === INVALID) return null;
+    buffer = (buffer << 6 | sextet) & 4095;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[offset++] = buffer >> bits;
+    }
+  }
+  return (buffer & (1 << bits) - 1) === 0 ? out : null;
+}
+
+// connect/nft-wire.ts
+var METADATA_FIELDS = [
+  "kind",
+  "name",
+  "description",
+  "image",
+  "animation_url",
+  "external_url",
+  "attributes",
+  "collection",
+  "collection_id"
+];
+var MEDIA_FIELDS = ["kind", "media_type", "bytes"];
+var LINK_FIELDS = ["kind", "media_type", "uri", "sha256"];
+var ATTRIBUTE_FIELDS = ["trait_type", "value"];
+var CONTENT_KINDS = "must be 'metadata', 'media' or 'link'";
+var MEDIA_REF_KINDS = "must be 'media' or 'link'";
+function refuse(field, rule) {
+  return new SphereError(`Invalid NFT ${field}: ${rule}`, "VALIDATION_ERROR");
+}
+function mediaToWire(media, field) {
+  if (!(media.bytes instanceof Uint8Array)) throw refuse(`${field}.bytes`, "must be a Uint8Array");
+  return { kind: "media", media_type: media.media_type, bytes: base64Encode(media.bytes) };
+}
+function linkToWire(link) {
+  return { kind: "link", media_type: link.media_type, uri: link.uri, sha256: link.sha256 };
+}
+function mediaRefToWire(ref, field) {
+  if (ref === null) return null;
+  if (ref?.kind === "media") return mediaToWire(ref, field);
+  if (ref?.kind === "link") return linkToWire(ref);
+  throw refuse(`${field}.kind`, MEDIA_REF_KINDS);
+}
+function metadataToWire(metadata) {
+  return {
+    kind: "metadata",
+    name: metadata.name,
+    description: metadata.description,
+    image: mediaRefToWire(metadata.image, "content.image"),
+    animation_url: mediaRefToWire(metadata.animation_url, "content.animation_url"),
+    external_url: metadata.external_url,
+    attributes: metadata.attributes.map(({ trait_type, value }) => ({ trait_type, value })),
+    collection: metadata.collection,
+    collection_id: metadata.collection_id
+  };
+}
+function nftContentToWire(content) {
+  switch (content?.kind) {
+    case "metadata":
+      return metadataToWire(content);
+    case "media":
+      return mediaToWire(content, "content");
+    case "link":
+      return linkToWire(content);
+    default:
+      throw refuse("content.kind", CONTENT_KINDS);
+  }
+}
+function recordAt(value, field, rule = "must be an object") {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw refuse(field, rule);
+  return value;
+}
+function requireExactFields(record, field, fields) {
+  const missing = fields.find((name) => !Object.prototype.hasOwnProperty.call(record, name));
+  if (missing !== void 0) throw refuse(`${field}.${missing}`, "is missing \u2014 an absent optional field is null");
+  const extra = Object.keys(record).find((name) => !fields.includes(name));
+  if (extra !== void 0) throw refuse(`${field}.${extra}`, "is not a field of this item");
+}
+function stringAt(record, field, name) {
+  const value = record[name];
+  if (typeof value !== "string") throw refuse(`${field}.${name}`, "must be a string");
+  return value;
+}
+function optionalStringAt(record, field, name) {
+  const value = record[name];
+  if (value === null) return null;
+  if (typeof value !== "string") throw refuse(`${field}.${name}`, "must be a string or null");
+  return value;
+}
+function mediaFromWire(record, field) {
+  requireExactFields(record, field, MEDIA_FIELDS);
+  const mediaType = stringAt(record, field, "media_type");
+  const bytes = base64DecodeCanonical(stringAt(record, field, "bytes"));
+  if (bytes === null) throw refuse(`${field}.bytes`, "must be canonical standard base64 with padding (RFC 4648 \xA74)");
+  return { kind: "media", media_type: mediaType, bytes };
+}
+function linkFromWire(record, field) {
+  requireExactFields(record, field, LINK_FIELDS);
+  return {
+    kind: "link",
+    media_type: stringAt(record, field, "media_type"),
+    uri: stringAt(record, field, "uri"),
+    sha256: stringAt(record, field, "sha256")
+  };
+}
+function mediaRefFromWire(value, field) {
+  if (value === null) return null;
+  const record = recordAt(value, field, "must be a media or link object, or null");
+  if (record.kind === "media") return mediaFromWire(record, field);
+  if (record.kind === "link") return linkFromWire(record, field);
+  throw refuse(`${field}.kind`, MEDIA_REF_KINDS);
+}
+function attributeFromWire(value, field) {
+  const record = recordAt(value, field);
+  requireExactFields(record, field, ATTRIBUTE_FIELDS);
+  const traitType = stringAt(record, field, "trait_type");
+  const attributeValue = record.value;
+  if (typeof attributeValue !== "string" && typeof attributeValue !== "number") {
+    throw refuse(`${field}.value`, "must be a string or a number");
+  }
+  return { trait_type: traitType, value: attributeValue };
+}
+function attributesFromWire(value, field) {
+  if (!Array.isArray(value)) throw refuse(field, "must be an array \u2014 [] when there are none");
+  return Array.from(value, (entry, index) => attributeFromWire(entry, `${field}[${index}]`));
+}
+function metadataFromWire(record) {
+  requireExactFields(record, "content", METADATA_FIELDS);
+  return {
+    kind: "metadata",
+    name: stringAt(record, "content", "name"),
+    description: optionalStringAt(record, "content", "description"),
+    image: mediaRefFromWire(record.image, "content.image"),
+    animation_url: mediaRefFromWire(record.animation_url, "content.animation_url"),
+    external_url: optionalStringAt(record, "content", "external_url"),
+    attributes: attributesFromWire(record.attributes, "content.attributes"),
+    collection: optionalStringAt(record, "content", "collection"),
+    collection_id: optionalStringAt(record, "content", "collection_id")
+  };
+}
+function nftContentFromWire(wire) {
+  const record = recordAt(wire, "content");
+  switch (record.kind) {
+    case "metadata":
+      return metadataFromWire(record);
+    case "media":
+      return mediaFromWire(record, "content");
+    case "link":
+      return linkFromWire(record, "content");
+    default:
+      throw refuse("content.kind", CONTENT_KINDS);
+  }
+}
 //# sourceMappingURL=index.cjs.map