@solana/keys 2.0.0-experimental.ca5fcbd → 2.0.0-experimental.ca7c151

package/README.md

@@ -18,35 +18,44 @@ This package contains utilities for validating, generating, and manipulating add
 
 ## Types
 
-### `Base58EncodedAddress`
+### `Ed25519Signature`
 
-This type represents a string that validates as a Solana address or public key. Functions that require well-formed addresses should specify their inputs in terms of this type.
+This type represents a 64-byte Ed25519 signature of some data with a private key.
 
-Whenever you need to validate an arbitrary string as a base58-encoded address, use the `assertIsBase58EncodedAddress()` function in this package.
+Whenever you need to verify that a particular signature is, in fact, the one that would have been produced by signing some known bytes using the private key associated with some known public key, use the `verifySignature()` function in this package.
 
 ## Functions
 
-### `assertIsBase58EncodedAddress()`
+### `generateKeyPair()`
 
-Client applications primarily deal with addresses and public keys in the form of base58-encoded strings. Addresses and public keys returned from the RPC API conform to the type `Base58EncodedAddress`. You can use a value of that type wherever a base58-encoded address or key is expected.
+Generates an Ed25519 public/private key pair for use with other methods in this package that accept `CryptoKey` objects.
 
-From time to time you might acquire a string, that you expect to validate as an address, from an untrusted network API or user input. To assert that such an arbitrary string is a base58-encoded address, use the `assertIsBase58EncodedAddress` function.
+```ts
+import { generateKeyPair } from '@solana/keys';
+
+const { privateKey, publicKey } = await generateKeyPair();
+```
+
+### `signBytes()`
+
+Given a private `CryptoKey` and a `Uint8Array` of bytes, this method will return the 64-byte Ed25519 signature of that data as a `Uint8Array`.
+
+```ts
+import { signBytes } from '@solana/keys';
+
+const data = new Uint8Array([1, 2, 3]);
+const signature = await signBytes(privateKey, data);
+```
+
+### `verifySignature()`
+
+Given a public `CryptoKey`, an `Ed25519Signature`, and a `Uint8Array` of bytes, this method will return `true` if the signature was produced by signing the bytes using the private key associated with the public key, and `false` otherwise.
 
 ```ts
-import { assertIsBase58EncodedAddress } from '@solana/web3.js`;
-
-// Imagine a function that fetches an account's balance when a user submits a form.
-function handleSubmit() {
-    // We know only that what the user typed conforms to the `string` type.
-    const address: string = accountAddressInput.value;
-    try {
-        // If this type assertion function doesn't throw, then
-        // Typescript will upcast `address` to `Base58EncodedAddress`.
-        assertIsBase58EncodedAddress(address);
-        // At this point, `address` is a `Base58EncodedAddress` that can be used with the RPC.
-        const balanceInLamports = await rpc.getBalance(address).send();
-    } catch (e) {
-        // `address` turned out not to be a base58-encoded address
-    }
+import { verifySignature } from '@solana/keys';
+
+const data = new Uint8Array([1, 2, 3]);
+if (!(await verifySignature(publicKey, signature, data))) {
+    throw new Error('The data were *not* signed by the private key associated with `publicKey`');
 }
 ```

package/dist/index.browser.cjs

@@ -1,49 +1,34 @@
 'use strict';
 
-var umiSerializers = require('@metaplex-foundation/umi-serializers');
+var assertions = require('@solana/assertions');
 
-// ../build-scripts/env-shim.ts
-var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
-function assertIsBase58EncodedAddress(putativeBase58EncodedAddress) {
-  try {
-    if (
-      // Lowest address (32 bytes of zeroes)
-      putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
-      putativeBase58EncodedAddress.length > 44
-    ) {
-      throw new Error("Expected input string to decode to a byte array of length 32.");
-    }
-    const bytes = umiSerializers.base58.serialize(putativeBase58EncodedAddress);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
-      cause: e
-    });
-  }
+// src/key-pair.ts
+async function generateKeyPair() {
+  await assertions.assertKeyGenerationIsAvailable();
+  const keyPair = await crypto.subtle.generateKey(
+    /* algorithm */
+    "Ed25519",
+    // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20
+    /* extractable */
+    false,
+    // Prevents the bytes of the private key from being visible to JS.
+    /* allowed uses */
+    ["sign", "verify"]
+  );
+  return keyPair;
 }
-function getBase58EncodedAddressCodec(config) {
-  return umiSerializers.string({
-    description: config?.description ?? (__DEV__ ? "A 32-byte account address" : ""),
-    encoding: umiSerializers.base58,
-    size: 32
-  });
+async function signBytes(key, data) {
+  await assertions.assertSigningCapabilityIsAvailable();
+  const signedData = await crypto.subtle.sign("Ed25519", key, data);
+  return new Uint8Array(signedData);
 }
-function getBase58EncodedAddressComparator() {
-  return new Intl.Collator("en", {
-    caseFirst: "lower",
-    ignorePunctuation: false,
-    localeMatcher: "best fit",
-    numeric: false,
-    sensitivity: "variant",
-    usage: "sort"
-  }).compare;
+async function verifySignature(key, signature, data) {
+  await assertions.assertVerificationCapabilityIsAvailable();
+  return await crypto.subtle.verify("Ed25519", key, signature, data);
 }
 
-exports.assertIsBase58EncodedAddress = assertIsBase58EncodedAddress;
-exports.getBase58EncodedAddressCodec = getBase58EncodedAddressCodec;
-exports.getBase58EncodedAddressComparator = getBase58EncodedAddressComparator;
+exports.generateKeyPair = generateKeyPair;
+exports.signBytes = signBytes;
+exports.verifySignature = verifySignature;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.cjs.map

package/dist/index.browser.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../build-scripts/env-shim.ts","../src/base58.ts"],"names":[],"mappings":";AACO,IAAM,UAA2B,uBAAO,QAAgB,KAAU,EAAE,aAAa,eAAe;;;ACDvG,SAAS,QAAoB,cAAc;AAMpC,SAAS,6BACZ,8BACiG;AACjG,MAAI;AAEA;AAAA;AAAA,MAEI,6BAA6B,SAAS;AAAA,MAEtC,6BAA6B,SAAS;AAAA,MACxC;AACE,YAAM,IAAI,MAAM,+DAA+D;AAAA,IACnF;AAEA,UAAM,QAAQ,OAAO,UAAU,4BAA4B;AAC3D,UAAM,WAAW,MAAM;AACvB,QAAI,aAAa,IAAI;AACjB,YAAM,IAAI,MAAM,gFAAgF,UAAU;AAAA,IAC9G;AAAA,EACJ,SAAS,GAAP;AACE,UAAM,IAAI,MAAM,KAAK,mEAAmE;AAAA,MACpF,OAAO;AAAA,IACX,CAAC;AAAA,EACL;AACJ;AAEO,SAAS,6BACZ,QAGgC;AAChC,SAAO,OAAO;AAAA,IACV,aAAa,QAAQ,gBAAgB,UAAU,8BAA8B;AAAA,IAC7E,UAAU;AAAA,IACV,MAAM;AAAA,EACV,CAAC;AACL;AAEO,SAAS,oCAAsE;AAClF,SAAO,IAAI,KAAK,SAAS,MAAM;AAAA,IAC3B,WAAW;AAAA,IACX,mBAAmB;AAAA,IACnB,eAAe;AAAA,IACf,SAAS;AAAA,IACT,aAAa;AAAA,IACb,OAAO;AAAA,EACX,CAAC,EAAE;AACP","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","import { base58, Serializer, string } from '@metaplex-foundation/umi-serializers';\n\nexport type Base58EncodedAddress<TAddress extends string = string> = TAddress & {\n    readonly __base58EncodedAddress: unique symbol;\n};\n\nexport function assertIsBase58EncodedAddress(\n    putativeBase58EncodedAddress: string\n): asserts putativeBase58EncodedAddress is Base58EncodedAddress<typeof putativeBase58EncodedAddress> {\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest address (32 bytes of zeroes)\n            putativeBase58EncodedAddress.length < 32 ||\n            // Highest address (32 bytes of 255)\n            putativeBase58EncodedAddress.length > 44\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 32.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = base58.serialize(putativeBase58EncodedAddress);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 32) {\n            throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeBase58EncodedAddress}\\` is not a base-58 encoded address`, {\n            cause: e,\n        });\n    }\n}\n\nexport function getBase58EncodedAddressCodec(\n    config?: Readonly<{\n        description: string;\n    }>\n): Serializer<Base58EncodedAddress> {\n    return string({\n        description: config?.description ?? (__DEV__ ? 'A 32-byte account address' : ''),\n        encoding: base58,\n        size: 32,\n    }) as unknown as Serializer<Base58EncodedAddress>;\n}\n\nexport function getBase58EncodedAddressComparator(): (x: string, y: string) => number {\n    return new Intl.Collator('en', {\n        caseFirst: 'lower',\n        ignorePunctuation: false,\n        localeMatcher: 'best fit',\n        numeric: false,\n        sensitivity: 'variant',\n        usage: 'sort',\n    }).compare;\n}\n"]}
+{"version":3,"sources":["../src/key-pair.ts","../src/signatures.ts"],"names":[],"mappings":";AAAA,SAAS,sCAAsC;AAE/C,eAAsB,kBAA0C;AAC5D,QAAM,+BAA+B;AACrC,QAAM,UAAU,MAAM,OAAO,OAAO;AAAA;AAAA,IAChB;AAAA;AAAA;AAAA,IACE;AAAA;AAAA;AAAA,IACC,CAAC,QAAQ,QAAQ;AAAA,EACxC;AACA,SAAO;AACX;;;ACVA,SAAS,oCAAoC,+CAA+C;AAI5F,eAAsB,UAAU,KAAgB,MAA6C;AACzF,QAAM,mCAAmC;AACzC,QAAM,aAAa,MAAM,OAAO,OAAO,KAAK,WAAW,KAAK,IAAI;AAChE,SAAO,IAAI,WAAW,UAAU;AACpC;AAEA,eAAsB,gBAAgB,KAAgB,WAA6B,MAAoC;AACnH,QAAM,wCAAwC;AAC9C,SAAO,MAAM,OAAO,OAAO,OAAO,WAAW,KAAK,WAAW,IAAI;AACrE","sourcesContent":["import { assertKeyGenerationIsAvailable } from '@solana/assertions';\n\nexport async function generateKeyPair(): Promise<CryptoKeyPair> {\n    await assertKeyGenerationIsAvailable();\n    const keyPair = await crypto.subtle.generateKey(\n        /* algorithm */ 'Ed25519', // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20\n        /* extractable */ false, // Prevents the bytes of the private key from being visible to JS.\n        /* allowed uses */ ['sign', 'verify']\n    );\n    return keyPair as CryptoKeyPair;\n}\n","import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';\n\nexport type Ed25519Signature = Uint8Array & { readonly __ed25519Signature: unique symbol };\n\nexport async function signBytes(key: CryptoKey, data: Uint8Array): Promise<Ed25519Signature> {\n    await assertSigningCapabilityIsAvailable();\n    const signedData = await crypto.subtle.sign('Ed25519', key, data);\n    return new Uint8Array(signedData) as Ed25519Signature;\n}\n\nexport async function verifySignature(key: CryptoKey, signature: Ed25519Signature, data: Uint8Array): Promise<boolean> {\n    await assertVerificationCapabilityIsAvailable();\n    return await crypto.subtle.verify('Ed25519', key, signature, data);\n}\n"]}

package/dist/index.browser.js

@@ -1,45 +1,30 @@
-import { base58, string } from '@metaplex-foundation/umi-serializers';
+import { assertKeyGenerationIsAvailable, assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';
 
-// ../build-scripts/env-shim.ts
-var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
-function assertIsBase58EncodedAddress(putativeBase58EncodedAddress) {
-  try {
-    if (
-      // Lowest address (32 bytes of zeroes)
-      putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
-      putativeBase58EncodedAddress.length > 44
-    ) {
-      throw new Error("Expected input string to decode to a byte array of length 32.");
-    }
-    const bytes = base58.serialize(putativeBase58EncodedAddress);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
-      cause: e
-    });
-  }
+// src/key-pair.ts
+async function generateKeyPair() {
+  await assertKeyGenerationIsAvailable();
+  const keyPair = await crypto.subtle.generateKey(
+    /* algorithm */
+    "Ed25519",
+    // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20
+    /* extractable */
+    false,
+    // Prevents the bytes of the private key from being visible to JS.
+    /* allowed uses */
+    ["sign", "verify"]
+  );
+  return keyPair;
 }
-function getBase58EncodedAddressCodec(config) {
-  return string({
-    description: config?.description ?? (__DEV__ ? "A 32-byte account address" : ""),
-    encoding: base58,
-    size: 32
-  });
+async function signBytes(key, data) {
+  await assertSigningCapabilityIsAvailable();
+  const signedData = await crypto.subtle.sign("Ed25519", key, data);
+  return new Uint8Array(signedData);
 }
-function getBase58EncodedAddressComparator() {
-  return new Intl.Collator("en", {
-    caseFirst: "lower",
-    ignorePunctuation: false,
-    localeMatcher: "best fit",
-    numeric: false,
-    sensitivity: "variant",
-    usage: "sort"
-  }).compare;
+async function verifySignature(key, signature, data) {
+  await assertVerificationCapabilityIsAvailable();
+  return await crypto.subtle.verify("Ed25519", key, signature, data);
 }
 
-export { assertIsBase58EncodedAddress, getBase58EncodedAddressCodec, getBase58EncodedAddressComparator };
+export { generateKeyPair, signBytes, verifySignature };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.js.map

package/dist/index.browser.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../build-scripts/env-shim.ts","../src/base58.ts"],"names":[],"mappings":";AACO,IAAM,UAA2B,uBAAO,QAAgB,KAAU,EAAE,aAAa,eAAe;;;ACDvG,SAAS,QAAoB,cAAc;AAMpC,SAAS,6BACZ,8BACiG;AACjG,MAAI;AAEA;AAAA;AAAA,MAEI,6BAA6B,SAAS;AAAA,MAEtC,6BAA6B,SAAS;AAAA,MACxC;AACE,YAAM,IAAI,MAAM,+DAA+D;AAAA,IACnF;AAEA,UAAM,QAAQ,OAAO,UAAU,4BAA4B;AAC3D,UAAM,WAAW,MAAM;AACvB,QAAI,aAAa,IAAI;AACjB,YAAM,IAAI,MAAM,gFAAgF,UAAU;AAAA,IAC9G;AAAA,EACJ,SAAS,GAAP;AACE,UAAM,IAAI,MAAM,KAAK,mEAAmE;AAAA,MACpF,OAAO;AAAA,IACX,CAAC;AAAA,EACL;AACJ;AAEO,SAAS,6BACZ,QAGgC;AAChC,SAAO,OAAO;AAAA,IACV,aAAa,QAAQ,gBAAgB,UAAU,8BAA8B;AAAA,IAC7E,UAAU;AAAA,IACV,MAAM;AAAA,EACV,CAAC;AACL;AAEO,SAAS,oCAAsE;AAClF,SAAO,IAAI,KAAK,SAAS,MAAM;AAAA,IAC3B,WAAW;AAAA,IACX,mBAAmB;AAAA,IACnB,eAAe;AAAA,IACf,SAAS;AAAA,IACT,aAAa;AAAA,IACb,OAAO;AAAA,EACX,CAAC,EAAE;AACP","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","import { base58, Serializer, string } from '@metaplex-foundation/umi-serializers';\n\nexport type Base58EncodedAddress<TAddress extends string = string> = TAddress & {\n    readonly __base58EncodedAddress: unique symbol;\n};\n\nexport function assertIsBase58EncodedAddress(\n    putativeBase58EncodedAddress: string\n): asserts putativeBase58EncodedAddress is Base58EncodedAddress<typeof putativeBase58EncodedAddress> {\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest address (32 bytes of zeroes)\n            putativeBase58EncodedAddress.length < 32 ||\n            // Highest address (32 bytes of 255)\n            putativeBase58EncodedAddress.length > 44\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 32.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = base58.serialize(putativeBase58EncodedAddress);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 32) {\n            throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeBase58EncodedAddress}\\` is not a base-58 encoded address`, {\n            cause: e,\n        });\n    }\n}\n\nexport function getBase58EncodedAddressCodec(\n    config?: Readonly<{\n        description: string;\n    }>\n): Serializer<Base58EncodedAddress> {\n    return string({\n        description: config?.description ?? (__DEV__ ? 'A 32-byte account address' : ''),\n        encoding: base58,\n        size: 32,\n    }) as unknown as Serializer<Base58EncodedAddress>;\n}\n\nexport function getBase58EncodedAddressComparator(): (x: string, y: string) => number {\n    return new Intl.Collator('en', {\n        caseFirst: 'lower',\n        ignorePunctuation: false,\n        localeMatcher: 'best fit',\n        numeric: false,\n        sensitivity: 'variant',\n        usage: 'sort',\n    }).compare;\n}\n"]}
+{"version":3,"sources":["../src/key-pair.ts","../src/signatures.ts"],"names":[],"mappings":";AAAA,SAAS,sCAAsC;AAE/C,eAAsB,kBAA0C;AAC5D,QAAM,+BAA+B;AACrC,QAAM,UAAU,MAAM,OAAO,OAAO;AAAA;AAAA,IAChB;AAAA;AAAA;AAAA,IACE;AAAA;AAAA;AAAA,IACC,CAAC,QAAQ,QAAQ;AAAA,EACxC;AACA,SAAO;AACX;;;ACVA,SAAS,oCAAoC,+CAA+C;AAI5F,eAAsB,UAAU,KAAgB,MAA6C;AACzF,QAAM,mCAAmC;AACzC,QAAM,aAAa,MAAM,OAAO,OAAO,KAAK,WAAW,KAAK,IAAI;AAChE,SAAO,IAAI,WAAW,UAAU;AACpC;AAEA,eAAsB,gBAAgB,KAAgB,WAA6B,MAAoC;AACnH,QAAM,wCAAwC;AAC9C,SAAO,MAAM,OAAO,OAAO,OAAO,WAAW,KAAK,WAAW,IAAI;AACrE","sourcesContent":["import { assertKeyGenerationIsAvailable } from '@solana/assertions';\n\nexport async function generateKeyPair(): Promise<CryptoKeyPair> {\n    await assertKeyGenerationIsAvailable();\n    const keyPair = await crypto.subtle.generateKey(\n        /* algorithm */ 'Ed25519', // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20\n        /* extractable */ false, // Prevents the bytes of the private key from being visible to JS.\n        /* allowed uses */ ['sign', 'verify']\n    );\n    return keyPair as CryptoKeyPair;\n}\n","import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';\n\nexport type Ed25519Signature = Uint8Array & { readonly __ed25519Signature: unique symbol };\n\nexport async function signBytes(key: CryptoKey, data: Uint8Array): Promise<Ed25519Signature> {\n    await assertSigningCapabilityIsAvailable();\n    const signedData = await crypto.subtle.sign('Ed25519', key, data);\n    return new Uint8Array(signedData) as Ed25519Signature;\n}\n\nexport async function verifySignature(key: CryptoKey, signature: Ed25519Signature, data: Uint8Array): Promise<boolean> {\n    await assertVerificationCapabilityIsAvailable();\n    return await crypto.subtle.verify('Ed25519', key, signature, data);\n}\n"]}

package/dist/index.development.js

@@ -2,312 +2,90 @@ this.globalThis = this.globalThis || {};
 this.globalThis.solanaWeb3 = (function (exports) {
   'use strict';
 
-  var __defProp = Object.defineProperty;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField = (obj, key, value) => {
-    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/bytes.mjs
-  var mergeBytes = (bytesArr) => {
-    const totalLength = bytesArr.reduce((total, arr) => total + arr.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    bytesArr.forEach((arr) => {
-      result.set(arr, offset);
-      offset += arr.length;
-    });
-    return result;
-  };
-  var padBytes = (bytes, length) => {
-    if (bytes.length >= length)
-      return bytes;
-    const paddedBytes = new Uint8Array(length).fill(0);
-    paddedBytes.set(bytes);
-    return paddedBytes;
-  };
-  var fixBytes = (bytes, length) => padBytes(bytes.slice(0, length), length);
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/errors.mjs
-  var DeserializingEmptyBufferError = class extends Error {
-    constructor(serializer) {
-      super(`Serializer [${serializer}] cannot deserialize empty buffers.`);
-      __publicField(this, "name", "DeserializingEmptyBufferError");
-    }
-  };
-  var NotEnoughBytesError = class extends Error {
-    constructor(serializer, expected, actual) {
-      super(`Serializer [${serializer}] expected ${expected} bytes, got ${actual}.`);
-      __publicField(this, "name", "NotEnoughBytesError");
+  // ../assertions/dist/index.browser.js
+  function assertIsSecureContext() {
+    if (!globalThis.isSecureContext) {
+      throw new Error(
+        "Cryptographic operations are only allowed in secure browser contexts. Read more here: https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts"
+      );
     }
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/fixSerializer.mjs
-  function fixSerializer(serializer, fixedBytes, description) {
-    return {
-      description: description ?? `fixed(${fixedBytes}, ${serializer.description})`,
-      fixedSize: fixedBytes,
-      maxSize: fixedBytes,
-      serialize: (value) => fixBytes(serializer.serialize(value), fixedBytes),
-      deserialize: (buffer, offset = 0) => {
-        buffer = buffer.slice(offset, offset + fixedBytes);
-        if (buffer.length < fixedBytes) {
-          throw new NotEnoughBytesError("fixSerializer", fixedBytes, buffer.length);
-        }
-        if (serializer.fixedSize !== null) {
-          buffer = fixBytes(buffer, serializer.fixedSize);
-        }
-        const [value] = serializer.deserialize(buffer, 0);
-        return [value, offset + fixedBytes];
-      }
-    };
   }
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/errors.mjs
-  var InvalidBaseStringError = class extends Error {
-    constructor(value, base, cause) {
-      const message = `Expected a string of base ${base}, got [${value}].`;
-      super(message);
-      __publicField(this, "name", "InvalidBaseStringError");
-      this.cause = cause;
-    }
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
-  var baseX = (alphabet) => {
-    const base = alphabet.length;
-    const baseBigInt = BigInt(base);
-    return {
-      description: `base${base}`,
-      fixedSize: null,
-      maxSize: null,
-      serialize(value) {
-        if (!value.match(new RegExp(`^[${alphabet}]*$`))) {
-          throw new InvalidBaseStringError(value, base);
-        }
-        if (value === "")
-          return new Uint8Array();
-        const chars = [...value];
-        let trailIndex = chars.findIndex((c) => c !== alphabet[0]);
-        trailIndex = trailIndex === -1 ? chars.length : trailIndex;
-        const leadingZeroes = Array(trailIndex).fill(0);
-        if (trailIndex === chars.length)
-          return Uint8Array.from(leadingZeroes);
-        const tailChars = chars.slice(trailIndex);
-        let base10Number = 0n;
-        let baseXPower = 1n;
-        for (let i = tailChars.length - 1; i >= 0; i -= 1) {
-          base10Number += baseXPower * BigInt(alphabet.indexOf(tailChars[i]));
-          baseXPower *= baseBigInt;
-        }
-        const tailBytes = [];
-        while (base10Number > 0n) {
-          tailBytes.unshift(Number(base10Number % 256n));
-          base10Number /= 256n;
-        }
-        return Uint8Array.from(leadingZeroes.concat(tailBytes));
-      },
-      deserialize(buffer, offset = 0) {
-        if (buffer.length === 0)
-          return ["", 0];
-        const bytes = buffer.slice(offset);
-        let trailIndex = bytes.findIndex((n) => n !== 0);
-        trailIndex = trailIndex === -1 ? bytes.length : trailIndex;
-        const leadingZeroes = alphabet[0].repeat(trailIndex);
-        if (trailIndex === bytes.length)
-          return [leadingZeroes, buffer.length];
-        let base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);
-        const tailChars = [];
-        while (base10Number > 0n) {
-          tailChars.unshift(alphabet[Number(base10Number % baseBigInt)]);
-          base10Number /= baseBigInt;
-        }
-        return [leadingZeroes + tailChars.join(""), buffer.length];
-      }
-    };
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/base58.mjs
-  var base58 = baseX("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/nullCharacters.mjs
-  var removeNullCharacters = (value) => (
-    // eslint-disable-next-line no-control-regex
-    value.replace(/\u0000/g, "")
-  );
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/utf8.mjs
-  var utf8 = {
-    description: "utf8",
-    fixedSize: null,
-    maxSize: null,
-    serialize(value) {
-      return new TextEncoder().encode(value);
-    },
-    deserialize(buffer, offset = 0) {
-      const value = new TextDecoder().decode(buffer.slice(offset));
-      return [removeNullCharacters(value), buffer.length];
-    }
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/common.mjs
-  var Endian;
-  (function(Endian2) {
-    Endian2["Little"] = "le";
-    Endian2["Big"] = "be";
-  })(Endian || (Endian = {}));
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/errors.mjs
-  var NumberOutOfRangeError = class extends RangeError {
-    constructor(serializer, min, max, actual) {
-      super(`Serializer [${serializer}] expected number to be between ${min} and ${max}, got ${actual}.`);
-      __publicField(this, "name", "NumberOutOfRangeError");
+  var cachedEd25519Decision;
+  async function isEd25519CurveSupported(subtle) {
+    if (cachedEd25519Decision === void 0) {
+      cachedEd25519Decision = new Promise((resolve) => {
+        subtle.generateKey(
+          "Ed25519",
+          /* extractable */
+          false,
+          ["sign", "verify"]
+        ).catch(() => {
+          resolve(cachedEd25519Decision = false);
+        }).then(() => {
+          resolve(cachedEd25519Decision = true);
+        });
+      });
     }
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/utils.mjs
-  function numberFactory(input) {
-    let littleEndian;
-    let defaultDescription = input.name;
-    if (input.size > 1) {
-      littleEndian = !("endian" in input.options) || input.options.endian === Endian.Little;
-      defaultDescription += littleEndian ? "(le)" : "(be)";
+    if (typeof cachedEd25519Decision === "boolean") {
+      return cachedEd25519Decision;
+    } else {
+      return await cachedEd25519Decision;
     }
-    return {
-      description: input.options.description ?? defaultDescription,
-      fixedSize: input.size,
-      maxSize: input.size,
-      serialize(value) {
-        if (input.range) {
-          assertRange(input.name, input.range[0], input.range[1], value);
-        }
-        const buffer = new ArrayBuffer(input.size);
-        input.set(new DataView(buffer), value, littleEndian);
-        return new Uint8Array(buffer);
-      },
-      deserialize(bytes, offset = 0) {
-        const slice = bytes.slice(offset, offset + input.size);
-        assertEnoughBytes("i8", slice, input.size);
-        const view = toDataView(slice);
-        return [input.get(view, littleEndian), offset + input.size];
-      }
-    };
   }
-  var toArrayBuffer = (array) => array.buffer.slice(array.byteOffset, array.byteLength + array.byteOffset);
-  var toDataView = (array) => new DataView(toArrayBuffer(array));
-  var assertRange = (serializer, min, max, value) => {
-    if (value < min || value > max) {
-      throw new NumberOutOfRangeError(serializer, min, max, value);
+  async function assertKeyGenerationIsAvailable() {
+    assertIsSecureContext();
+    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.generateKey !== "function") {
+      throw new Error("No key generation implementation could be found");
     }
-  };
-  var assertEnoughBytes = (serializer, bytes, expected) => {
-    if (bytes.length === 0) {
-      throw new DeserializingEmptyBufferError(serializer);
+    if (!await isEd25519CurveSupported(globalThis.crypto.subtle)) {
+      throw new Error(
+        "This runtime does not support the generation of Ed25519 key pairs.\n\nInstall and import `@solana/webcrypto-ed25519-polyfill` before generating keys in environments that do not support Ed25519.\n\nFor a list of runtimes that currently support Ed25519 operations, visit https://github.com/WICG/webcrypto-secure-curves/issues/20"
+      );
     }
-    if (bytes.length < expected) {
-      throw new NotEnoughBytesError(serializer, expected, bytes.length);
-    }
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u32.mjs
-  var u32 = (options = {}) => numberFactory({
-    name: "u32",
-    size: 4,
-    range: [0, Number("0xffffffff")],
-    set: (view, value, le) => view.setUint32(0, Number(value), le),
-    get: (view, le) => view.getUint32(0, le),
-    options
-  });
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/utils.mjs
-  function getSizeDescription(size) {
-    return typeof size === "object" ? size.description : `${size}`;
   }
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/string.mjs
-  function string(options = {}) {
-    const size = options.size ?? u32();
-    const encoding = options.encoding ?? utf8;
-    const description = options.description ?? `string(${encoding.description}; ${getSizeDescription(size)})`;
-    if (size === "variable") {
-      return {
-        ...encoding,
-        description
-      };
+  async function assertSigningCapabilityIsAvailable() {
+    assertIsSecureContext();
+    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.sign !== "function") {
+      throw new Error("No signing implementation could be found");
     }
-    if (typeof size === "number") {
-      return fixSerializer(encoding, size, description);
+  }
+  async function assertVerificationCapabilityIsAvailable() {
+    assertIsSecureContext();
+    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.verify !== "function") {
+      throw new Error("No signature verification implementation could be found");
     }
-    return {
-      description,
-      fixedSize: null,
-      maxSize: null,
-      serialize: (value) => {
-        const contentBytes = encoding.serialize(value);
-        const lengthBytes = size.serialize(contentBytes.length);
-        return mergeBytes([lengthBytes, contentBytes]);
-      },
-      deserialize: (buffer, offset = 0) => {
-        if (buffer.slice(offset).length === 0) {
-          throw new DeserializingEmptyBufferError("string");
-        }
-        const [lengthBigInt, lengthOffset] = size.deserialize(buffer, offset);
-        const length = Number(lengthBigInt);
-        offset = lengthOffset;
-        const contentBuffer = buffer.slice(offset, offset + length);
-        if (contentBuffer.length < length) {
-          throw new NotEnoughBytesError("string", length, contentBuffer.length);
-        }
-        const [value, contentOffset] = encoding.deserialize(contentBuffer);
-        offset += contentOffset;
-        return [value, offset];
-      }
-    };
   }
 
-  // src/base58.ts
-  function assertIsBase58EncodedAddress(putativeBase58EncodedAddress) {
-    try {
-      if (
-        // Lowest address (32 bytes of zeroes)
-        putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
-        putativeBase58EncodedAddress.length > 44
-      ) {
-        throw new Error("Expected input string to decode to a byte array of length 32.");
-      }
-      const bytes = base58.serialize(putativeBase58EncodedAddress);
-      const numBytes = bytes.byteLength;
-      if (numBytes !== 32) {
-        throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-      }
-    } catch (e) {
-      throw new Error(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
-        cause: e
-      });
-    }
+  // src/key-pair.ts
+  async function generateKeyPair() {
+    await assertKeyGenerationIsAvailable();
+    const keyPair = await crypto.subtle.generateKey(
+      /* algorithm */
+      "Ed25519",
+      // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20
+      /* extractable */
+      false,
+      // Prevents the bytes of the private key from being visible to JS.
+      /* allowed uses */
+      ["sign", "verify"]
+    );
+    return keyPair;
   }
-  function getBase58EncodedAddressCodec(config) {
-    return string({
-      description: config?.description ?? ("A 32-byte account address" ),
-      encoding: base58,
-      size: 32
-    });
+
+  // src/signatures.ts
+  async function signBytes(key, data) {
+    await assertSigningCapabilityIsAvailable();
+    const signedData = await crypto.subtle.sign("Ed25519", key, data);
+    return new Uint8Array(signedData);
   }
-  function getBase58EncodedAddressComparator() {
-    return new Intl.Collator("en", {
-      caseFirst: "lower",
-      ignorePunctuation: false,
-      localeMatcher: "best fit",
-      numeric: false,
-      sensitivity: "variant",
-      usage: "sort"
-    }).compare;
+  async function verifySignature(key, signature, data) {
+    await assertVerificationCapabilityIsAvailable();
+    return await crypto.subtle.verify("Ed25519", key, signature, data);
   }
 
-  exports.assertIsBase58EncodedAddress = assertIsBase58EncodedAddress;
-  exports.getBase58EncodedAddressCodec = getBase58EncodedAddressCodec;
-  exports.getBase58EncodedAddressComparator = getBase58EncodedAddressComparator;
+  exports.generateKeyPair = generateKeyPair;
+  exports.signBytes = signBytes;
+  exports.verifySignature = verifySignature;
 
   return exports;
 

package/dist/index.development.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/src/bytes.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/src/errors.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/src/fixSerializer.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/src/errors.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/src/baseX.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/src/base58.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/src/nullCharacters.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/src/utf8.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/src/common.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/src/errors.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/src/utils.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/src/u32.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/src/utils.ts","../../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/src/string.ts","../src/base58.ts"],"names":["mergeBytes","bytesArr","totalLength","reduce","total","arr","length","result","Uint8Array","offset","forEach","set","padBytes","bytes","paddedBytes","fill","fixBytes","slice","DeserializingEmptyBufferError","Error","constructor","serializer","name","NotEnoughBytesError","expected","actual","fixSerializer","fixedBytes","description","fixedSize","maxSize","serialize","value","deserialize","buffer","InvalidBaseStringError","base","cause","message","baseX","alphabet","baseBigInt","BigInt","match","RegExp","chars","trailIndex","findIndex","c","leadingZeroes","Array","from","tailChars","base10Number","baseXPower","i","indexOf","tailBytes","unshift","Number","concat","n","repeat","sum","byte","join","base58","removeNullCharacters","replace","utf8","TextEncoder","encode","TextDecoder","decode","Endian","NumberOutOfRangeError","RangeError","min","max","numberFactory","input","littleEndian","defaultDescription","size","options","endian","Little","range","assertRange","ArrayBuffer","DataView","assertEnoughBytes","view","toDataView","get","toArrayBuffer","array","byteOffset","byteLength","u32","le","setUint32","getUint32","getSizeDescription","string","encoding","contentBytes","lengthBytes","lengthBigInt","lengthOffset","contentBuffer","contentOffset"],"mappings":"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","sourcesContent":["/**\n * Concatenates an array of `Uint8Array`s into a single `Uint8Array`.\n * @category Utils\n */\nexport const mergeBytes = (bytesArr: Uint8Array[]): Uint8Array => {\n  const totalLength = bytesArr.reduce((total, arr) => total + arr.length, 0);\n  const result = new Uint8Array(totalLength);\n  let offset = 0;\n  bytesArr.forEach((arr) => {\n    result.set(arr, offset);\n    offset += arr.length;\n  });\n  return result;\n};\n\n/**\n * Pads a `Uint8Array` with zeroes to the specified length.\n * If the array is longer than the specified length, it is returned as-is.\n * @category Utils\n */\nexport const padBytes = (bytes: Uint8Array, length: number): Uint8Array => {\n  if (bytes.length >= length) return bytes;\n  const paddedBytes = new Uint8Array(length).fill(0);\n  paddedBytes.set(bytes);\n  return paddedBytes;\n};\n\n/**\n * Fixes a `Uint8Array` to the specified length.\n * If the array is longer than the specified length, it is truncated.\n * If the array is shorter than the specified length, it is padded with zeroes.\n * @category Utils\n */\nexport const fixBytes = (bytes: Uint8Array, length: number): Uint8Array =>\n  padBytes(bytes.slice(0, length), length);\n","/** @category Errors */\nexport class DeserializingEmptyBufferError extends Error {\n  readonly name: string = 'DeserializingEmptyBufferError';\n\n  constructor(serializer: string) {\n    super(`Serializer [${serializer}] cannot deserialize empty buffers.`);\n  }\n}\n\n/** @category Errors */\nexport class NotEnoughBytesError extends Error {\n  readonly name: string = 'NotEnoughBytesError';\n\n  constructor(\n    serializer: string,\n    expected: bigint | number,\n    actual: bigint | number\n  ) {\n    super(\n      `Serializer [${serializer}] expected ${expected} bytes, got ${actual}.`\n    );\n  }\n}\n\n/** @category Errors */\nexport class ExpectedFixedSizeSerializerError extends Error {\n  readonly name: string = 'ExpectedFixedSizeSerializerError';\n\n  constructor(message?: string) {\n    message ??= 'Expected a fixed-size serializer, got a variable-size one.';\n    super(message);\n  }\n}\n","import { fixBytes } from './bytes';\nimport { Serializer } from './common';\nimport { NotEnoughBytesError } from './errors';\n\n/**\n * Creates a fixed-size serializer from a given serializer.\n *\n * @param serializer - The serializer to wrap into a fixed-size serializer.\n * @param fixedBytes - The fixed number of bytes to read.\n * @param description - A custom description for the serializer.\n *\n * @category Serializers\n */\nexport function fixSerializer<T, U extends T = T>(\n  serializer: Serializer<T, U>,\n  fixedBytes: number,\n  description?: string\n): Serializer<T, U> {\n  return {\n    description:\n      description ?? `fixed(${fixedBytes}, ${serializer.description})`,\n    fixedSize: fixedBytes,\n    maxSize: fixedBytes,\n    serialize: (value: T) => fixBytes(serializer.serialize(value), fixedBytes),\n    deserialize: (buffer: Uint8Array, offset = 0) => {\n      // Slice the buffer to the fixed size.\n      buffer = buffer.slice(offset, offset + fixedBytes);\n      // Ensure we have enough bytes.\n      if (buffer.length < fixedBytes) {\n        throw new NotEnoughBytesError(\n          'fixSerializer',\n          fixedBytes,\n          buffer.length\n        );\n      }\n      // If the nested serializer is fixed-size, pad and truncate the buffer accordingly.\n      if (serializer.fixedSize !== null) {\n        buffer = fixBytes(buffer, serializer.fixedSize);\n      }\n      // Deserialize the value using the nested serializer.\n      const [value] = serializer.deserialize(buffer, 0);\n      return [value, offset + fixedBytes];\n    },\n  };\n}\n","/** @category Errors */\nexport class InvalidBaseStringError extends Error {\n  readonly name: string = 'InvalidBaseStringError';\n\n  readonly cause?: Error;\n\n  constructor(value: string, base: number, cause?: Error) {\n    const message = `Expected a string of base ${base}, got [${value}].`;\n    super(message);\n    this.cause = cause;\n  }\n}\n","import type { Serializer } from '@metaplex-foundation/umi-serializers-core';\nimport { InvalidBaseStringError } from './errors';\n\n/**\n * A string serializer that uses a custom alphabet.\n * This can be used to create serializers for base58, base64, etc.\n * @category Serializers\n */\nexport const baseX = (alphabet: string): Serializer<string> => {\n  const base = alphabet.length;\n  const baseBigInt = BigInt(base);\n  return {\n    description: `base${base}`,\n    fixedSize: null,\n    maxSize: null,\n    serialize(value: string): Uint8Array {\n      // Check if the value is valid.\n      if (!value.match(new RegExp(`^[${alphabet}]*$`))) {\n        throw new InvalidBaseStringError(value, base);\n      }\n      if (value === '') return new Uint8Array();\n\n      // Handle leading zeroes.\n      const chars = [...value];\n      let trailIndex = chars.findIndex((c) => c !== alphabet[0]);\n      trailIndex = trailIndex === -1 ? chars.length : trailIndex;\n      const leadingZeroes = Array(trailIndex).fill(0);\n      if (trailIndex === chars.length) return Uint8Array.from(leadingZeroes);\n\n      // From baseX to base10.\n      const tailChars = chars.slice(trailIndex);\n      let base10Number = 0n;\n      let baseXPower = 1n;\n      for (let i = tailChars.length - 1; i >= 0; i -= 1) {\n        base10Number += baseXPower * BigInt(alphabet.indexOf(tailChars[i]));\n        baseXPower *= baseBigInt;\n      }\n\n      // From base10 to bytes.\n      const tailBytes = [];\n      while (base10Number > 0n) {\n        tailBytes.unshift(Number(base10Number % 256n));\n        base10Number /= 256n;\n      }\n      return Uint8Array.from(leadingZeroes.concat(tailBytes));\n    },\n    deserialize(buffer, offset = 0): [string, number] {\n      if (buffer.length === 0) return ['', 0];\n\n      // Handle leading zeroes.\n      const bytes = buffer.slice(offset);\n      let trailIndex = bytes.findIndex((n) => n !== 0);\n      trailIndex = trailIndex === -1 ? bytes.length : trailIndex;\n      const leadingZeroes = alphabet[0].repeat(trailIndex);\n      if (trailIndex === bytes.length) return [leadingZeroes, buffer.length];\n\n      // From bytes to base10.\n      let base10Number = bytes\n        .slice(trailIndex)\n        .reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);\n\n      // From base10 to baseX.\n      const tailChars = [];\n      while (base10Number > 0n) {\n        tailChars.unshift(alphabet[Number(base10Number % baseBigInt)]);\n        base10Number /= baseBigInt;\n      }\n\n      return [leadingZeroes + tailChars.join(''), buffer.length];\n    },\n  };\n};\n","import type { Serializer } from '@metaplex-foundation/umi-serializers-core';\nimport { baseX } from './baseX';\n\n/**\n * A string serializer that uses base58 encoding.\n * @category Serializers\n */\nexport const base58: Serializer<string> = baseX(\n  '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n);\n","/**\n * Removes null characters from a string.\n * @category Utils\n */\nexport const removeNullCharacters = (value: string) =>\n  // eslint-disable-next-line no-control-regex\n  value.replace(/\\u0000/g, '');\n\n/**\n * Pads a string with null characters at the end.\n * @category Utils\n */\nexport const padNullCharacters = (value: string, chars: number) =>\n  value.padEnd(chars, '\\u0000');\n","import type { Serializer } from '@metaplex-foundation/umi-serializers-core';\nimport { removeNullCharacters } from './nullCharacters';\n\n/**\n * A string serializer that uses UTF-8 encoding\n * using the native `TextEncoder` API.\n * @category Serializers\n */\nexport const utf8: Serializer<string> = {\n  description: 'utf8',\n  fixedSize: null,\n  maxSize: null,\n  serialize(value: string) {\n    return new TextEncoder().encode(value);\n  },\n  deserialize(buffer, offset = 0) {\n    const value = new TextDecoder().decode(buffer.slice(offset));\n    return [removeNullCharacters(value), buffer.length];\n  },\n};\n","import {\n  BaseSerializerOptions,\n  Serializer,\n} from '@metaplex-foundation/umi-serializers-core';\n\n/**\n * Defines a serializer for numbers and bigints.\n * @category Serializers\n */\nexport type NumberSerializer =\n  | Serializer<number>\n  | Serializer<number | bigint, bigint>;\n\n/**\n * Defines the options for u8 and i8 serializers.\n * @category Serializers\n */\nexport type SingleByteNumberSerializerOptions = BaseSerializerOptions;\n\n/**\n * Defines the options for number serializers that use more than one byte.\n * @category Serializers\n */\nexport type NumberSerializerOptions = BaseSerializerOptions & {\n  /**\n   * Whether the serializer should use little-endian or big-endian encoding.\n   * @defaultValue `Endian.Little`\n   */\n  endian?: Endian;\n};\n\n/**\n * Defines the endianness of a number serializer.\n * @category Serializers\n */\nexport enum Endian {\n  Little = 'le',\n  Big = 'be',\n}\n","/** @category Errors */\nexport class NumberOutOfRangeError extends RangeError {\n  readonly name: string = 'NumberOutOfRangeError';\n\n  constructor(\n    serializer: string,\n    min: number | bigint,\n    max: number | bigint,\n    actual: number | bigint\n  ) {\n    super(\n      `Serializer [${serializer}] expected number to be between ${min} and ${max}, got ${actual}.`\n    );\n  }\n}\n","import {\n  DeserializingEmptyBufferError,\n  NotEnoughBytesError,\n  Serializer,\n} from '@metaplex-foundation/umi-serializers-core';\nimport {\n  Endian,\n  NumberSerializer,\n  NumberSerializerOptions,\n  SingleByteNumberSerializerOptions,\n} from './common';\nimport { NumberOutOfRangeError } from './errors';\n\nexport function numberFactory(input: {\n  name: string;\n  size: number;\n  range?: [number | bigint, number | bigint];\n  set: (view: DataView, value: number | bigint, littleEndian?: boolean) => void;\n  get: (view: DataView, littleEndian?: boolean) => number;\n  options: SingleByteNumberSerializerOptions | NumberSerializerOptions;\n}): Serializer<number>;\nexport function numberFactory(input: {\n  name: string;\n  size: number;\n  range?: [number | bigint, number | bigint];\n  set: (view: DataView, value: number | bigint, littleEndian?: boolean) => void;\n  get: (view: DataView, littleEndian?: boolean) => bigint;\n  options: SingleByteNumberSerializerOptions | NumberSerializerOptions;\n}): Serializer<number | bigint, bigint>;\nexport function numberFactory(input: {\n  name: string;\n  size: number;\n  range?: [number | bigint, number | bigint];\n  set: (view: DataView, value: number | bigint, littleEndian?: boolean) => void;\n  get: (view: DataView, littleEndian?: boolean) => number | bigint;\n  options: SingleByteNumberSerializerOptions | NumberSerializerOptions;\n}): NumberSerializer {\n  let littleEndian: boolean | undefined;\n  let defaultDescription: string = input.name;\n\n  if (input.size > 1) {\n    littleEndian =\n      !('endian' in input.options) || input.options.endian === Endian.Little;\n    defaultDescription += littleEndian ? '(le)' : '(be)';\n  }\n\n  return {\n    description: input.options.description ?? defaultDescription,\n    fixedSize: input.size,\n    maxSize: input.size,\n    serialize(value: number | bigint): Uint8Array {\n      if (input.range) {\n        assertRange(input.name, input.range[0], input.range[1], value);\n      }\n      const buffer = new ArrayBuffer(input.size);\n      input.set(new DataView(buffer), value, littleEndian);\n      return new Uint8Array(buffer);\n    },\n    deserialize(bytes, offset = 0): [number | bigint, number] {\n      const slice = bytes.slice(offset, offset + input.size);\n      assertEnoughBytes('i8', slice, input.size);\n      const view = toDataView(slice);\n      return [input.get(view, littleEndian), offset + input.size];\n    },\n  } as NumberSerializer;\n}\n\n/**\n * Helper function to ensure that the array buffer is converted properly from a uint8array\n * Source: https://stackoverflow.com/questions/37228285/uint8array-to-arraybuffer\n * @param {Uint8Array} array Uint8array that's being converted into an array buffer\n * @returns {ArrayBuffer} An array buffer that's necessary to construct a data view\n */\nexport const toArrayBuffer = (array: Uint8Array): ArrayBuffer =>\n  array.buffer.slice(array.byteOffset, array.byteLength + array.byteOffset);\n\nexport const toDataView = (array: Uint8Array): DataView =>\n  new DataView(toArrayBuffer(array));\n\nexport const assertRange = (\n  serializer: string,\n  min: number | bigint,\n  max: number | bigint,\n  value: number | bigint\n) => {\n  if (value < min || value > max) {\n    throw new NumberOutOfRangeError(serializer, min, max, value);\n  }\n};\n\nexport const assertEnoughBytes = (\n  serializer: string,\n  bytes: Uint8Array,\n  expected: number\n) => {\n  if (bytes.length === 0) {\n    throw new DeserializingEmptyBufferError(serializer);\n  }\n  if (bytes.length < expected) {\n    throw new NotEnoughBytesError(serializer, expected, bytes.length);\n  }\n};\n","import { Serializer } from '@metaplex-foundation/umi-serializers-core';\nimport { NumberSerializerOptions } from './common';\nimport { numberFactory } from './utils';\n\nexport const u32 = (\n  options: NumberSerializerOptions = {}\n): Serializer<number> =>\n  numberFactory({\n    name: 'u32',\n    size: 4,\n    range: [0, Number('0xffffffff')],\n    set: (view, value, le) => view.setUint32(0, Number(value), le),\n    get: (view, le) => view.getUint32(0, le),\n    options,\n  });\n","import { ExpectedFixedSizeSerializerError } from '@metaplex-foundation/umi-serializers-core';\nimport { ArrayLikeSerializerSize } from './arrayLikeSerializerSize';\nimport {\n  InvalidArrayLikeRemainderSizeError,\n  UnrecognizedArrayLikeSerializerSizeError,\n} from './errors';\nimport { sumSerializerSizes } from './sumSerializerSizes';\n\nexport function getResolvedSize(\n  size: ArrayLikeSerializerSize,\n  childrenSizes: (number | null)[],\n  bytes: Uint8Array,\n  offset: number\n): [number | bigint, number] {\n  if (typeof size === 'number') {\n    return [size, offset];\n  }\n\n  if (typeof size === 'object') {\n    return size.deserialize(bytes, offset);\n  }\n\n  if (size === 'remainder') {\n    const childrenSize = sumSerializerSizes(childrenSizes);\n    if (childrenSize === null) {\n      throw new ExpectedFixedSizeSerializerError(\n        'Serializers of \"remainder\" size must have fixed-size items.'\n      );\n    }\n    const remainder = bytes.slice(offset).length;\n    if (remainder % childrenSize !== 0) {\n      throw new InvalidArrayLikeRemainderSizeError(remainder, childrenSize);\n    }\n    return [remainder / childrenSize, offset];\n  }\n\n  throw new UnrecognizedArrayLikeSerializerSizeError(size);\n}\n\nexport function getSizeDescription(\n  size: ArrayLikeSerializerSize | string\n): string {\n  return typeof size === 'object' ? size.description : `${size}`;\n}\n\nexport function getSizeFromChildren(\n  size: ArrayLikeSerializerSize,\n  childrenSizes: (number | null)[]\n): number | null {\n  if (typeof size !== 'number') return null;\n  if (size === 0) return 0;\n  const childrenSize = sumSerializerSizes(childrenSizes);\n  return childrenSize === null ? null : childrenSize * size;\n}\n\nexport function getSizePrefix(\n  size: ArrayLikeSerializerSize,\n  realSize: number\n): Uint8Array {\n  return typeof size === 'object' ? size.serialize(realSize) : new Uint8Array();\n}\n","import {\n  BaseSerializerOptions,\n  DeserializingEmptyBufferError,\n  NotEnoughBytesError,\n  Serializer,\n  fixSerializer,\n  mergeBytes,\n} from '@metaplex-foundation/umi-serializers-core';\nimport { utf8 } from '@metaplex-foundation/umi-serializers-encodings';\nimport {\n  NumberSerializer,\n  u32,\n} from '@metaplex-foundation/umi-serializers-numbers';\nimport { getSizeDescription } from './utils';\n\n/**\n * Defines the options for string serializers.\n * @category Serializers\n */\nexport type StringSerializerOptions = BaseSerializerOptions & {\n  /**\n   * The size of the string. It can be one of the following:\n   * - a {@link NumberSerializer} that prefixes the string with its size.\n   * - a fixed number of bytes.\n   * - or `'variable'` to use the rest of the buffer.\n   * @defaultValue `u32()`\n   */\n  size?: NumberSerializer | number | 'variable';\n  /**\n   * The string serializer to use for encoding and decoding the content.\n   * @defaultValue `utf8`\n   */\n  encoding?: Serializer<string>;\n};\n\n/**\n * Creates a string serializer.\n *\n * @param options - A set of options for the serializer.\n * @category Serializers\n */\nexport function string(\n  options: StringSerializerOptions = {}\n): Serializer<string> {\n  const size = options.size ?? u32();\n  const encoding = options.encoding ?? utf8;\n  const description =\n    options.description ??\n    `string(${encoding.description}; ${getSizeDescription(size)})`;\n\n  if (size === 'variable') {\n    return { ...encoding, description };\n  }\n\n  if (typeof size === 'number') {\n    return fixSerializer(encoding, size, description);\n  }\n\n  return {\n    description,\n    fixedSize: null,\n    maxSize: null,\n    serialize: (value: string) => {\n      const contentBytes = encoding.serialize(value);\n      const lengthBytes = size.serialize(contentBytes.length);\n      return mergeBytes([lengthBytes, contentBytes]);\n    },\n    deserialize: (buffer: Uint8Array, offset = 0) => {\n      if (buffer.slice(offset).length === 0) {\n        throw new DeserializingEmptyBufferError('string');\n      }\n      const [lengthBigInt, lengthOffset] = size.deserialize(buffer, offset);\n      const length = Number(lengthBigInt);\n      offset = lengthOffset;\n      const contentBuffer = buffer.slice(offset, offset + length);\n      if (contentBuffer.length < length) {\n        throw new NotEnoughBytesError('string', length, contentBuffer.length);\n      }\n      const [value, contentOffset] = encoding.deserialize(contentBuffer);\n      offset += contentOffset;\n      return [value, offset];\n    },\n  };\n}\n","import { base58, Serializer, string } from '@metaplex-foundation/umi-serializers';\n\nexport type Base58EncodedAddress<TAddress extends string = string> = TAddress & {\n    readonly __base58EncodedAddress: unique symbol;\n};\n\nexport function assertIsBase58EncodedAddress(\n    putativeBase58EncodedAddress: string\n): asserts putativeBase58EncodedAddress is Base58EncodedAddress<typeof putativeBase58EncodedAddress> {\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest address (32 bytes of zeroes)\n            putativeBase58EncodedAddress.length < 32 ||\n            // Highest address (32 bytes of 255)\n            putativeBase58EncodedAddress.length > 44\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 32.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = base58.serialize(putativeBase58EncodedAddress);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 32) {\n            throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeBase58EncodedAddress}\\` is not a base-58 encoded address`, {\n            cause: e,\n        });\n    }\n}\n\nexport function getBase58EncodedAddressCodec(\n    config?: Readonly<{\n        description: string;\n    }>\n): Serializer<Base58EncodedAddress> {\n    return string({\n        description: config?.description ?? (__DEV__ ? 'A 32-byte account address' : ''),\n        encoding: base58,\n        size: 32,\n    }) as unknown as Serializer<Base58EncodedAddress>;\n}\n\nexport function getBase58EncodedAddressComparator(): (x: string, y: string) => number {\n    return new Intl.Collator('en', {\n        caseFirst: 'lower',\n        ignorePunctuation: false,\n        localeMatcher: 'best fit',\n        numeric: false,\n        sensitivity: 'variant',\n        usage: 'sort',\n    }).compare;\n}\n"]}
+{"version":3,"sources":["../../assertions/src/subtle-crypto.ts","../src/key-pair.ts","../src/signatures.ts"],"names":[],"mappings":";AAAA,SAAS,wBAAwB;AAC7B,MAAmB,CAAC,WAAW,iBAAiB;AAE5C,UAAM,IAAI;MACN;IAEJ;EACJ;AACJ;AAEA,IAAI;AACJ,eAAe,wBAAwB,QAAwC;AAC3E,MAAI,0BAA0B,QAAW;AACrC,4BAAwB,IAAI,QAAQ,CAAA,YAAW;AAC3C,aACK;QAAY;;QAA6B;QAAO,CAAC,QAAQ,QAAQ;MAAC,EAClE,MAAM,MAAM;AACT,gBAAS,wBAAwB,KAAM;MAC3C,CAAC,EACA,KAAK,MAAM;AACR,gBAAS,wBAAwB,IAAK;MAC1C,CAAC;IACT,CAAC;EACL;AACA,MAAI,OAAO,0BAA0B,WAAW;AAC5C,WAAO;EACX,OAAO;AACH,WAAO,MAAM;EACjB;AACJ;AAUA,eAAsB,iCAAiC;AACnD,wBAAsB;AACtB,MAAI,OAAO,WAAW,WAAW,eAAe,OAAO,WAAW,OAAO,QAAQ,gBAAgB,YAAY;AAEzG,UAAM,IAAI,MAAM,iDAAiD;EACrE;AACA,MAAI,CAAE,MAAM,wBAAwB,WAAW,OAAO,MAAM,GAAI;AAE5D,UAAM,IAAI;MACN;IAKJ;EACJ;AACJ;AAUA,eAAsB,qCAAqC;AACvD,wBAAsB;AACtB,MAAI,OAAO,WAAW,WAAW,eAAe,OAAO,WAAW,OAAO,QAAQ,SAAS,YAAY;AAElG,UAAM,IAAI,MAAM,0CAA0C;EAC9D;AACJ;AAEA,eAAsB,0CAA0C;AAC5D,wBAAsB;AACtB,MAAI,OAAO,WAAW,WAAW,eAAe,OAAO,WAAW,OAAO,QAAQ,WAAW,YAAY;AAEpG,UAAM,IAAI,MAAM,yDAAyD;EAC7E;AACJ;;;AC7EA,eAAsB,kBAA0C;AAC5D,QAAM,+BAA+B;AACrC,QAAM,UAAU,MAAM,OAAO,OAAO;AAAA;AAAA,IAChB;AAAA;AAAA;AAAA,IACE;AAAA;AAAA;AAAA,IACC,CAAC,QAAQ,QAAQ;AAAA,EACxC;AACA,SAAO;AACX;;;ACNA,eAAsB,UAAU,KAAgB,MAA6C;AACzF,QAAM,mCAAmC;AACzC,QAAM,aAAa,MAAM,OAAO,OAAO,KAAK,WAAW,KAAK,IAAI;AAChE,SAAO,IAAI,WAAW,UAAU;AACpC;AAEA,eAAsB,gBAAgB,KAAgB,WAA6B,MAAoC;AACnH,QAAM,wCAAwC;AAC9C,SAAO,MAAM,OAAO,OAAO,OAAO,WAAW,KAAK,WAAW,IAAI;AACrE","sourcesContent":["function assertIsSecureContext() {\n    if (__BROWSER__ && !globalThis.isSecureContext) {\n        // TODO: Coded error.\n        throw new Error(\n            'Cryptographic operations are only allowed in secure browser contexts. Read more ' +\n                'here: https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts'\n        );\n    }\n}\n\nlet cachedEd25519Decision: PromiseLike<boolean> | boolean | undefined;\nasync function isEd25519CurveSupported(subtle: SubtleCrypto): Promise<boolean> {\n    if (cachedEd25519Decision === undefined) {\n        cachedEd25519Decision = new Promise(resolve => {\n            subtle\n                .generateKey('Ed25519', /* extractable */ false, ['sign', 'verify'])\n                .catch(() => {\n                    resolve((cachedEd25519Decision = false));\n                })\n                .then(() => {\n                    resolve((cachedEd25519Decision = true));\n                });\n        });\n    }\n    if (typeof cachedEd25519Decision === 'boolean') {\n        return cachedEd25519Decision;\n    } else {\n        return await cachedEd25519Decision;\n    }\n}\n\nexport async function assertDigestCapabilityIsAvailable() {\n    assertIsSecureContext();\n    if (typeof globalThis.crypto === 'undefined' || typeof globalThis.crypto.subtle?.digest !== 'function') {\n        // TODO: Coded error.\n        throw new Error('No digest implementation could be found');\n    }\n}\n\nexport async function assertKeyGenerationIsAvailable() {\n    assertIsSecureContext();\n    if (typeof globalThis.crypto === 'undefined' || typeof globalThis.crypto.subtle?.generateKey !== 'function') {\n        // TODO: Coded error.\n        throw new Error('No key generation implementation could be found');\n    }\n    if (!(await isEd25519CurveSupported(globalThis.crypto.subtle))) {\n        // TODO: Coded error.\n        throw new Error(\n            'This runtime does not support the generation of Ed25519 key pairs.\\n\\nInstall and ' +\n                'import `@solana/webcrypto-ed25519-polyfill` before generating keys in ' +\n                'environments that do not support Ed25519.\\n\\nFor a list of runtimes that ' +\n                'currently support Ed25519 operations, visit ' +\n                'https://github.com/WICG/webcrypto-secure-curves/issues/20'\n        );\n    }\n}\n\nexport async function assertKeyExporterIsAvailable() {\n    assertIsSecureContext();\n    if (typeof globalThis.crypto === 'undefined' || typeof globalThis.crypto.subtle?.exportKey !== 'function') {\n        // TODO: Coded error.\n        throw new Error('No key export implementation could be found');\n    }\n}\n\nexport async function assertSigningCapabilityIsAvailable() {\n    assertIsSecureContext();\n    if (typeof globalThis.crypto === 'undefined' || typeof globalThis.crypto.subtle?.sign !== 'function') {\n        // TODO: Coded error.\n        throw new Error('No signing implementation could be found');\n    }\n}\n\nexport async function assertVerificationCapabilityIsAvailable() {\n    assertIsSecureContext();\n    if (typeof globalThis.crypto === 'undefined' || typeof globalThis.crypto.subtle?.verify !== 'function') {\n        // TODO: Coded error.\n        throw new Error('No signature verification implementation could be found');\n    }\n}\n","import { assertKeyGenerationIsAvailable } from '@solana/assertions';\n\nexport async function generateKeyPair(): Promise<CryptoKeyPair> {\n    await assertKeyGenerationIsAvailable();\n    const keyPair = await crypto.subtle.generateKey(\n        /* algorithm */ 'Ed25519', // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20\n        /* extractable */ false, // Prevents the bytes of the private key from being visible to JS.\n        /* allowed uses */ ['sign', 'verify']\n    );\n    return keyPair as CryptoKeyPair;\n}\n","import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';\n\nexport type Ed25519Signature = Uint8Array & { readonly __ed25519Signature: unique symbol };\n\nexport async function signBytes(key: CryptoKey, data: Uint8Array): Promise<Ed25519Signature> {\n    await assertSigningCapabilityIsAvailable();\n    const signedData = await crypto.subtle.sign('Ed25519', key, data);\n    return new Uint8Array(signedData) as Ed25519Signature;\n}\n\nexport async function verifySignature(key: CryptoKey, signature: Ed25519Signature, data: Uint8Array): Promise<boolean> {\n    await assertVerificationCapabilityIsAvailable();\n    return await crypto.subtle.verify('Ed25519', key, signature, data);\n}\n"]}

package/dist/index.native.js

@@ -1,45 +1,30 @@
-import { base58, string } from '@metaplex-foundation/umi-serializers';
+import { assertKeyGenerationIsAvailable, assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';
 
-// ../build-scripts/env-shim.ts
-var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
-function assertIsBase58EncodedAddress(putativeBase58EncodedAddress) {
-  try {
-    if (
-      // Lowest address (32 bytes of zeroes)
-      putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
-      putativeBase58EncodedAddress.length > 44
-    ) {
-      throw new Error("Expected input string to decode to a byte array of length 32.");
-    }
-    const bytes = base58.serialize(putativeBase58EncodedAddress);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
-      cause: e
-    });
-  }
+// src/key-pair.ts
+async function generateKeyPair() {
+  await assertKeyGenerationIsAvailable();
+  const keyPair = await crypto.subtle.generateKey(
+    /* algorithm */
+    "Ed25519",
+    // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20
+    /* extractable */
+    false,
+    // Prevents the bytes of the private key from being visible to JS.
+    /* allowed uses */
+    ["sign", "verify"]
+  );
+  return keyPair;
 }
-function getBase58EncodedAddressCodec(config) {
-  return string({
-    description: config?.description ?? (__DEV__ ? "A 32-byte account address" : ""),
-    encoding: base58,
-    size: 32
-  });
+async function signBytes(key, data) {
+  await assertSigningCapabilityIsAvailable();
+  const signedData = await crypto.subtle.sign("Ed25519", key, data);
+  return new Uint8Array(signedData);
 }
-function getBase58EncodedAddressComparator() {
-  return new Intl.Collator("en", {
-    caseFirst: "lower",
-    ignorePunctuation: false,
-    localeMatcher: "best fit",
-    numeric: false,
-    sensitivity: "variant",
-    usage: "sort"
-  }).compare;
+async function verifySignature(key, signature, data) {
+  await assertVerificationCapabilityIsAvailable();
+  return await crypto.subtle.verify("Ed25519", key, signature, data);
 }
 
-export { assertIsBase58EncodedAddress, getBase58EncodedAddressCodec, getBase58EncodedAddressComparator };
+export { generateKeyPair, signBytes, verifySignature };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.native.js.map

package/dist/index.native.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../build-scripts/env-shim.ts","../src/base58.ts"],"names":[],"mappings":";AACO,IAAM,UAA2B,uBAAO,QAAgB,KAAU,EAAE,aAAa,eAAe;;;ACDvG,SAAS,QAAoB,cAAc;AAMpC,SAAS,6BACZ,8BACiG;AACjG,MAAI;AAEA;AAAA;AAAA,MAEI,6BAA6B,SAAS;AAAA,MAEtC,6BAA6B,SAAS;AAAA,MACxC;AACE,YAAM,IAAI,MAAM,+DAA+D;AAAA,IACnF;AAEA,UAAM,QAAQ,OAAO,UAAU,4BAA4B;AAC3D,UAAM,WAAW,MAAM;AACvB,QAAI,aAAa,IAAI;AACjB,YAAM,IAAI,MAAM,gFAAgF,UAAU;AAAA,IAC9G;AAAA,EACJ,SAAS,GAAP;AACE,UAAM,IAAI,MAAM,KAAK,mEAAmE;AAAA,MACpF,OAAO;AAAA,IACX,CAAC;AAAA,EACL;AACJ;AAEO,SAAS,6BACZ,QAGgC;AAChC,SAAO,OAAO;AAAA,IACV,aAAa,QAAQ,gBAAgB,UAAU,8BAA8B;AAAA,IAC7E,UAAU;AAAA,IACV,MAAM;AAAA,EACV,CAAC;AACL;AAEO,SAAS,oCAAsE;AAClF,SAAO,IAAI,KAAK,SAAS,MAAM;AAAA,IAC3B,WAAW;AAAA,IACX,mBAAmB;AAAA,IACnB,eAAe;AAAA,IACf,SAAS;AAAA,IACT,aAAa;AAAA,IACb,OAAO;AAAA,EACX,CAAC,EAAE;AACP","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","import { base58, Serializer, string } from '@metaplex-foundation/umi-serializers';\n\nexport type Base58EncodedAddress<TAddress extends string = string> = TAddress & {\n    readonly __base58EncodedAddress: unique symbol;\n};\n\nexport function assertIsBase58EncodedAddress(\n    putativeBase58EncodedAddress: string\n): asserts putativeBase58EncodedAddress is Base58EncodedAddress<typeof putativeBase58EncodedAddress> {\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest address (32 bytes of zeroes)\n            putativeBase58EncodedAddress.length < 32 ||\n            // Highest address (32 bytes of 255)\n            putativeBase58EncodedAddress.length > 44\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 32.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = base58.serialize(putativeBase58EncodedAddress);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 32) {\n            throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeBase58EncodedAddress}\\` is not a base-58 encoded address`, {\n            cause: e,\n        });\n    }\n}\n\nexport function getBase58EncodedAddressCodec(\n    config?: Readonly<{\n        description: string;\n    }>\n): Serializer<Base58EncodedAddress> {\n    return string({\n        description: config?.description ?? (__DEV__ ? 'A 32-byte account address' : ''),\n        encoding: base58,\n        size: 32,\n    }) as unknown as Serializer<Base58EncodedAddress>;\n}\n\nexport function getBase58EncodedAddressComparator(): (x: string, y: string) => number {\n    return new Intl.Collator('en', {\n        caseFirst: 'lower',\n        ignorePunctuation: false,\n        localeMatcher: 'best fit',\n        numeric: false,\n        sensitivity: 'variant',\n        usage: 'sort',\n    }).compare;\n}\n"]}
+{"version":3,"sources":["../src/key-pair.ts","../src/signatures.ts"],"names":[],"mappings":";AAAA,SAAS,sCAAsC;AAE/C,eAAsB,kBAA0C;AAC5D,QAAM,+BAA+B;AACrC,QAAM,UAAU,MAAM,OAAO,OAAO;AAAA;AAAA,IAChB;AAAA;AAAA;AAAA,IACE;AAAA;AAAA;AAAA,IACC,CAAC,QAAQ,QAAQ;AAAA,EACxC;AACA,SAAO;AACX;;;ACVA,SAAS,oCAAoC,+CAA+C;AAI5F,eAAsB,UAAU,KAAgB,MAA6C;AACzF,QAAM,mCAAmC;AACzC,QAAM,aAAa,MAAM,OAAO,OAAO,KAAK,WAAW,KAAK,IAAI;AAChE,SAAO,IAAI,WAAW,UAAU;AACpC;AAEA,eAAsB,gBAAgB,KAAgB,WAA6B,MAAoC;AACnH,QAAM,wCAAwC;AAC9C,SAAO,MAAM,OAAO,OAAO,OAAO,WAAW,KAAK,WAAW,IAAI;AACrE","sourcesContent":["import { assertKeyGenerationIsAvailable } from '@solana/assertions';\n\nexport async function generateKeyPair(): Promise<CryptoKeyPair> {\n    await assertKeyGenerationIsAvailable();\n    const keyPair = await crypto.subtle.generateKey(\n        /* algorithm */ 'Ed25519', // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20\n        /* extractable */ false, // Prevents the bytes of the private key from being visible to JS.\n        /* allowed uses */ ['sign', 'verify']\n    );\n    return keyPair as CryptoKeyPair;\n}\n","import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';\n\nexport type Ed25519Signature = Uint8Array & { readonly __ed25519Signature: unique symbol };\n\nexport async function signBytes(key: CryptoKey, data: Uint8Array): Promise<Ed25519Signature> {\n    await assertSigningCapabilityIsAvailable();\n    const signedData = await crypto.subtle.sign('Ed25519', key, data);\n    return new Uint8Array(signedData) as Ed25519Signature;\n}\n\nexport async function verifySignature(key: CryptoKey, signature: Ed25519Signature, data: Uint8Array): Promise<boolean> {\n    await assertVerificationCapabilityIsAvailable();\n    return await crypto.subtle.verify('Ed25519', key, signature, data);\n}\n"]}

package/dist/index.node.cjs

@@ -1,49 +1,34 @@
 'use strict';
 
-var umiSerializers = require('@metaplex-foundation/umi-serializers');
+var assertions = require('@solana/assertions');
 
-// ../build-scripts/env-shim.ts
-var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
-function assertIsBase58EncodedAddress(putativeBase58EncodedAddress) {
-  try {
-    if (
-      // Lowest address (32 bytes of zeroes)
-      putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
-      putativeBase58EncodedAddress.length > 44
-    ) {
-      throw new Error("Expected input string to decode to a byte array of length 32.");
-    }
-    const bytes = umiSerializers.base58.serialize(putativeBase58EncodedAddress);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
-      cause: e
-    });
-  }
+// src/key-pair.ts
+async function generateKeyPair() {
+  await assertions.assertKeyGenerationIsAvailable();
+  const keyPair = await crypto.subtle.generateKey(
+    /* algorithm */
+    "Ed25519",
+    // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20
+    /* extractable */
+    false,
+    // Prevents the bytes of the private key from being visible to JS.
+    /* allowed uses */
+    ["sign", "verify"]
+  );
+  return keyPair;
 }
-function getBase58EncodedAddressCodec(config) {
-  return umiSerializers.string({
-    description: config?.description ?? (__DEV__ ? "A 32-byte account address" : ""),
-    encoding: umiSerializers.base58,
-    size: 32
-  });
+async function signBytes(key, data) {
+  await assertions.assertSigningCapabilityIsAvailable();
+  const signedData = await crypto.subtle.sign("Ed25519", key, data);
+  return new Uint8Array(signedData);
 }
-function getBase58EncodedAddressComparator() {
-  return new Intl.Collator("en", {
-    caseFirst: "lower",
-    ignorePunctuation: false,
-    localeMatcher: "best fit",
-    numeric: false,
-    sensitivity: "variant",
-    usage: "sort"
-  }).compare;
+async function verifySignature(key, signature, data) {
+  await assertions.assertVerificationCapabilityIsAvailable();
+  return await crypto.subtle.verify("Ed25519", key, signature, data);
 }
 
-exports.assertIsBase58EncodedAddress = assertIsBase58EncodedAddress;
-exports.getBase58EncodedAddressCodec = getBase58EncodedAddressCodec;
-exports.getBase58EncodedAddressComparator = getBase58EncodedAddressComparator;
+exports.generateKeyPair = generateKeyPair;
+exports.signBytes = signBytes;
+exports.verifySignature = verifySignature;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.node.cjs.map

package/dist/index.node.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../build-scripts/env-shim.ts","../src/base58.ts"],"names":[],"mappings":";AACO,IAAM,UAA2B,uBAAO,QAAgB,KAAU,EAAE,aAAa,eAAe;;;ACDvG,SAAS,QAAoB,cAAc;AAMpC,SAAS,6BACZ,8BACiG;AACjG,MAAI;AAEA;AAAA;AAAA,MAEI,6BAA6B,SAAS;AAAA,MAEtC,6BAA6B,SAAS;AAAA,MACxC;AACE,YAAM,IAAI,MAAM,+DAA+D;AAAA,IACnF;AAEA,UAAM,QAAQ,OAAO,UAAU,4BAA4B;AAC3D,UAAM,WAAW,MAAM;AACvB,QAAI,aAAa,IAAI;AACjB,YAAM,IAAI,MAAM,gFAAgF,UAAU;AAAA,IAC9G;AAAA,EACJ,SAAS,GAAP;AACE,UAAM,IAAI,MAAM,KAAK,mEAAmE;AAAA,MACpF,OAAO;AAAA,IACX,CAAC;AAAA,EACL;AACJ;AAEO,SAAS,6BACZ,QAGgC;AAChC,SAAO,OAAO;AAAA,IACV,aAAa,QAAQ,gBAAgB,UAAU,8BAA8B;AAAA,IAC7E,UAAU;AAAA,IACV,MAAM;AAAA,EACV,CAAC;AACL;AAEO,SAAS,oCAAsE;AAClF,SAAO,IAAI,KAAK,SAAS,MAAM;AAAA,IAC3B,WAAW;AAAA,IACX,mBAAmB;AAAA,IACnB,eAAe;AAAA,IACf,SAAS;AAAA,IACT,aAAa;AAAA,IACb,OAAO;AAAA,EACX,CAAC,EAAE;AACP","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","import { base58, Serializer, string } from '@metaplex-foundation/umi-serializers';\n\nexport type Base58EncodedAddress<TAddress extends string = string> = TAddress & {\n    readonly __base58EncodedAddress: unique symbol;\n};\n\nexport function assertIsBase58EncodedAddress(\n    putativeBase58EncodedAddress: string\n): asserts putativeBase58EncodedAddress is Base58EncodedAddress<typeof putativeBase58EncodedAddress> {\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest address (32 bytes of zeroes)\n            putativeBase58EncodedAddress.length < 32 ||\n            // Highest address (32 bytes of 255)\n            putativeBase58EncodedAddress.length > 44\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 32.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = base58.serialize(putativeBase58EncodedAddress);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 32) {\n            throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeBase58EncodedAddress}\\` is not a base-58 encoded address`, {\n            cause: e,\n        });\n    }\n}\n\nexport function getBase58EncodedAddressCodec(\n    config?: Readonly<{\n        description: string;\n    }>\n): Serializer<Base58EncodedAddress> {\n    return string({\n        description: config?.description ?? (__DEV__ ? 'A 32-byte account address' : ''),\n        encoding: base58,\n        size: 32,\n    }) as unknown as Serializer<Base58EncodedAddress>;\n}\n\nexport function getBase58EncodedAddressComparator(): (x: string, y: string) => number {\n    return new Intl.Collator('en', {\n        caseFirst: 'lower',\n        ignorePunctuation: false,\n        localeMatcher: 'best fit',\n        numeric: false,\n        sensitivity: 'variant',\n        usage: 'sort',\n    }).compare;\n}\n"]}
+{"version":3,"sources":["../src/key-pair.ts","../src/signatures.ts"],"names":[],"mappings":";AAAA,SAAS,sCAAsC;AAE/C,eAAsB,kBAA0C;AAC5D,QAAM,+BAA+B;AACrC,QAAM,UAAU,MAAM,OAAO,OAAO;AAAA;AAAA,IAChB;AAAA;AAAA;AAAA,IACE;AAAA;AAAA;AAAA,IACC,CAAC,QAAQ,QAAQ;AAAA,EACxC;AACA,SAAO;AACX;;;ACVA,SAAS,oCAAoC,+CAA+C;AAI5F,eAAsB,UAAU,KAAgB,MAA6C;AACzF,QAAM,mCAAmC;AACzC,QAAM,aAAa,MAAM,OAAO,OAAO,KAAK,WAAW,KAAK,IAAI;AAChE,SAAO,IAAI,WAAW,UAAU;AACpC;AAEA,eAAsB,gBAAgB,KAAgB,WAA6B,MAAoC;AACnH,QAAM,wCAAwC;AAC9C,SAAO,MAAM,OAAO,OAAO,OAAO,WAAW,KAAK,WAAW,IAAI;AACrE","sourcesContent":["import { assertKeyGenerationIsAvailable } from '@solana/assertions';\n\nexport async function generateKeyPair(): Promise<CryptoKeyPair> {\n    await assertKeyGenerationIsAvailable();\n    const keyPair = await crypto.subtle.generateKey(\n        /* algorithm */ 'Ed25519', // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20\n        /* extractable */ false, // Prevents the bytes of the private key from being visible to JS.\n        /* allowed uses */ ['sign', 'verify']\n    );\n    return keyPair as CryptoKeyPair;\n}\n","import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';\n\nexport type Ed25519Signature = Uint8Array & { readonly __ed25519Signature: unique symbol };\n\nexport async function signBytes(key: CryptoKey, data: Uint8Array): Promise<Ed25519Signature> {\n    await assertSigningCapabilityIsAvailable();\n    const signedData = await crypto.subtle.sign('Ed25519', key, data);\n    return new Uint8Array(signedData) as Ed25519Signature;\n}\n\nexport async function verifySignature(key: CryptoKey, signature: Ed25519Signature, data: Uint8Array): Promise<boolean> {\n    await assertVerificationCapabilityIsAvailable();\n    return await crypto.subtle.verify('Ed25519', key, signature, data);\n}\n"]}

package/dist/index.node.js

@@ -1,45 +1,30 @@
-import { base58, string } from '@metaplex-foundation/umi-serializers';
+import { assertKeyGenerationIsAvailable, assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';
 
-// ../build-scripts/env-shim.ts
-var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
-function assertIsBase58EncodedAddress(putativeBase58EncodedAddress) {
-  try {
-    if (
-      // Lowest address (32 bytes of zeroes)
-      putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
-      putativeBase58EncodedAddress.length > 44
-    ) {
-      throw new Error("Expected input string to decode to a byte array of length 32.");
-    }
-    const bytes = base58.serialize(putativeBase58EncodedAddress);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
-      cause: e
-    });
-  }
+// src/key-pair.ts
+async function generateKeyPair() {
+  await assertKeyGenerationIsAvailable();
+  const keyPair = await crypto.subtle.generateKey(
+    /* algorithm */
+    "Ed25519",
+    // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20
+    /* extractable */
+    false,
+    // Prevents the bytes of the private key from being visible to JS.
+    /* allowed uses */
+    ["sign", "verify"]
+  );
+  return keyPair;
 }
-function getBase58EncodedAddressCodec(config) {
-  return string({
-    description: config?.description ?? (__DEV__ ? "A 32-byte account address" : ""),
-    encoding: base58,
-    size: 32
-  });
+async function signBytes(key, data) {
+  await assertSigningCapabilityIsAvailable();
+  const signedData = await crypto.subtle.sign("Ed25519", key, data);
+  return new Uint8Array(signedData);
 }
-function getBase58EncodedAddressComparator() {
-  return new Intl.Collator("en", {
-    caseFirst: "lower",
-    ignorePunctuation: false,
-    localeMatcher: "best fit",
-    numeric: false,
-    sensitivity: "variant",
-    usage: "sort"
-  }).compare;
+async function verifySignature(key, signature, data) {
+  await assertVerificationCapabilityIsAvailable();
+  return await crypto.subtle.verify("Ed25519", key, signature, data);
 }
 
-export { assertIsBase58EncodedAddress, getBase58EncodedAddressCodec, getBase58EncodedAddressComparator };
+export { generateKeyPair, signBytes, verifySignature };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.node.js.map

package/dist/index.node.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../build-scripts/env-shim.ts","../src/base58.ts"],"names":[],"mappings":";AACO,IAAM,UAA2B,uBAAO,QAAgB,KAAU,EAAE,aAAa,eAAe;;;ACDvG,SAAS,QAAoB,cAAc;AAMpC,SAAS,6BACZ,8BACiG;AACjG,MAAI;AAEA;AAAA;AAAA,MAEI,6BAA6B,SAAS;AAAA,MAEtC,6BAA6B,SAAS;AAAA,MACxC;AACE,YAAM,IAAI,MAAM,+DAA+D;AAAA,IACnF;AAEA,UAAM,QAAQ,OAAO,UAAU,4BAA4B;AAC3D,UAAM,WAAW,MAAM;AACvB,QAAI,aAAa,IAAI;AACjB,YAAM,IAAI,MAAM,gFAAgF,UAAU;AAAA,IAC9G;AAAA,EACJ,SAAS,GAAP;AACE,UAAM,IAAI,MAAM,KAAK,mEAAmE;AAAA,MACpF,OAAO;AAAA,IACX,CAAC;AAAA,EACL;AACJ;AAEO,SAAS,6BACZ,QAGgC;AAChC,SAAO,OAAO;AAAA,IACV,aAAa,QAAQ,gBAAgB,UAAU,8BAA8B;AAAA,IAC7E,UAAU;AAAA,IACV,MAAM;AAAA,EACV,CAAC;AACL;AAEO,SAAS,oCAAsE;AAClF,SAAO,IAAI,KAAK,SAAS,MAAM;AAAA,IAC3B,WAAW;AAAA,IACX,mBAAmB;AAAA,IACnB,eAAe;AAAA,IACf,SAAS;AAAA,IACT,aAAa;AAAA,IACb,OAAO;AAAA,EACX,CAAC,EAAE;AACP","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","import { base58, Serializer, string } from '@metaplex-foundation/umi-serializers';\n\nexport type Base58EncodedAddress<TAddress extends string = string> = TAddress & {\n    readonly __base58EncodedAddress: unique symbol;\n};\n\nexport function assertIsBase58EncodedAddress(\n    putativeBase58EncodedAddress: string\n): asserts putativeBase58EncodedAddress is Base58EncodedAddress<typeof putativeBase58EncodedAddress> {\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest address (32 bytes of zeroes)\n            putativeBase58EncodedAddress.length < 32 ||\n            // Highest address (32 bytes of 255)\n            putativeBase58EncodedAddress.length > 44\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 32.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = base58.serialize(putativeBase58EncodedAddress);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 32) {\n            throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeBase58EncodedAddress}\\` is not a base-58 encoded address`, {\n            cause: e,\n        });\n    }\n}\n\nexport function getBase58EncodedAddressCodec(\n    config?: Readonly<{\n        description: string;\n    }>\n): Serializer<Base58EncodedAddress> {\n    return string({\n        description: config?.description ?? (__DEV__ ? 'A 32-byte account address' : ''),\n        encoding: base58,\n        size: 32,\n    }) as unknown as Serializer<Base58EncodedAddress>;\n}\n\nexport function getBase58EncodedAddressComparator(): (x: string, y: string) => number {\n    return new Intl.Collator('en', {\n        caseFirst: 'lower',\n        ignorePunctuation: false,\n        localeMatcher: 'best fit',\n        numeric: false,\n        sensitivity: 'variant',\n        usage: 'sort',\n    }).compare;\n}\n"]}
+{"version":3,"sources":["../src/key-pair.ts","../src/signatures.ts"],"names":[],"mappings":";AAAA,SAAS,sCAAsC;AAE/C,eAAsB,kBAA0C;AAC5D,QAAM,+BAA+B;AACrC,QAAM,UAAU,MAAM,OAAO,OAAO;AAAA;AAAA,IAChB;AAAA;AAAA;AAAA,IACE;AAAA;AAAA;AAAA,IACC,CAAC,QAAQ,QAAQ;AAAA,EACxC;AACA,SAAO;AACX;;;ACVA,SAAS,oCAAoC,+CAA+C;AAI5F,eAAsB,UAAU,KAAgB,MAA6C;AACzF,QAAM,mCAAmC;AACzC,QAAM,aAAa,MAAM,OAAO,OAAO,KAAK,WAAW,KAAK,IAAI;AAChE,SAAO,IAAI,WAAW,UAAU;AACpC;AAEA,eAAsB,gBAAgB,KAAgB,WAA6B,MAAoC;AACnH,QAAM,wCAAwC;AAC9C,SAAO,MAAM,OAAO,OAAO,OAAO,WAAW,KAAK,WAAW,IAAI;AACrE","sourcesContent":["import { assertKeyGenerationIsAvailable } from '@solana/assertions';\n\nexport async function generateKeyPair(): Promise<CryptoKeyPair> {\n    await assertKeyGenerationIsAvailable();\n    const keyPair = await crypto.subtle.generateKey(\n        /* algorithm */ 'Ed25519', // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20\n        /* extractable */ false, // Prevents the bytes of the private key from being visible to JS.\n        /* allowed uses */ ['sign', 'verify']\n    );\n    return keyPair as CryptoKeyPair;\n}\n","import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';\n\nexport type Ed25519Signature = Uint8Array & { readonly __ed25519Signature: unique symbol };\n\nexport async function signBytes(key: CryptoKey, data: Uint8Array): Promise<Ed25519Signature> {\n    await assertSigningCapabilityIsAvailable();\n    const signedData = await crypto.subtle.sign('Ed25519', key, data);\n    return new Uint8Array(signedData) as Ed25519Signature;\n}\n\nexport async function verifySignature(key: CryptoKey, signature: Ed25519Signature, data: Uint8Array): Promise<boolean> {\n    await assertVerificationCapabilityIsAvailable();\n    return await crypto.subtle.verify('Ed25519', key, signature, data);\n}\n"]}

package/dist/index.production.min.js

@@ -2,11 +2,15 @@ this.globalThis = this.globalThis || {};
 this.globalThis.solanaWeb3 = (function (exports) {
 	'use strict';
 
-	var O=Object.defineProperty;var U=(e,r,t)=>r in e?O(e,r,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[r]=t;var u=(e,r,t)=>(U(e,typeof r!="symbol"?r+"":r,t),t);var S=e=>{let r=e.reduce((n,i)=>n+i.length,0),t=new Uint8Array(r),o=0;return e.forEach(n=>{t.set(n,o),o+=n.length;}),t},N=(e,r)=>{if(e.length>=r)return e;let t=new Uint8Array(r).fill(0);return t.set(e),t},g=(e,r)=>N(e.slice(0,r),r);var x=class extends Error{constructor(t){super(`Serializer [${t}] cannot deserialize empty buffers.`);u(this,"name","DeserializingEmptyBufferError");}},d=class extends Error{constructor(t,o,n){super(`Serializer [${t}] expected ${o} bytes, got ${n}.`);u(this,"name","NotEnoughBytesError");}};function w(e,r,t){return {description:t??`fixed(${r}, ${e.description})`,fixedSize:r,maxSize:r,serialize:o=>g(e.serialize(o),r),deserialize:(o,n=0)=>{if(o=o.slice(n,n+r),o.length<r)throw new d("fixSerializer",r,o.length);e.fixedSize!==null&&(o=g(o,e.fixedSize));let[i]=e.deserialize(o,0);return [i,n+r]}}}var z=class extends Error{constructor(t,o,n){let i=`Expected a string of base ${o}, got [${t}].`;super(i);u(this,"name","InvalidBaseStringError");this.cause=n;}};var $=e=>{let r=e.length,t=BigInt(r);return {description:`base${r}`,fixedSize:null,maxSize:null,serialize(o){if(!o.match(new RegExp(`^[${e}]*$`)))throw new z(o,r);if(o==="")return new Uint8Array;let n=[...o],i=n.findIndex(m=>m!==e[0]);i=i===-1?n.length:i;let a=Array(i).fill(0);if(i===n.length)return Uint8Array.from(a);let p=n.slice(i),l=0n,c=1n;for(let m=p.length-1;m>=0;m-=1)l+=c*BigInt(e.indexOf(p[m])),c*=t;let f=[];for(;l>0n;)f.unshift(Number(l%256n)),l/=256n;return Uint8Array.from(a.concat(f))},deserialize(o,n=0){if(o.length===0)return ["",0];let i=o.slice(n),a=i.findIndex(f=>f!==0);a=a===-1?i.length:a;let p=e[0].repeat(a);if(a===i.length)return [p,o.length];let l=i.slice(a).reduce((f,m)=>f*256n+BigInt(m),0n),c=[];for(;l>0n;)c.unshift(e[Number(l%t)]),l/=t;return [p+c.join(""),o.length]}}};var h=$("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");var I=e=>e.replace(/\u0000/g,"");var b={description:"utf8",fixedSize:null,maxSize:null,serialize(e){return new TextEncoder().encode(e)},deserialize(e,r=0){let t=new TextDecoder().decode(e.slice(r));return [I(t),e.length]}};var E;(function(e){e.Little="le",e.Big="be";})(E||(E={}));var y=class extends RangeError{constructor(t,o,n,i){super(`Serializer [${t}] expected number to be between ${o} and ${n}, got ${i}.`);u(this,"name","NumberOutOfRangeError");}};function v(e){let r,t=e.name;return e.size>1&&(r=!("endian"in e.options)||e.options.endian===E.Little,t+=r?"(le)":"(be)"),{description:e.options.description??t,fixedSize:e.size,maxSize:e.size,serialize(o){e.range&&_(e.name,e.range[0],e.range[1],o);let n=new ArrayBuffer(e.size);return e.set(new DataView(n),o,r),new Uint8Array(n)},deserialize(o,n=0){let i=o.slice(n,n+e.size);L("i8",i,e.size);let a=R(i);return [e.get(a,r),n+e.size]}}}var C=e=>e.buffer.slice(e.byteOffset,e.byteLength+e.byteOffset),R=e=>new DataView(C(e)),_=(e,r,t,o)=>{if(o<r||o>t)throw new y(e,r,t,o)},L=(e,r,t)=>{if(r.length===0)throw new x(e);if(r.length<t)throw new d(e,t,r.length)};var B=(e={})=>v({name:"u32",size:4,range:[0,+"0xffffffff"],set:(r,t,o)=>r.setUint32(0,Number(t),o),get:(r,t)=>r.getUint32(0,t),options:e});function D(e){return typeof e=="object"?e.description:`${e}`}function A(e={}){let r=e.size??B(),t=e.encoding??b,o=e.description??`string(${t.description}; ${D(r)})`;return r==="variable"?{...t,description:o}:typeof r=="number"?w(t,r,o):{description:o,fixedSize:null,maxSize:null,serialize:n=>{let i=t.serialize(n),a=r.serialize(i.length);return S([a,i])},deserialize:(n,i=0)=>{if(n.slice(i).length===0)throw new x("string");let[a,p]=r.deserialize(n,i),l=Number(a);i=p;let c=n.slice(i,i+l);if(c.length<l)throw new d("string",l,c.length);let[f,m]=t.deserialize(c);return i+=m,[f,i]}}}function Je(e){try{if(e.length<32||e.length>44)throw new Error("Expected input string to decode to a byte array of length 32.");let t=h.serialize(e).byteLength;if(t!==32)throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${t}`)}catch(r){throw new Error(`\`${e}\` is not a base-58 encoded address`,{cause:r})}}function Qe(e){return A({description:e?.description??"",encoding:h,size:32})}function We(){return new Intl.Collator("en",{caseFirst:"lower",ignorePunctuation:!1,localeMatcher:"best fit",numeric:!1,sensitivity:"variant",usage:"sort"}).compare}
+	function n(){if(!globalThis.isSecureContext)throw new Error("Cryptographic operations are only allowed in secure browser contexts. Read more here: https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts")}var e;async function y(t){return e===void 0&&(e=new Promise(o=>{t.generateKey("Ed25519",!1,["sign","verify"]).catch(()=>{o(e=!1);}).then(()=>{o(e=!0);});})),typeof e=="boolean"?e:await e}async function a(){if(n(),typeof globalThis.crypto>"u"||typeof globalThis.crypto.subtle?.generateKey!="function")throw new Error("No key generation implementation could be found");if(!await y(globalThis.crypto.subtle))throw new Error(`This runtime does not support the generation of Ed25519 key pairs.
 
-	exports.assertIsBase58EncodedAddress = Je;
-	exports.getBase58EncodedAddressCodec = Qe;
-	exports.getBase58EncodedAddressComparator = We;
+Install and import \`@solana/webcrypto-ed25519-polyfill\` before generating keys in environments that do not support Ed25519.
+
+For a list of runtimes that currently support Ed25519 operations, visit https://github.com/WICG/webcrypto-secure-curves/issues/20`)}async function s(){if(n(),typeof globalThis.crypto>"u"||typeof globalThis.crypto.subtle?.sign!="function")throw new Error("No signing implementation could be found")}async function l(){if(n(),typeof globalThis.crypto>"u"||typeof globalThis.crypto.subtle?.verify!="function")throw new Error("No signature verification implementation could be found")}async function d(){return await a(),await crypto.subtle.generateKey("Ed25519",!1,["sign","verify"])}async function m(t,o){await s();let r=await crypto.subtle.sign("Ed25519",t,o);return new Uint8Array(r)}async function w(t,o,r){return await l(),await crypto.subtle.verify("Ed25519",t,o,r)}
+
+	exports.generateKeyPair = d;
+	exports.signBytes = m;
+	exports.verifySignature = w;
 
 	return exports;
 

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
-export * from './base58';
+export * from './key-pair';
+export * from './signatures';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC"}

