@metamask-previews/kyc-controller 0.0.0-preview-e57e5c3dc → 0.0.0-preview-c449b8da8

package/dist/ukyc/wrapEncryptionKey.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrapEncryptionKey.d.mts","sourceRoot":"","sources":["../../src/ukyc/wrapEncryptionKey.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,uBAAuB,EAAE,UAAU,EACnC,sBAAsB,EAAE,MAAM,EAC9B,SAAS,EAAE,UAAU,GACpB,yBAAyB,CAa3B"}

package/dist/ukyc/wrapEncryptionKey.mjs

@@ -1,25 +0,0 @@
-import $tweetnacl from "tweetnacl";
-const { randomBytes, box } = $tweetnacl;
-import { base64UrlToBytes, toBase64Url } from "../encoding.mjs";
-/**
- * Wraps `keyToWrap` for the UKYC session server.
- *
- * The box is sealed with NaCl's `crypto_box`, keyed by the X25519 shared secret
- * between our session client private key and the session server public key
- * returned by `getWrappingKey`.
- *
- * @param sessionClientPrivateKey - Our session's X25519 private key.
- * @param sessionServerPublicKey - The server's X25519 public key (base64url).
- * @param keyToWrap - The raw symmetric key bytes to encrypt.
- * @returns The base64url `encryptedKey` (ciphertext + tag) and `nonce`.
- */
-export function wrapEncryptionKey(sessionClientPrivateKey, sessionServerPublicKey, keyToWrap) {
-    const serverPublicKey = base64UrlToBytes(sessionServerPublicKey);
-    const nonce = randomBytes(box.nonceLength);
-    const encryptedKey = box(keyToWrap, nonce, serverPublicKey, sessionClientPrivateKey);
-    return {
-        encryptedKey: toBase64Url(encryptedKey),
-        nonce: toBase64Url(nonce),
-    };
-}
-//# sourceMappingURL=wrapEncryptionKey.mjs.map

package/dist/ukyc/wrapEncryptionKey.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrapEncryptionKey.mjs","sourceRoot":"","sources":["../../src/ukyc/wrapEncryptionKey.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,wBAAuB;AAwB/D;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAC/B,uBAAmC,EACnC,sBAA8B,EAC9B,SAAqB;IAErB,MAAM,eAAe,GAAG,gBAAgB,CAAC,sBAAsB,CAAC,CAAC;IACjE,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC3C,MAAM,YAAY,GAAG,GAAG,CACtB,SAAS,EACT,KAAK,EACL,eAAe,EACf,uBAAuB,CACxB,CAAC;IACF,OAAO;QACL,YAAY,EAAE,WAAW,CAAC,YAAY,CAAC;QACvC,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC;KAC1B,CAAC;AACJ,CAAC","sourcesContent":["import { randomBytes, box } from 'tweetnacl';\n\nimport { base64UrlToBytes, toBase64Url } from '../encoding.js';\n\n/**\n * Wraps the `data_encryption_key` for the UKYC session server using NaCl's\n * `crypto_box` (X25519 + XSalsa20-Poly1305) established with the server's\n * per-session wrapping key.\n *\n * Unlike {@link wrapUserKey} (which generates a fresh ephemeral keypair per\n * call), this uses the session client keypair whose public half was already\n * handed to the server via `POST /wrapping-key`. The server therefore already\n * knows our public key and can derive the same shared secret from its session\n * private key, so only `{ encryptedKey, nonce }` need be transmitted.\n */\n\n/**\n * The transmitted portion of a wrapped encryption key: the `crypto_box`\n * ciphertext (which includes the 16-byte Poly1305 auth tag) and the nonce,\n * both unpadded base64url-encoded.\n */\nexport type WrappedEncryptionKeyParts = {\n  encryptedKey: string;\n  nonce: string;\n};\n\n/**\n * Wraps `keyToWrap` for the UKYC session server.\n *\n * The box is sealed with NaCl's `crypto_box`, keyed by the X25519 shared secret\n * between our session client private key and the session server public key\n * returned by `getWrappingKey`.\n *\n * @param sessionClientPrivateKey - Our session's X25519 private key.\n * @param sessionServerPublicKey - The server's X25519 public key (base64url).\n * @param keyToWrap - The raw symmetric key bytes to encrypt.\n * @returns The base64url `encryptedKey` (ciphertext + tag) and `nonce`.\n */\nexport function wrapEncryptionKey(\n  sessionClientPrivateKey: Uint8Array,\n  sessionServerPublicKey: string,\n  keyToWrap: Uint8Array,\n): WrappedEncryptionKeyParts {\n  const serverPublicKey = base64UrlToBytes(sessionServerPublicKey);\n  const nonce = randomBytes(box.nonceLength);\n  const encryptedKey = box(\n    keyToWrap,\n    nonce,\n    serverPublicKey,\n    sessionClientPrivateKey,\n  );\n  return {\n    encryptedKey: toBase64Url(encryptedKey),\n    nonce: toBase64Url(nonce),\n  };\n}\n"]}

package/dist/ukyc/wrapUserKey.cjs

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapUserKey = void 0;
-const utils_1 = require("@metamask/utils");
-const aes_1 = require("@noble/ciphers/aes");
-const ed25519_1 = require("@noble/curves/ed25519");
-const hkdf_1 = require("@noble/hashes/hkdf");
-const sha2_1 = require("@noble/hashes/sha2");
-const utils_2 = require("@noble/hashes/utils");
-const encoding_js_1 = require("../encoding.cjs");
-/**
- * Wraps (encrypts) a symmetric key so that only the holder of a given X25519
- * private key can recover it — used to seal the `data_encryption_key` for the
- * idOS Relay before it is handed to the UKYC API as `wrappedUserKey`.
- */
-/** X25519 public/private keys and AES-256-GCM keys are all 32 bytes. */
-const X25519_KEY_SIZE_BYTES = 32;
-/** 96-bit IV, the AES-GCM standard nonce size. */
-const IV_SIZE_BYTES = 12;
-/**
- * Decodes an X25519 public key presented as either hex or base64/base64url.
- *
- * @param recipientPublicKey - The recipient's 32-byte X25519 public key.
- * @returns The raw 32-byte public key.
- */
-function decodePublicKey(recipientPublicKey) {
-    const isHex = recipientPublicKey.length === X25519_KEY_SIZE_BYTES * 2 &&
-        /^[0-9a-fA-F]+$/u.test(recipientPublicKey);
-    const bytes = isHex
-        ? (0, utils_2.hexToBytes)(recipientPublicKey)
-        : (0, utils_1.base64ToBytes)(recipientPublicKey
-            .replace(/-/gu, '+')
-            .replace(/_/gu, '/')
-            .padEnd(recipientPublicKey.length +
-            ((4 - (recipientPublicKey.length % 4)) % 4), '='));
-    if (bytes.length !== X25519_KEY_SIZE_BYTES) {
-        throw new Error(`UKYC: wrappingPublicKey has unexpected length ${bytes.length}, expected ${X25519_KEY_SIZE_BYTES}.`);
-    }
-    return bytes;
-}
-/**
- * Wraps `keyToWrap` for the holder of `recipientPublicKey` using an
- * ephemeral-static ECDH + AES-256-GCM sealed-box scheme:
- *
- *   ephemeral = fresh X25519 keypair (one per call)
- *   shared    = X25519(ephemeralPrivate, recipientPublic)
- *   aeadKey   = HKDF-SHA256(shared, 32 bytes)
- *   iv        = 12 random bytes
- *   ct        = AES-256-GCM(aeadKey, iv).encrypt(keyToWrap)   // ct includes tag
- *
- * The recipient reverses it with their private key:
- *
- *   shared  = X25519(recipientPrivate, ephemeralPublic)
- *   aeadKey = HKDF-SHA256(shared, 32 bytes)
- *   key     = AES-256-GCM(aeadKey, iv).decrypt(ct)
- *
- * This mirrors the X25519 + AES-256-GCM/HKDF decryption used for MoonPay
- * Check/Auth-frame credentials, so both directions share one primitive.
- *
- * @param recipientPublicKey - The recipient's X25519 public key (hex or base64).
- * @param keyToWrap - The raw symmetric key bytes to encrypt (e.g. the
- * `data_encryption_key`).
- * @returns Base64url of `ephemeralPublicKey(32) || iv(12) || ciphertext+tag`.
- */
-function wrapUserKey(recipientPublicKey, keyToWrap) {
-    const recipient = decodePublicKey(recipientPublicKey);
-    const ephemeralPrivateKey = ed25519_1.x25519.utils.randomSecretKey();
-    const ephemeralPublicKey = ed25519_1.x25519.getPublicKey(ephemeralPrivateKey);
-    const shared = ed25519_1.x25519.getSharedSecret(ephemeralPrivateKey, recipient);
-    const aeadKey = (0, hkdf_1.hkdf)(sha2_1.sha256, shared, undefined, undefined, 32);
-    const iv = (0, utils_2.randomBytes)(IV_SIZE_BYTES);
-    const ciphertext = (0, aes_1.gcm)(aeadKey, iv).encrypt(keyToWrap);
-    const blob = new Uint8Array(ephemeralPublicKey.length + iv.length + ciphertext.length);
-    blob.set(ephemeralPublicKey, 0);
-    blob.set(iv, ephemeralPublicKey.length);
-    blob.set(ciphertext, ephemeralPublicKey.length + iv.length);
-    return (0, encoding_js_1.toBase64Url)(blob);
-}
-exports.wrapUserKey = wrapUserKey;
-//# sourceMappingURL=wrapUserKey.cjs.map