package/dist/types/key-pair.d.ts

@@ -0,0 +1,2 @@
+export declare function generateKeyPair(): Promise<CryptoKeyPair>;
+//# sourceMappingURL=key-pair.d.ts.map

package/dist/types/key-pair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-pair.d.ts","sourceRoot":"","sources":["../../src/key-pair.ts"],"names":[],"mappings":"AAEA,wBAAsB,eAAe,IAAI,OAAO,CAAC,aAAa,CAAC,CAQ9D"}

package/dist/types/signatures.d.ts

@@ -0,0 +1,6 @@
+export type Ed25519Signature = Uint8Array & {
+    readonly __ed25519Signature: unique symbol;
+};
+export declare function signBytes(key: CryptoKey, data: Uint8Array): Promise<Ed25519Signature>;
+export declare function verifySignature(key: CryptoKey, signature: Ed25519Signature, data: Uint8Array): Promise<boolean>;
+//# sourceMappingURL=signatures.d.ts.map

package/dist/types/signatures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signatures.d.ts","sourceRoot":"","sources":["../../src/signatures.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG;IAAE,QAAQ,CAAC,kBAAkB,EAAE,OAAO,MAAM,CAAA;CAAE,CAAC;AAE3F,wBAAsB,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAI3F;AAED,wBAAsB,eAAe,CAAC,GAAG,EAAE,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAGrH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/keys",
-  "version": "2.0.0-experimental.ca5fcbd",
+  "version": "2.0.0-experimental.ca7c151",
   "description": "Helpers for generating and transforming key material",
   "exports": {
     "browser": {
@@ -45,30 +45,29 @@
     "supports bigint and not dead",
     "maintained node versions"
   ],
+  "engine": {
+    "node": ">=17.4"
+  },
   "dependencies": {
-    "@metaplex-foundation/umi-serializers": "^0.8.2"
+    "@solana/assertions": "2.0.0-experimental.ca7c151"
   },
   "devDependencies": {
-    "@solana/eslint-config-solana": "^1.0.1",
-    "@swc/core": "^1.3.18",
-    "@swc/jest": "^0.2.26",
-    "@types/jest": "^29.5.2",
-    "@typescript-eslint/eslint-plugin": "^5.57.1",
-    "@typescript-eslint/parser": "^5.57.1",
+    "@solana/eslint-config-solana": "^1.0.2",
+    "@swc/jest": "^0.2.27",
+    "@types/jest": "^29.5.3",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
     "agadoo": "^3.0.0",
-    "eslint": "^8.37.0",
-    "eslint-plugin-jest": "^27.1.5",
-    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint": "^8.45.0",
+    "eslint-plugin-jest": "^27.2.3",
     "eslint-plugin-sort-keys-fix": "^1.1.2",
     "jest": "^29.6.1",
     "jest-environment-jsdom": "^29.6.0",
     "jest-runner-eslint": "^2.1.0",
     "jest-runner-prettier": "^1.0.0",
-    "postcss": "^8.4.12",
     "prettier": "^2.8.8",
-    "ts-node": "^10.9.1",
-    "tsup": "6.7.0",
-    "typescript": "^5.0.4",
+    "tsup": "7.2.0",
+    "typescript": "^5.1.6",
     "version-from-git": "^1.1.1",
     "build-scripts": "0.0.0",
     "test-config": "0.0.0",

package/dist/types/base58.d.ts

@@ -1,10 +0,0 @@
-import { Serializer } from '@metaplex-foundation/umi-serializers';
-export type Base58EncodedAddress<TAddress extends string = string> = TAddress & {
-    readonly __base58EncodedAddress: unique symbol;
-};
-export declare function assertIsBase58EncodedAddress(putativeBase58EncodedAddress: string): asserts putativeBase58EncodedAddress is Base58EncodedAddress<typeof putativeBase58EncodedAddress>;
-export declare function getBase58EncodedAddressCodec(config?: Readonly<{
-    description: string;
-}>): Serializer<Base58EncodedAddress>;
-export declare function getBase58EncodedAddressComparator(): (x: string, y: string) => number;
-//# sourceMappingURL=base58.d.ts.map