package/dist/ukyc/wrapUserKey.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrapUserKey.cjs","sourceRoot":"","sources":["../../src/ukyc/wrapUserKey.ts"],"names":[],"mappings":";;;AAAA,2CAAgD;AAChD,4CAAyC;AACzC,mDAA+C;AAC/C,6CAA0C;AAC1C,6CAA4C;AAC5C,+CAA8D;AAE9D,iDAA6C;AAE7C;;;;GAIG;AAEH,wEAAwE;AACxE,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAEjC,kDAAkD;AAClD,MAAM,aAAa,GAAG,EAAE,CAAC;AAEzB;;;;;GAKG;AACH,SAAS,eAAe,CAAC,kBAA0B;IACjD,MAAM,KAAK,GACT,kBAAkB,CAAC,MAAM,KAAK,qBAAqB,GAAG,CAAC;QACvD,iBAAiB,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAE7C,MAAM,KAAK,GAAG,KAAK;QACjB,CAAC,CAAC,IAAA,kBAAU,EAAC,kBAAkB,CAAC;QAChC,CAAC,CAAC,IAAA,qBAAa,EACX,kBAAkB;aACf,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;aACnB,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;aACnB,MAAM,CACL,kBAAkB,CAAC,MAAM;YACvB,CAAC,CAAC,CAAC,GAAG,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAC7C,GAAG,CACJ,CACJ,CAAC;IAEN,IAAI,KAAK,CAAC,MAAM,KAAK,qBAAqB,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CACb,iDAAiD,KAAK,CAAC,MAAM,cAAc,qBAAqB,GAAG,CACpG,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,SAAgB,WAAW,CACzB,kBAA0B,EAC1B,SAAqB;IAErB,MAAM,SAAS,GAAG,eAAe,CAAC,kBAAkB,CAAC,CAAC;IAEtD,MAAM,mBAAmB,GAAG,gBAAM,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC;IAC3D,MAAM,kBAAkB,GAAG,gBAAM,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC;IAEpE,MAAM,MAAM,GAAG,gBAAM,CAAC,eAAe,CAAC,mBAAmB,EAAE,SAAS,CAAC,CAAC;IACtE,MAAM,OAAO,GAAG,IAAA,WAAI,EAAC,aAAM,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;IAE/D,MAAM,EAAE,GAAG,IAAA,mBAAW,EAAC,aAAa,CAAC,CAAC;IACtC,MAAM,UAAU,GAAG,IAAA,SAAG,EAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAEvD,MAAM,IAAI,GAAG,IAAI,UAAU,CACzB,kBAAkB,CAAC,MAAM,GAAG,EAAE,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAC1D,CAAC;IACF,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC;IAChC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACxC,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC;IAE5D,OAAO,IAAA,yBAAW,EAAC,IAAI,CAAC,CAAC;AAC3B,CAAC;AAvBD,kCAuBC","sourcesContent":["import { base64ToBytes } from '@metamask/utils';\nimport { gcm } from '@noble/ciphers/aes';\nimport { x25519 } from '@noble/curves/ed25519';\nimport { hkdf } from '@noble/hashes/hkdf';\nimport { sha256 } from '@noble/hashes/sha2';\nimport { hexToBytes, randomBytes } from '@noble/hashes/utils';\n\nimport { toBase64Url } from '../encoding.js';\n\n/**\n * Wraps (encrypts) a symmetric key so that only the holder of a given X25519\n * private key can recover it — used to seal the `data_encryption_key` for the\n * idOS Relay before it is handed to the UKYC API as `wrappedUserKey`.\n */\n\n/** X25519 public/private keys and AES-256-GCM keys are all 32 bytes. */\nconst X25519_KEY_SIZE_BYTES = 32;\n\n/** 96-bit IV, the AES-GCM standard nonce size. */\nconst IV_SIZE_BYTES = 12;\n\n/**\n * Decodes an X25519 public key presented as either hex or base64/base64url.\n *\n * @param recipientPublicKey - The recipient's 32-byte X25519 public key.\n * @returns The raw 32-byte public key.\n */\nfunction decodePublicKey(recipientPublicKey: string): Uint8Array {\n  const isHex =\n    recipientPublicKey.length === X25519_KEY_SIZE_BYTES * 2 &&\n    /^[0-9a-fA-F]+$/u.test(recipientPublicKey);\n\n  const bytes = isHex\n    ? hexToBytes(recipientPublicKey)\n    : base64ToBytes(\n        recipientPublicKey\n          .replace(/-/gu, '+')\n          .replace(/_/gu, '/')\n          .padEnd(\n            recipientPublicKey.length +\n              ((4 - (recipientPublicKey.length % 4)) % 4),\n            '=',\n          ),\n      );\n\n  if (bytes.length !== X25519_KEY_SIZE_BYTES) {\n    throw new Error(\n      `UKYC: wrappingPublicKey has unexpected length ${bytes.length}, expected ${X25519_KEY_SIZE_BYTES}.`,\n    );\n  }\n  return bytes;\n}\n\n/**\n * Wraps `keyToWrap` for the holder of `recipientPublicKey` using an\n * ephemeral-static ECDH + AES-256-GCM sealed-box scheme:\n *\n *   ephemeral = fresh X25519 keypair (one per call)\n *   shared    = X25519(ephemeralPrivate, recipientPublic)\n *   aeadKey   = HKDF-SHA256(shared, 32 bytes)\n *   iv        = 12 random bytes\n *   ct        = AES-256-GCM(aeadKey, iv).encrypt(keyToWrap)   // ct includes tag\n *\n * The recipient reverses it with their private key:\n *\n *   shared  = X25519(recipientPrivate, ephemeralPublic)\n *   aeadKey = HKDF-SHA256(shared, 32 bytes)\n *   key     = AES-256-GCM(aeadKey, iv).decrypt(ct)\n *\n * This mirrors the X25519 + AES-256-GCM/HKDF decryption used for MoonPay\n * Check/Auth-frame credentials, so both directions share one primitive.\n *\n * @param recipientPublicKey - The recipient's X25519 public key (hex or base64).\n * @param keyToWrap - The raw symmetric key bytes to encrypt (e.g. the\n * `data_encryption_key`).\n * @returns Base64url of `ephemeralPublicKey(32) || iv(12) || ciphertext+tag`.\n */\nexport function wrapUserKey(\n  recipientPublicKey: string,\n  keyToWrap: Uint8Array,\n): string {\n  const recipient = decodePublicKey(recipientPublicKey);\n\n  const ephemeralPrivateKey = x25519.utils.randomSecretKey();\n  const ephemeralPublicKey = x25519.getPublicKey(ephemeralPrivateKey);\n\n  const shared = x25519.getSharedSecret(ephemeralPrivateKey, recipient);\n  const aeadKey = hkdf(sha256, shared, undefined, undefined, 32);\n\n  const iv = randomBytes(IV_SIZE_BYTES);\n  const ciphertext = gcm(aeadKey, iv).encrypt(keyToWrap);\n\n  const blob = new Uint8Array(\n    ephemeralPublicKey.length + iv.length + ciphertext.length,\n  );\n  blob.set(ephemeralPublicKey, 0);\n  blob.set(iv, ephemeralPublicKey.length);\n  blob.set(ciphertext, ephemeralPublicKey.length + iv.length);\n\n  return toBase64Url(blob);\n}\n"]}

package/dist/ukyc/wrapUserKey.d.cts

@@ -1,26 +0,0 @@
-/**
- * Wraps `keyToWrap` for the holder of `recipientPublicKey` using an
- * ephemeral-static ECDH + AES-256-GCM sealed-box scheme:
- *
- *   ephemeral = fresh X25519 keypair (one per call)
- *   shared    = X25519(ephemeralPrivate, recipientPublic)
- *   aeadKey   = HKDF-SHA256(shared, 32 bytes)
- *   iv        = 12 random bytes
- *   ct        = AES-256-GCM(aeadKey, iv).encrypt(keyToWrap)   // ct includes tag
- *
- * The recipient reverses it with their private key:
- *
- *   shared  = X25519(recipientPrivate, ephemeralPublic)
- *   aeadKey = HKDF-SHA256(shared, 32 bytes)
- *   key     = AES-256-GCM(aeadKey, iv).decrypt(ct)
- *
- * This mirrors the X25519 + AES-256-GCM/HKDF decryption used for MoonPay
- * Check/Auth-frame credentials, so both directions share one primitive.
- *
- * @param recipientPublicKey - The recipient's X25519 public key (hex or base64).
- * @param keyToWrap - The raw symmetric key bytes to encrypt (e.g. the
- * `data_encryption_key`).
- * @returns Base64url of `ephemeralPublicKey(32) || iv(12) || ciphertext+tag`.
- */
-export declare function wrapUserKey(recipientPublicKey: string, keyToWrap: Uint8Array): string;
-//# sourceMappingURL=wrapUserKey.d.cts.map

package/dist/ukyc/wrapUserKey.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrapUserKey.d.cts","sourceRoot":"","sources":["../../src/ukyc/wrapUserKey.ts"],"names":[],"mappings":"AAqDA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CACzB,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,UAAU,GACpB,MAAM,CAoBR"}

package/dist/ukyc/wrapUserKey.d.mts

@@ -1,26 +0,0 @@
-/**
- * Wraps `keyToWrap` for the holder of `recipientPublicKey` using an
- * ephemeral-static ECDH + AES-256-GCM sealed-box scheme:
- *
- *   ephemeral = fresh X25519 keypair (one per call)
- *   shared    = X25519(ephemeralPrivate, recipientPublic)
- *   aeadKey   = HKDF-SHA256(shared, 32 bytes)
- *   iv        = 12 random bytes
- *   ct        = AES-256-GCM(aeadKey, iv).encrypt(keyToWrap)   // ct includes tag
- *
- * The recipient reverses it with their private key:
- *
- *   shared  = X25519(recipientPrivate, ephemeralPublic)
- *   aeadKey = HKDF-SHA256(shared, 32 bytes)
- *   key     = AES-256-GCM(aeadKey, iv).decrypt(ct)
- *
- * This mirrors the X25519 + AES-256-GCM/HKDF decryption used for MoonPay
- * Check/Auth-frame credentials, so both directions share one primitive.
- *
- * @param recipientPublicKey - The recipient's X25519 public key (hex or base64).
- * @param keyToWrap - The raw symmetric key bytes to encrypt (e.g. the
- * `data_encryption_key`).
- * @returns Base64url of `ephemeralPublicKey(32) || iv(12) || ciphertext+tag`.
- */
-export declare function wrapUserKey(recipientPublicKey: string, keyToWrap: Uint8Array): string;
-//# sourceMappingURL=wrapUserKey.d.mts.map

package/dist/ukyc/wrapUserKey.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrapUserKey.d.mts","sourceRoot":"","sources":["../../src/ukyc/wrapUserKey.ts"],"names":[],"mappings":"AAqDA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CACzB,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,UAAU,GACpB,MAAM,CAoBR"}

package/dist/ukyc/wrapUserKey.mjs

@@ -1,76 +0,0 @@
-import { base64ToBytes } from "@metamask/utils";
-import { gcm } from "@noble/ciphers/aes";
-import { x25519 } from "@noble/curves/ed25519";
-import { hkdf } from "@noble/hashes/hkdf";
-import { sha256 } from "@noble/hashes/sha2";
-import { hexToBytes, randomBytes } from "@noble/hashes/utils";
-import { toBase64Url } from "../encoding.mjs";
-/**
- * Wraps (encrypts) a symmetric key so that only the holder of a given X25519
- * private key can recover it — used to seal the `data_encryption_key` for the
- * idOS Relay before it is handed to the UKYC API as `wrappedUserKey`.
- */
-/** X25519 public/private keys and AES-256-GCM keys are all 32 bytes. */
-const X25519_KEY_SIZE_BYTES = 32;
-/** 96-bit IV, the AES-GCM standard nonce size. */
-const IV_SIZE_BYTES = 12;
-/**
- * Decodes an X25519 public key presented as either hex or base64/base64url.
- *
- * @param recipientPublicKey - The recipient's 32-byte X25519 public key.
- * @returns The raw 32-byte public key.
- */
-function decodePublicKey(recipientPublicKey) {
-    const isHex = recipientPublicKey.length === X25519_KEY_SIZE_BYTES * 2 &&
-        /^[0-9a-fA-F]+$/u.test(recipientPublicKey);
-    const bytes = isHex
-        ? hexToBytes(recipientPublicKey)
-        : base64ToBytes(recipientPublicKey
-            .replace(/-/gu, '+')
-            .replace(/_/gu, '/')
-            .padEnd(recipientPublicKey.length +
-            ((4 - (recipientPublicKey.length % 4)) % 4), '='));
-    if (bytes.length !== X25519_KEY_SIZE_BYTES) {
-        throw new Error(`UKYC: wrappingPublicKey has unexpected length ${bytes.length}, expected ${X25519_KEY_SIZE_BYTES}.`);
-    }
-    return bytes;
-}
-/**
- * Wraps `keyToWrap` for the holder of `recipientPublicKey` using an
- * ephemeral-static ECDH + AES-256-GCM sealed-box scheme:
- *
- *   ephemeral = fresh X25519 keypair (one per call)
- *   shared    = X25519(ephemeralPrivate, recipientPublic)
- *   aeadKey   = HKDF-SHA256(shared, 32 bytes)
- *   iv        = 12 random bytes
- *   ct        = AES-256-GCM(aeadKey, iv).encrypt(keyToWrap)   // ct includes tag
- *
- * The recipient reverses it with their private key:
- *
- *   shared  = X25519(recipientPrivate, ephemeralPublic)
- *   aeadKey = HKDF-SHA256(shared, 32 bytes)
- *   key     = AES-256-GCM(aeadKey, iv).decrypt(ct)
- *
- * This mirrors the X25519 + AES-256-GCM/HKDF decryption used for MoonPay
- * Check/Auth-frame credentials, so both directions share one primitive.
- *
- * @param recipientPublicKey - The recipient's X25519 public key (hex or base64).
- * @param keyToWrap - The raw symmetric key bytes to encrypt (e.g. the
- * `data_encryption_key`).
- * @returns Base64url of `ephemeralPublicKey(32) || iv(12) || ciphertext+tag`.
- */
-export function wrapUserKey(recipientPublicKey, keyToWrap) {
-    const recipient = decodePublicKey(recipientPublicKey);
-    const ephemeralPrivateKey = x25519.utils.randomSecretKey();
-    const ephemeralPublicKey = x25519.getPublicKey(ephemeralPrivateKey);
-    const shared = x25519.getSharedSecret(ephemeralPrivateKey, recipient);
-    const aeadKey = hkdf(sha256, shared, undefined, undefined, 32);
-    const iv = randomBytes(IV_SIZE_BYTES);
-    const ciphertext = gcm(aeadKey, iv).encrypt(keyToWrap);
-    const blob = new Uint8Array(ephemeralPublicKey.length + iv.length + ciphertext.length);
-    blob.set(ephemeralPublicKey, 0);
-    blob.set(iv, ephemeralPublicKey.length);
-    blob.set(ciphertext, ephemeralPublicKey.length + iv.length);
-    return toBase64Url(blob);
-}
-//# sourceMappingURL=wrapUserKey.mjs.map

package/dist/ukyc/wrapUserKey.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrapUserKey.mjs","sourceRoot":"","sources":["../../src/ukyc/wrapUserKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,wBAAwB;AAChD,OAAO,EAAE,GAAG,EAAE,2BAA2B;AACzC,OAAO,EAAE,MAAM,EAAE,8BAA8B;AAC/C,OAAO,EAAE,IAAI,EAAE,2BAA2B;AAC1C,OAAO,EAAE,MAAM,EAAE,2BAA2B;AAC5C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,4BAA4B;AAE9D,OAAO,EAAE,WAAW,EAAE,wBAAuB;AAE7C;;;;GAIG;AAEH,wEAAwE;AACxE,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAEjC,kDAAkD;AAClD,MAAM,aAAa,GAAG,EAAE,CAAC;AAEzB;;;;;GAKG;AACH,SAAS,eAAe,CAAC,kBAA0B;IACjD,MAAM,KAAK,GACT,kBAAkB,CAAC,MAAM,KAAK,qBAAqB,GAAG,CAAC;QACvD,iBAAiB,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAE7C,MAAM,KAAK,GAAG,KAAK;QACjB,CAAC,CAAC,UAAU,CAAC,kBAAkB,CAAC;QAChC,CAAC,CAAC,aAAa,CACX,kBAAkB;aACf,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;aACnB,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;aACnB,MAAM,CACL,kBAAkB,CAAC,MAAM;YACvB,CAAC,CAAC,CAAC,GAAG,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAC7C,GAAG,CACJ,CACJ,CAAC;IAEN,IAAI,KAAK,CAAC,MAAM,KAAK,qBAAqB,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CACb,iDAAiD,KAAK,CAAC,MAAM,cAAc,qBAAqB,GAAG,CACpG,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,WAAW,CACzB,kBAA0B,EAC1B,SAAqB;IAErB,MAAM,SAAS,GAAG,eAAe,CAAC,kBAAkB,CAAC,CAAC;IAEtD,MAAM,mBAAmB,GAAG,MAAM,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC;IAC3D,MAAM,kBAAkB,GAAG,MAAM,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC;IAEpE,MAAM,MAAM,GAAG,MAAM,CAAC,eAAe,CAAC,mBAAmB,EAAE,SAAS,CAAC,CAAC;IACtE,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;IAE/D,MAAM,EAAE,GAAG,WAAW,CAAC,aAAa,CAAC,CAAC;IACtC,MAAM,UAAU,GAAG,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAEvD,MAAM,IAAI,GAAG,IAAI,UAAU,CACzB,kBAAkB,CAAC,MAAM,GAAG,EAAE,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAC1D,CAAC;IACF,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC;IAChC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACxC,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC;IAE5D,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC;AAC3B,CAAC","sourcesContent":["import { base64ToBytes } from '@metamask/utils';\nimport { gcm } from '@noble/ciphers/aes';\nimport { x25519 } from '@noble/curves/ed25519';\nimport { hkdf } from '@noble/hashes/hkdf';\nimport { sha256 } from '@noble/hashes/sha2';\nimport { hexToBytes, randomBytes } from '@noble/hashes/utils';\n\nimport { toBase64Url } from '../encoding.js';\n\n/**\n * Wraps (encrypts) a symmetric key so that only the holder of a given X25519\n * private key can recover it — used to seal the `data_encryption_key` for the\n * idOS Relay before it is handed to the UKYC API as `wrappedUserKey`.\n */\n\n/** X25519 public/private keys and AES-256-GCM keys are all 32 bytes. */\nconst X25519_KEY_SIZE_BYTES = 32;\n\n/** 96-bit IV, the AES-GCM standard nonce size. */\nconst IV_SIZE_BYTES = 12;\n\n/**\n * Decodes an X25519 public key presented as either hex or base64/base64url.\n *\n * @param recipientPublicKey - The recipient's 32-byte X25519 public key.\n * @returns The raw 32-byte public key.\n */\nfunction decodePublicKey(recipientPublicKey: string): Uint8Array {\n  const isHex =\n    recipientPublicKey.length === X25519_KEY_SIZE_BYTES * 2 &&\n    /^[0-9a-fA-F]+$/u.test(recipientPublicKey);\n\n  const bytes = isHex\n    ? hexToBytes(recipientPublicKey)\n    : base64ToBytes(\n        recipientPublicKey\n          .replace(/-/gu, '+')\n          .replace(/_/gu, '/')\n          .padEnd(\n            recipientPublicKey.length +\n              ((4 - (recipientPublicKey.length % 4)) % 4),\n            '=',\n          ),\n      );\n\n  if (bytes.length !== X25519_KEY_SIZE_BYTES) {\n    throw new Error(\n      `UKYC: wrappingPublicKey has unexpected length ${bytes.length}, expected ${X25519_KEY_SIZE_BYTES}.`,\n    );\n  }\n  return bytes;\n}\n\n/**\n * Wraps `keyToWrap` for the holder of `recipientPublicKey` using an\n * ephemeral-static ECDH + AES-256-GCM sealed-box scheme:\n *\n *   ephemeral = fresh X25519 keypair (one per call)\n *   shared    = X25519(ephemeralPrivate, recipientPublic)\n *   aeadKey   = HKDF-SHA256(shared, 32 bytes)\n *   iv        = 12 random bytes\n *   ct        = AES-256-GCM(aeadKey, iv).encrypt(keyToWrap)   // ct includes tag\n *\n * The recipient reverses it with their private key:\n *\n *   shared  = X25519(recipientPrivate, ephemeralPublic)\n *   aeadKey = HKDF-SHA256(shared, 32 bytes)\n *   key     = AES-256-GCM(aeadKey, iv).decrypt(ct)\n *\n * This mirrors the X25519 + AES-256-GCM/HKDF decryption used for MoonPay\n * Check/Auth-frame credentials, so both directions share one primitive.\n *\n * @param recipientPublicKey - The recipient's X25519 public key (hex or base64).\n * @param keyToWrap - The raw symmetric key bytes to encrypt (e.g. the\n * `data_encryption_key`).\n * @returns Base64url of `ephemeralPublicKey(32) || iv(12) || ciphertext+tag`.\n */\nexport function wrapUserKey(\n  recipientPublicKey: string,\n  keyToWrap: Uint8Array,\n): string {\n  const recipient = decodePublicKey(recipientPublicKey);\n\n  const ephemeralPrivateKey = x25519.utils.randomSecretKey();\n  const ephemeralPublicKey = x25519.getPublicKey(ephemeralPrivateKey);\n\n  const shared = x25519.getSharedSecret(ephemeralPrivateKey, recipient);\n  const aeadKey = hkdf(sha256, shared, undefined, undefined, 32);\n\n  const iv = randomBytes(IV_SIZE_BYTES);\n  const ciphertext = gcm(aeadKey, iv).encrypt(keyToWrap);\n\n  const blob = new Uint8Array(\n    ephemeralPublicKey.length + iv.length + ciphertext.length,\n  );\n  blob.set(ephemeralPublicKey, 0);\n  blob.set(iv, ephemeralPublicKey.length);\n  blob.set(ciphertext, ephemeralPublicKey.length + iv.length);\n\n  return toBase64Url(blob);\n}\n"]}

package/dist/ukyc/wrappedRelayPayload.cjs

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildWrappedRelayPayload = void 0;
-const encoding_js_1 = require("../encoding.cjs");
-/**
- * Assembles the `wrapped_relay_payload` from derived client material and a
- * Relay-presented `storage_access_token`.
- *
- * The token must be scoped for the Relay to present (`presenter: 'idos-relay'`)
- * and must not authorize `delete`, which is never delegated to the Relay.
- *
- * @param material - Client material derived from `local_user_secret`.
- * @param storageAccessToken - A `read`/`write`-scoped, Relay-presented token.
- * @returns The `wrapped_relay_payload` to send to the Relay via the UKYC API.
- */
-function buildWrappedRelayPayload(material, storageAccessToken) {
-    const { presenter, operations } = storageAccessToken.payload;
-    if (presenter !== 'idos-relay') {
-        throw new Error('UKYC: wrapped_relay_payload requires a Relay-presented storage_access_token.');
-    }
-    if (operations.includes('delete')) {
-        throw new Error('UKYC: wrapped_relay_payload must not carry a delete-scoped storage_access_token.');
-    }
-    return {
-        storage_id: (0, encoding_js_1.toBase64Url)(material.storageId),
-        data_encryption_key: (0, encoding_js_1.toBase64Url)(material.dataEncryptionKey),
-        signing_public_key: (0, encoding_js_1.toBase64Url)(material.signingPublicKey),
-        storage_access_token: storageAccessToken,
-    };
-}
-exports.buildWrappedRelayPayload = buildWrappedRelayPayload;
-//# sourceMappingURL=wrappedRelayPayload.cjs.map

package/dist/ukyc/wrappedRelayPayload.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrappedRelayPayload.cjs","sourceRoot":"","sources":["../../src/ukyc/wrappedRelayPayload.ts"],"names":[],"mappings":";;;AACA,iDAA6C;AA4B7C;;;;;;;;;;GAUG;AACH,SAAgB,wBAAwB,CACtC,QAA4B,EAC5B,kBAA0C;IAE1C,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,kBAAkB,CAAC,OAAO,CAAC;IAE7D,IAAI,SAAS,KAAK,YAAY,EAAE,CAAC;QAC/B,MAAM,IAAI,KAAK,CACb,8EAA8E,CAC/E,CAAC;IACJ,CAAC;IAED,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CACb,kFAAkF,CACnF,CAAC;IACJ,CAAC;IAED,OAAO;QACL,UAAU,EAAE,IAAA,yBAAW,EAAC,QAAQ,CAAC,SAAS,CAAC;QAC3C,mBAAmB,EAAE,IAAA,yBAAW,EAAC,QAAQ,CAAC,iBAAiB,CAAC;QAC5D,kBAAkB,EAAE,IAAA,yBAAW,EAAC,QAAQ,CAAC,gBAAgB,CAAC;QAC1D,oBAAoB,EAAE,kBAAkB;KACzC,CAAC;AACJ,CAAC;AAxBD,4DAwBC","sourcesContent":["import type { UkycClientMaterial } from './deriveClientMaterial.js';\nimport { toBase64Url } from '../encoding.js';\nimport type { UkycStorageAccessToken } from './storageAccessToken.js';\n\n/**\n * Builds the `wrapped_relay_payload` — the only client-derived material that\n * leaves the device. It is sent to the idOS Relay (through the UKYC API) so the\n * Relay can encrypt/decrypt and store KYC payloads on the user's behalf. See the\n * architecture doc, section \"Client-Derived Material\".\n *\n * Neither `local_user_secret` nor the private `signing_key` are ever included.\n * The `data_encryption_key` *is* included: it is intentionally shared with the\n * Relay so it can encrypt/decrypt payloads transiently.\n */\n\n/**\n * The Relay-facing bundle. `data_encryption_key` is base64url-encoded secret\n * material shared with the Relay; the other fields are non-secret.\n */\nexport type UkycWrappedRelayPayload = {\n  // Wire-shape fields are snake_case.\n  /* eslint-disable @typescript-eslint/naming-convention */\n  storage_id: string;\n  data_encryption_key: string;\n  signing_public_key: string;\n  storage_access_token: UkycStorageAccessToken;\n  /* eslint-enable @typescript-eslint/naming-convention */\n};\n\n/**\n * Assembles the `wrapped_relay_payload` from derived client material and a\n * Relay-presented `storage_access_token`.\n *\n * The token must be scoped for the Relay to present (`presenter: 'idos-relay'`)\n * and must not authorize `delete`, which is never delegated to the Relay.\n *\n * @param material - Client material derived from `local_user_secret`.\n * @param storageAccessToken - A `read`/`write`-scoped, Relay-presented token.\n * @returns The `wrapped_relay_payload` to send to the Relay via the UKYC API.\n */\nexport function buildWrappedRelayPayload(\n  material: UkycClientMaterial,\n  storageAccessToken: UkycStorageAccessToken,\n): UkycWrappedRelayPayload {\n  const { presenter, operations } = storageAccessToken.payload;\n\n  if (presenter !== 'idos-relay') {\n    throw new Error(\n      'UKYC: wrapped_relay_payload requires a Relay-presented storage_access_token.',\n    );\n  }\n\n  if (operations.includes('delete')) {\n    throw new Error(\n      'UKYC: wrapped_relay_payload must not carry a delete-scoped storage_access_token.',\n    );\n  }\n\n  return {\n    storage_id: toBase64Url(material.storageId),\n    data_encryption_key: toBase64Url(material.dataEncryptionKey),\n    signing_public_key: toBase64Url(material.signingPublicKey),\n    storage_access_token: storageAccessToken,\n  };\n}\n"]}

package/dist/ukyc/wrappedRelayPayload.d.cts

@@ -1,35 +0,0 @@
-import type { UkycClientMaterial } from "./deriveClientMaterial.cjs";
-import type { UkycStorageAccessToken } from "./storageAccessToken.cjs";
-/**
- * Builds the `wrapped_relay_payload` — the only client-derived material that
- * leaves the device. It is sent to the idOS Relay (through the UKYC API) so the
- * Relay can encrypt/decrypt and store KYC payloads on the user's behalf. See the
- * architecture doc, section "Client-Derived Material".
- *
- * Neither `local_user_secret` nor the private `signing_key` are ever included.
- * The `data_encryption_key` *is* included: it is intentionally shared with the
- * Relay so it can encrypt/decrypt payloads transiently.
- */
-/**
- * The Relay-facing bundle. `data_encryption_key` is base64url-encoded secret
- * material shared with the Relay; the other fields are non-secret.
- */
-export type UkycWrappedRelayPayload = {
-    storage_id: string;
-    data_encryption_key: string;
-    signing_public_key: string;
-    storage_access_token: UkycStorageAccessToken;
-};
-/**
- * Assembles the `wrapped_relay_payload` from derived client material and a
- * Relay-presented `storage_access_token`.
- *
- * The token must be scoped for the Relay to present (`presenter: 'idos-relay'`)
- * and must not authorize `delete`, which is never delegated to the Relay.
- *
- * @param material - Client material derived from `local_user_secret`.
- * @param storageAccessToken - A `read`/`write`-scoped, Relay-presented token.
- * @returns The `wrapped_relay_payload` to send to the Relay via the UKYC API.
- */
-export declare function buildWrappedRelayPayload(material: UkycClientMaterial, storageAccessToken: UkycStorageAccessToken): UkycWrappedRelayPayload;
-//# sourceMappingURL=wrappedRelayPayload.d.cts.map

package/dist/ukyc/wrappedRelayPayload.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrappedRelayPayload.d.cts","sourceRoot":"","sources":["../../src/ukyc/wrappedRelayPayload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,mCAAkC;AAEpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,iCAAgC;AAEtE;;;;;;;;;GASG;AAEH;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG;IAGpC,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,oBAAoB,EAAE,sBAAsB,CAAC;CAE9C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,kBAAkB,EAC5B,kBAAkB,EAAE,sBAAsB,GACzC,uBAAuB,CAqBzB"}

package/dist/ukyc/wrappedRelayPayload.d.mts

@@ -1,35 +0,0 @@
-import type { UkycClientMaterial } from "./deriveClientMaterial.mjs";
-import type { UkycStorageAccessToken } from "./storageAccessToken.mjs";
-/**
- * Builds the `wrapped_relay_payload` — the only client-derived material that
- * leaves the device. It is sent to the idOS Relay (through the UKYC API) so the
- * Relay can encrypt/decrypt and store KYC payloads on the user's behalf. See the
- * architecture doc, section "Client-Derived Material".
- *
- * Neither `local_user_secret` nor the private `signing_key` are ever included.
- * The `data_encryption_key` *is* included: it is intentionally shared with the
- * Relay so it can encrypt/decrypt payloads transiently.
- */
-/**
- * The Relay-facing bundle. `data_encryption_key` is base64url-encoded secret
- * material shared with the Relay; the other fields are non-secret.
- */
-export type UkycWrappedRelayPayload = {
-    storage_id: string;
-    data_encryption_key: string;
-    signing_public_key: string;
-    storage_access_token: UkycStorageAccessToken;
-};
-/**
- * Assembles the `wrapped_relay_payload` from derived client material and a
- * Relay-presented `storage_access_token`.
- *
- * The token must be scoped for the Relay to present (`presenter: 'idos-relay'`)
- * and must not authorize `delete`, which is never delegated to the Relay.
- *
- * @param material - Client material derived from `local_user_secret`.
- * @param storageAccessToken - A `read`/`write`-scoped, Relay-presented token.
- * @returns The `wrapped_relay_payload` to send to the Relay via the UKYC API.
- */
-export declare function buildWrappedRelayPayload(material: UkycClientMaterial, storageAccessToken: UkycStorageAccessToken): UkycWrappedRelayPayload;
-//# sourceMappingURL=wrappedRelayPayload.d.mts.map

package/dist/ukyc/wrappedRelayPayload.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrappedRelayPayload.d.mts","sourceRoot":"","sources":["../../src/ukyc/wrappedRelayPayload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,mCAAkC;AAEpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,iCAAgC;AAEtE;;;;;;;;;GASG;AAEH;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG;IAGpC,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,oBAAoB,EAAE,sBAAsB,CAAC;CAE9C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,kBAAkB,EAC5B,kBAAkB,EAAE,sBAAsB,GACzC,uBAAuB,CAqBzB"}

package/dist/ukyc/wrappedRelayPayload.mjs

@@ -1,28 +0,0 @@
-import { toBase64Url } from "../encoding.mjs";
-/**
- * Assembles the `wrapped_relay_payload` from derived client material and a
- * Relay-presented `storage_access_token`.
- *
- * The token must be scoped for the Relay to present (`presenter: 'idos-relay'`)
- * and must not authorize `delete`, which is never delegated to the Relay.
- *
- * @param material - Client material derived from `local_user_secret`.
- * @param storageAccessToken - A `read`/`write`-scoped, Relay-presented token.
- * @returns The `wrapped_relay_payload` to send to the Relay via the UKYC API.
- */
-export function buildWrappedRelayPayload(material, storageAccessToken) {
-    const { presenter, operations } = storageAccessToken.payload;
-    if (presenter !== 'idos-relay') {
-        throw new Error('UKYC: wrapped_relay_payload requires a Relay-presented storage_access_token.');
-    }
-    if (operations.includes('delete')) {
-        throw new Error('UKYC: wrapped_relay_payload must not carry a delete-scoped storage_access_token.');
-    }
-    return {
-        storage_id: toBase64Url(material.storageId),
-        data_encryption_key: toBase64Url(material.dataEncryptionKey),
-        signing_public_key: toBase64Url(material.signingPublicKey),
-        storage_access_token: storageAccessToken,
-    };
-}
-//# sourceMappingURL=wrappedRelayPayload.mjs.map

package/dist/ukyc/wrappedRelayPayload.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrappedRelayPayload.mjs","sourceRoot":"","sources":["../../src/ukyc/wrappedRelayPayload.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,wBAAuB;AA4B7C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,wBAAwB,CACtC,QAA4B,EAC5B,kBAA0C;IAE1C,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,kBAAkB,CAAC,OAAO,CAAC;IAE7D,IAAI,SAAS,KAAK,YAAY,EAAE,CAAC;QAC/B,MAAM,IAAI,KAAK,CACb,8EAA8E,CAC/E,CAAC;IACJ,CAAC;IAED,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CACb,kFAAkF,CACnF,CAAC;IACJ,CAAC;IAED,OAAO;QACL,UAAU,EAAE,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC;QAC3C,mBAAmB,EAAE,WAAW,CAAC,QAAQ,CAAC,iBAAiB,CAAC;QAC5D,kBAAkB,EAAE,WAAW,CAAC,QAAQ,CAAC,gBAAgB,CAAC;QAC1D,oBAAoB,EAAE,kBAAkB;KACzC,CAAC;AACJ,CAAC","sourcesContent":["import type { UkycClientMaterial } from './deriveClientMaterial.js';\nimport { toBase64Url } from '../encoding.js';\nimport type { UkycStorageAccessToken } from './storageAccessToken.js';\n\n/**\n * Builds the `wrapped_relay_payload` — the only client-derived material that\n * leaves the device. It is sent to the idOS Relay (through the UKYC API) so the\n * Relay can encrypt/decrypt and store KYC payloads on the user's behalf. See the\n * architecture doc, section \"Client-Derived Material\".\n *\n * Neither `local_user_secret` nor the private `signing_key` are ever included.\n * The `data_encryption_key` *is* included: it is intentionally shared with the\n * Relay so it can encrypt/decrypt payloads transiently.\n */\n\n/**\n * The Relay-facing bundle. `data_encryption_key` is base64url-encoded secret\n * material shared with the Relay; the other fields are non-secret.\n */\nexport type UkycWrappedRelayPayload = {\n  // Wire-shape fields are snake_case.\n  /* eslint-disable @typescript-eslint/naming-convention */\n  storage_id: string;\n  data_encryption_key: string;\n  signing_public_key: string;\n  storage_access_token: UkycStorageAccessToken;\n  /* eslint-enable @typescript-eslint/naming-convention */\n};\n\n/**\n * Assembles the `wrapped_relay_payload` from derived client material and a\n * Relay-presented `storage_access_token`.\n *\n * The token must be scoped for the Relay to present (`presenter: 'idos-relay'`)\n * and must not authorize `delete`, which is never delegated to the Relay.\n *\n * @param material - Client material derived from `local_user_secret`.\n * @param storageAccessToken - A `read`/`write`-scoped, Relay-presented token.\n * @returns The `wrapped_relay_payload` to send to the Relay via the UKYC API.\n */\nexport function buildWrappedRelayPayload(\n  material: UkycClientMaterial,\n  storageAccessToken: UkycStorageAccessToken,\n): UkycWrappedRelayPayload {\n  const { presenter, operations } = storageAccessToken.payload;\n\n  if (presenter !== 'idos-relay') {\n    throw new Error(\n      'UKYC: wrapped_relay_payload requires a Relay-presented storage_access_token.',\n    );\n  }\n\n  if (operations.includes('delete')) {\n    throw new Error(\n      'UKYC: wrapped_relay_payload must not carry a delete-scoped storage_access_token.',\n    );\n  }\n\n  return {\n    storage_id: toBase64Url(material.storageId),\n    data_encryption_key: toBase64Url(material.dataEncryptionKey),\n    signing_public_key: toBase64Url(material.signingPublicKey),\n    storage_access_token: storageAccessToken,\n  };\n}\n"]}