@solana/keys 2.0.0-experimental.f57da91 → 2.0.0-experimental.f5d64e6

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018 Solana Labs, Inc
+Copyright (c) 2023 Solana Labs, Inc
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/README.md

@@ -18,7 +18,11 @@ This package contains utilities for validating, generating, and manipulating add
 
 ## Types
 
-### `Ed25519Signature`
+### `Signature`
+
+This type represents a 64-byte Ed25519 signature of some data with a private key, as a base58-encoded string.
+
+### `SignatureBytes`
 
 This type represents a 64-byte Ed25519 signature of some data with a private key.
 
@@ -26,6 +30,31 @@ Whenever you need to verify that a particular signature is, in fact, the one tha
 
 ## Functions
 
+### `assertIsSignature()`
+
+From time to time you might acquire a string that you expect to be a base58-encoded signature (eg. of a transaction) from an untrusted network API or user input. To assert that such an arbitrary string is in fact an Ed25519 signature, use the `assertIsSignature` function.
+
+```ts
+import { assertIsSignature } from '@solana/keys';
+
+// Imagine a function that asserts whether a user-supplied signature is valid or not.
+function handleSubmit() {
+    // We know only that what the user typed conforms to the `string` type.
+    const signature: string = signatureInput.value;
+    try {
+        // If this type assertion function doesn't throw, then
+        // Typescript will upcast `signature` to `Signature`.
+        assertIsSignature(signature);
+        // At this point, `signature` is a `Signature` that can be used with the RPC.
+        const {
+            value: [status],
+        } = await rpc.getSignatureStatuses([signature]).send();
+    } catch (e) {
+        // `signature` turned out not to be a base58-encoded signature
+    }
+}
+```
+
 ### `generateKeyPair()`
 
 Generates an Ed25519 public/private key pair for use with other methods in this package that accept `CryptoKey` objects.
@@ -36,6 +65,25 @@ import { generateKeyPair } from '@solana/keys';
 const { privateKey, publicKey } = await generateKeyPair();
 ```
 
+### `isSignature()`
+
+This is a type guard that accepts a string as input. It will both return `true` if the string conforms to the `Signature` type and will refine the type for use in your program.
+
+```ts
+import { isSignature } from '@solana/keys';
+
+if (isSignature(signature)) {
+    // At this point, `signature` has been refined to a
+    // `Signature` that can be used with the RPC.
+    const {
+        value: [status],
+    } = await rpc.getSignatureStatuses([signature]).send();
+    setSignatureStatus(status);
+} else {
+    setError(`${signature} is not a transaction signature`);
+}
+```
+
 ### `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`.
@@ -47,9 +95,22 @@ const data = new Uint8Array([1, 2, 3]);
 const signature = await signBytes(privateKey, data);
 ```
 
+### `signature()`
+
+This helper combines _asserting_ that a string is an Ed25519 signature with _coercing_ it to the `Signature` type. It's best used with untrusted input.
+
+```ts
+import { signature } from '@solana/keys';
+
+const signature = signature(userSuppliedSignature);
+const {
+    value: [status],
+} = await rpc.getSignatureStatuses([signature]).send();
+```
+
 ### `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.
+Given a public `CryptoKey`, some `SignatureBytes`, and a `Uint8Array` of data, this method will return `true` if the signature was produced by signing the data using the private key associated with the public key, and `false` otherwise.
 
 ```ts
 import { verifySignature } from '@solana/keys';

package/dist/index.browser.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var assertions = require('@solana/assertions');
+var codecsStrings = require('@solana/codecs-strings');
 
 // src/key-pair.ts
 async function generateKeyPair() {
@@ -17,18 +18,121 @@ async function generateKeyPair() {
   );
   return keyPair;
 }
+
+// src/private-key.ts
+function addPkcs8Header(bytes) {
+  return new Uint8Array([
+    /**
+     * PKCS#8 header
+     */
+    48,
+    // ASN.1 sequence tag
+    46,
+    // Length of sequence (46 more bytes)
+    2,
+    // ASN.1 integer tag
+    1,
+    // Length of integer
+    0,
+    // Version number
+    48,
+    // ASN.1 sequence tag
+    5,
+    // Length of sequence
+    6,
+    // ASN.1 object identifier tag
+    3,
+    // Length of object identifier
+    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112
+    43,
+    // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)
+    101,
+    // thawte(101)
+    // Ed25519 identifier
+    112,
+    // id-Ed25519(112)
+    /**
+     * Private key payload
+     */
+    4,
+    // ASN.1 octet string tag
+    34,
+    // String length (34 more bytes)
+    // Private key bytes as octet string
+    4,
+    // ASN.1 octet string tag
+    32,
+    // String length (32 bytes)
+    ...bytes
+  ]);
+}
+async function createPrivateKeyFromBytes(bytes, extractable) {
+  if (bytes.byteLength !== 32) {
+    throw new Error("Private key bytes must be of length 32");
+  }
+  const privateKeyBytesPkcs8 = addPkcs8Header(bytes);
+  return await crypto.subtle.importKey("pkcs8", privateKeyBytesPkcs8, "Ed25519", extractable ?? false, ["sign"]);
+}
+var base58Encoder;
+function assertIsSignature(putativeSignature) {
+  if (!base58Encoder)
+    base58Encoder = codecsStrings.getBase58Encoder();
+  try {
+    if (
+      // Lowest value (64 bytes of zeroes)
+      putativeSignature.length < 64 || // Highest value (64 bytes of 255)
+      putativeSignature.length > 88
+    ) {
+      throw new Error("Expected input string to decode to a byte array of length 64.");
+    }
+    const bytes = base58Encoder.encode(putativeSignature);
+    const numBytes = bytes.byteLength;
+    if (numBytes !== 64) {
+      throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
+    }
+  } catch (e) {
+    throw new Error(`\`${putativeSignature}\` is not a signature`, {
+      cause: e
+    });
+  }
+}
+function isSignature(putativeSignature) {
+  if (!base58Encoder)
+    base58Encoder = codecsStrings.getBase58Encoder();
+  if (
+    // Lowest value (64 bytes of zeroes)
+    putativeSignature.length < 64 || // Highest value (64 bytes of 255)
+    putativeSignature.length > 88
+  ) {
+    return false;
+  }
+  const bytes = base58Encoder.encode(putativeSignature);
+  const numBytes = bytes.byteLength;
+  if (numBytes !== 64) {
+    return false;
+  }
+  return true;
+}
 async function signBytes(key, data) {
   await assertions.assertSigningCapabilityIsAvailable();
   const signedData = await crypto.subtle.sign("Ed25519", key, data);
   return new Uint8Array(signedData);
 }
-async function verifySignature(key, signature, data) {
+function signature(putativeSignature) {
+  assertIsSignature(putativeSignature);
+  return putativeSignature;
+}
+async function verifySignature(key, signature2, data) {
   await assertions.assertVerificationCapabilityIsAvailable();
-  return await crypto.subtle.verify("Ed25519", key, signature, data);
+  return await crypto.subtle.verify("Ed25519", key, signature2, data);
 }
 
+exports.assertIsSignature = assertIsSignature;
+exports.createPrivateKeyFromBytes = createPrivateKeyFromBytes;
 exports.generateKeyPair = generateKeyPair;
+exports.isSignature = isSignature;
 exports.signBytes = signBytes;
+exports.signature = signature;
 exports.verifySignature = verifySignature;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.cjs.map

package/dist/index.browser.cjs.map

@@ -1 +1 @@
-{"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 __brand: 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"]}
+{"version":3,"sources":["../src/key-pair.ts","../src/private-key.ts","../src/signatures.ts"],"names":["signature"],"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,eAAe,OAA+B;AAEnD,SAAO,IAAI,WAAW;AAAA;AAAA;AAAA;AAAA,IAIlB;AAAA;AAAA,IACA;AAAA;AAAA,IAEI;AAAA;AAAA,IACA;AAAA;AAAA,IACI;AAAA;AAAA,IAEJ;AAAA;AAAA,IACA;AAAA;AAAA,IACI;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAEQ;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAEA;AAAA;AAAA;AAAA;AAAA;AAAA,IAKhB;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAGI;AAAA;AAAA,IACA;AAAA;AAAA,IAEJ,GAAG;AAAA,EACP,CAAC;AACL;AAEA,eAAsB,0BAA0B,OAAmB,aAA2C;AAC1G,MAAI,MAAM,eAAe,IAAI;AAEzB,UAAM,IAAI,MAAM,wCAAwC;AAAA,EAC5D;AACA,QAAM,uBAAuB,eAAe,KAAK;AACjD,SAAO,MAAM,OAAO,OAAO,UAAU,SAAS,sBAAsB,WAAW,eAAe,OAAO,CAAC,MAAM,CAAC;AACjH;;;AC5CA,SAAS,oCAAoC,+CAA+C;AAE5F,SAAS,wBAAwB;AAKjC,IAAI;AAEG,SAAS,kBAAkB,mBAAmE;AACjG,MAAI,CAAC;AAAe,oBAAgB,iBAAiB;AAErD,MAAI;AAEA;AAAA;AAAA,MAEI,kBAAkB,SAAS;AAAA,MAE3B,kBAAkB,SAAS;AAAA,MAC7B;AACE,YAAM,IAAI,MAAM,+DAA+D;AAAA,IACnF;AAEA,UAAM,QAAQ,cAAc,OAAO,iBAAiB;AACpD,UAAM,WAAW,MAAM;AACvB,QAAI,aAAa,IAAI;AACjB,YAAM,IAAI,MAAM,gFAAgF,QAAQ,EAAE;AAAA,IAC9G;AAAA,EACJ,SAAS,GAAG;AACR,UAAM,IAAI,MAAM,KAAK,iBAAiB,yBAAyB;AAAA,MAC3D,OAAO;AAAA,IACX,CAAC;AAAA,EACL;AACJ;AAEO,SAAS,YAAY,mBAA2D;AACnF,MAAI,CAAC;AAAe,oBAAgB,iBAAiB;AAGrD;AAAA;AAAA,IAEI,kBAAkB,SAAS;AAAA,IAE3B,kBAAkB,SAAS;AAAA,IAC7B;AACE,WAAO;AAAA,EACX;AAEA,QAAM,QAAQ,cAAc,OAAO,iBAAiB;AACpD,QAAM,WAAW,MAAM;AACvB,MAAI,aAAa,IAAI;AACjB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAEA,eAAsB,UAAU,KAAgB,MAA2C;AACvF,QAAM,mCAAmC;AACzC,QAAM,aAAa,MAAM,OAAO,OAAO,KAAK,WAAW,KAAK,IAAI;AAChE,SAAO,IAAI,WAAW,UAAU;AACpC;AAEO,SAAS,UAAU,mBAAsC;AAC5D,oBAAkB,iBAAiB;AACnC,SAAO;AACX;AAEA,eAAsB,gBAAgB,KAAgBA,YAA2B,MAAoC;AACjH,QAAM,wCAAwC;AAC9C,SAAO,MAAM,OAAO,OAAO,OAAO,WAAW,KAAKA,YAAW,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","function addPkcs8Header(bytes: Uint8Array): Uint8Array {\n    // prettier-ignore\n    return new Uint8Array([\n        /**\n         * PKCS#8 header\n         */\n        0x30, // ASN.1 sequence tag\n        0x2e, // Length of sequence (46 more bytes)\n\n            0x02, // ASN.1 integer tag\n            0x01, // Length of integer\n                0x00, // Version number\n\n            0x30, // ASN.1 sequence tag\n            0x05, // Length of sequence\n                0x06, // ASN.1 object identifier tag\n                0x03, // Length of object identifier\n                    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112\n                        0x2b, // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)\n                        0x65, // thawte(101)\n                    // Ed25519 identifier\n                        0x70, // id-Ed25519(112)\n\n        /**\n         * Private key payload\n         */\n        0x04, // ASN.1 octet string tag\n        0x22, // String length (34 more bytes)\n\n            // Private key bytes as octet string\n            0x04, // ASN.1 octet string tag\n            0x20, // String length (32 bytes)\n\n        ...bytes\n    ]);\n}\n\nexport async function createPrivateKeyFromBytes(bytes: Uint8Array, extractable?: boolean): Promise<CryptoKey> {\n    if (bytes.byteLength !== 32) {\n        // TODO: Coded error.\n        throw new Error('Private key bytes must be of length 32');\n    }\n    const privateKeyBytesPkcs8 = addPkcs8Header(bytes);\n    return await crypto.subtle.importKey('pkcs8', privateKeyBytesPkcs8, 'Ed25519', extractable ?? false, ['sign']);\n}\n","import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';\nimport { Encoder } from '@solana/codecs-core';\nimport { getBase58Encoder } from '@solana/codecs-strings';\n\nexport type Signature = string & { readonly __brand: unique symbol };\nexport type SignatureBytes = Uint8Array & { readonly __brand: unique symbol };\n\nlet base58Encoder: Encoder<string> | undefined;\n\nexport function assertIsSignature(putativeSignature: string): asserts putativeSignature is Signature {\n    if (!base58Encoder) base58Encoder = getBase58Encoder();\n\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest value (64 bytes of zeroes)\n            putativeSignature.length < 64 ||\n            // Highest value (64 bytes of 255)\n            putativeSignature.length > 88\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 64.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = base58Encoder.encode(putativeSignature);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 64) {\n            throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeSignature}\\` is not a signature`, {\n            cause: e,\n        });\n    }\n}\n\nexport function isSignature(putativeSignature: string): putativeSignature is Signature {\n    if (!base58Encoder) base58Encoder = getBase58Encoder();\n\n    // Fast-path; see if the input string is of an acceptable length.\n    if (\n        // Lowest value (64 bytes of zeroes)\n        putativeSignature.length < 64 ||\n        // Highest value (64 bytes of 255)\n        putativeSignature.length > 88\n    ) {\n        return false;\n    }\n    // Slow-path; actually attempt to decode the input string.\n    const bytes = base58Encoder.encode(putativeSignature);\n    const numBytes = bytes.byteLength;\n    if (numBytes !== 64) {\n        return false;\n    }\n    return true;\n}\n\nexport async function signBytes(key: CryptoKey, data: Uint8Array): Promise<SignatureBytes> {\n    await assertSigningCapabilityIsAvailable();\n    const signedData = await crypto.subtle.sign('Ed25519', key, data);\n    return new Uint8Array(signedData) as SignatureBytes;\n}\n\nexport function signature(putativeSignature: string): Signature {\n    assertIsSignature(putativeSignature);\n    return putativeSignature;\n}\n\nexport async function verifySignature(key: CryptoKey, signature: SignatureBytes, 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,4 +1,5 @@
 import { assertKeyGenerationIsAvailable, assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';
+import { getBase58Encoder } from '@solana/codecs-strings';
 
 // src/key-pair.ts
 async function generateKeyPair() {
@@ -15,16 +16,115 @@ async function generateKeyPair() {
   );
   return keyPair;
 }
+
+// src/private-key.ts
+function addPkcs8Header(bytes) {
+  return new Uint8Array([
+    /**
+     * PKCS#8 header
+     */
+    48,
+    // ASN.1 sequence tag
+    46,
+    // Length of sequence (46 more bytes)
+    2,
+    // ASN.1 integer tag
+    1,
+    // Length of integer
+    0,
+    // Version number
+    48,
+    // ASN.1 sequence tag
+    5,
+    // Length of sequence
+    6,
+    // ASN.1 object identifier tag
+    3,
+    // Length of object identifier
+    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112
+    43,
+    // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)
+    101,
+    // thawte(101)
+    // Ed25519 identifier
+    112,
+    // id-Ed25519(112)
+    /**
+     * Private key payload
+     */
+    4,
+    // ASN.1 octet string tag
+    34,
+    // String length (34 more bytes)
+    // Private key bytes as octet string
+    4,
+    // ASN.1 octet string tag
+    32,
+    // String length (32 bytes)
+    ...bytes
+  ]);
+}
+async function createPrivateKeyFromBytes(bytes, extractable) {
+  if (bytes.byteLength !== 32) {
+    throw new Error("Private key bytes must be of length 32");
+  }
+  const privateKeyBytesPkcs8 = addPkcs8Header(bytes);
+  return await crypto.subtle.importKey("pkcs8", privateKeyBytesPkcs8, "Ed25519", extractable ?? false, ["sign"]);
+}
+var base58Encoder;
+function assertIsSignature(putativeSignature) {
+  if (!base58Encoder)
+    base58Encoder = getBase58Encoder();
+  try {
+    if (
+      // Lowest value (64 bytes of zeroes)
+      putativeSignature.length < 64 || // Highest value (64 bytes of 255)
+      putativeSignature.length > 88
+    ) {
+      throw new Error("Expected input string to decode to a byte array of length 64.");
+    }
+    const bytes = base58Encoder.encode(putativeSignature);
+    const numBytes = bytes.byteLength;
+    if (numBytes !== 64) {
+      throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
+    }
+  } catch (e) {
+    throw new Error(`\`${putativeSignature}\` is not a signature`, {
+      cause: e
+    });
+  }
+}
+function isSignature(putativeSignature) {
+  if (!base58Encoder)
+    base58Encoder = getBase58Encoder();
+  if (
+    // Lowest value (64 bytes of zeroes)
+    putativeSignature.length < 64 || // Highest value (64 bytes of 255)
+    putativeSignature.length > 88
+  ) {
+    return false;
+  }
+  const bytes = base58Encoder.encode(putativeSignature);
+  const numBytes = bytes.byteLength;
+  if (numBytes !== 64) {
+    return false;
+  }
+  return true;
+}
 async function signBytes(key, data) {
   await assertSigningCapabilityIsAvailable();
   const signedData = await crypto.subtle.sign("Ed25519", key, data);
   return new Uint8Array(signedData);
 }
-async function verifySignature(key, signature, data) {
+function signature(putativeSignature) {
+  assertIsSignature(putativeSignature);
+  return putativeSignature;
+}
+async function verifySignature(key, signature2, data) {
   await assertVerificationCapabilityIsAvailable();
-  return await crypto.subtle.verify("Ed25519", key, signature, data);
+  return await crypto.subtle.verify("Ed25519", key, signature2, data);
 }
 
-export { generateKeyPair, signBytes, verifySignature };
+export { assertIsSignature, createPrivateKeyFromBytes, generateKeyPair, isSignature, signBytes, signature, verifySignature };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.js.map

package/dist/index.browser.js.map

@@ -1 +1 @@
-{"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 __brand: 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"]}
+{"version":3,"sources":["../src/key-pair.ts","../src/private-key.ts","../src/signatures.ts"],"names":["signature"],"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,eAAe,OAA+B;AAEnD,SAAO,IAAI,WAAW;AAAA;AAAA;AAAA;AAAA,IAIlB;AAAA;AAAA,IACA;AAAA;AAAA,IAEI;AAAA;AAAA,IACA;AAAA;AAAA,IACI;AAAA;AAAA,IAEJ;AAAA;AAAA,IACA;AAAA;AAAA,IACI;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAEQ;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAEA;AAAA;AAAA;AAAA;AAAA;AAAA,IAKhB;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAGI;AAAA;AAAA,IACA;AAAA;AAAA,IAEJ,GAAG;AAAA,EACP,CAAC;AACL;AAEA,eAAsB,0BAA0B,OAAmB,aAA2C;AAC1G,MAAI,MAAM,eAAe,IAAI;AAEzB,UAAM,IAAI,MAAM,wCAAwC;AAAA,EAC5D;AACA,QAAM,uBAAuB,eAAe,KAAK;AACjD,SAAO,MAAM,OAAO,OAAO,UAAU,SAAS,sBAAsB,WAAW,eAAe,OAAO,CAAC,MAAM,CAAC;AACjH;;;AC5CA,SAAS,oCAAoC,+CAA+C;AAE5F,SAAS,wBAAwB;AAKjC,IAAI;AAEG,SAAS,kBAAkB,mBAAmE;AACjG,MAAI,CAAC;AAAe,oBAAgB,iBAAiB;AAErD,MAAI;AAEA;AAAA;AAAA,MAEI,kBAAkB,SAAS;AAAA,MAE3B,kBAAkB,SAAS;AAAA,MAC7B;AACE,YAAM,IAAI,MAAM,+DAA+D;AAAA,IACnF;AAEA,UAAM,QAAQ,cAAc,OAAO,iBAAiB;AACpD,UAAM,WAAW,MAAM;AACvB,QAAI,aAAa,IAAI;AACjB,YAAM,IAAI,MAAM,gFAAgF,QAAQ,EAAE;AAAA,IAC9G;AAAA,EACJ,SAAS,GAAG;AACR,UAAM,IAAI,MAAM,KAAK,iBAAiB,yBAAyB;AAAA,MAC3D,OAAO;AAAA,IACX,CAAC;AAAA,EACL;AACJ;AAEO,SAAS,YAAY,mBAA2D;AACnF,MAAI,CAAC;AAAe,oBAAgB,iBAAiB;AAGrD;AAAA;AAAA,IAEI,kBAAkB,SAAS;AAAA,IAE3B,kBAAkB,SAAS;AAAA,IAC7B;AACE,WAAO;AAAA,EACX;AAEA,QAAM,QAAQ,cAAc,OAAO,iBAAiB;AACpD,QAAM,WAAW,MAAM;AACvB,MAAI,aAAa,IAAI;AACjB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAEA,eAAsB,UAAU,KAAgB,MAA2C;AACvF,QAAM,mCAAmC;AACzC,QAAM,aAAa,MAAM,OAAO,OAAO,KAAK,WAAW,KAAK,IAAI;AAChE,SAAO,IAAI,WAAW,UAAU;AACpC;AAEO,SAAS,UAAU,mBAAsC;AAC5D,oBAAkB,iBAAiB;AACnC,SAAO;AACX;AAEA,eAAsB,gBAAgB,KAAgBA,YAA2B,MAAoC;AACjH,QAAM,wCAAwC;AAC9C,SAAO,MAAM,OAAO,OAAO,OAAO,WAAW,KAAKA,YAAW,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","function addPkcs8Header(bytes: Uint8Array): Uint8Array {\n    // prettier-ignore\n    return new Uint8Array([\n        /**\n         * PKCS#8 header\n         */\n        0x30, // ASN.1 sequence tag\n        0x2e, // Length of sequence (46 more bytes)\n\n            0x02, // ASN.1 integer tag\n            0x01, // Length of integer\n                0x00, // Version number\n\n            0x30, // ASN.1 sequence tag\n            0x05, // Length of sequence\n                0x06, // ASN.1 object identifier tag\n                0x03, // Length of object identifier\n                    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112\n                        0x2b, // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)\n                        0x65, // thawte(101)\n                    // Ed25519 identifier\n                        0x70, // id-Ed25519(112)\n\n        /**\n         * Private key payload\n         */\n        0x04, // ASN.1 octet string tag\n        0x22, // String length (34 more bytes)\n\n            // Private key bytes as octet string\n            0x04, // ASN.1 octet string tag\n            0x20, // String length (32 bytes)\n\n        ...bytes\n    ]);\n}\n\nexport async function createPrivateKeyFromBytes(bytes: Uint8Array, extractable?: boolean): Promise<CryptoKey> {\n    if (bytes.byteLength !== 32) {\n        // TODO: Coded error.\n        throw new Error('Private key bytes must be of length 32');\n    }\n    const privateKeyBytesPkcs8 = addPkcs8Header(bytes);\n    return await crypto.subtle.importKey('pkcs8', privateKeyBytesPkcs8, 'Ed25519', extractable ?? false, ['sign']);\n}\n","import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';\nimport { Encoder } from '@solana/codecs-core';\nimport { getBase58Encoder } from '@solana/codecs-strings';\n\nexport type Signature = string & { readonly __brand: unique symbol };\nexport type SignatureBytes = Uint8Array & { readonly __brand: unique symbol };\n\nlet base58Encoder: Encoder<string> | undefined;\n\nexport function assertIsSignature(putativeSignature: string): asserts putativeSignature is Signature {\n    if (!base58Encoder) base58Encoder = getBase58Encoder();\n\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest value (64 bytes of zeroes)\n            putativeSignature.length < 64 ||\n            // Highest value (64 bytes of 255)\n            putativeSignature.length > 88\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 64.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = base58Encoder.encode(putativeSignature);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 64) {\n            throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeSignature}\\` is not a signature`, {\n            cause: e,\n        });\n    }\n}\n\nexport function isSignature(putativeSignature: string): putativeSignature is Signature {\n    if (!base58Encoder) base58Encoder = getBase58Encoder();\n\n    // Fast-path; see if the input string is of an acceptable length.\n    if (\n        // Lowest value (64 bytes of zeroes)\n        putativeSignature.length < 64 ||\n        // Highest value (64 bytes of 255)\n        putativeSignature.length > 88\n    ) {\n        return false;\n    }\n    // Slow-path; actually attempt to decode the input string.\n    const bytes = base58Encoder.encode(putativeSignature);\n    const numBytes = bytes.byteLength;\n    if (numBytes !== 64) {\n        return false;\n    }\n    return true;\n}\n\nexport async function signBytes(key: CryptoKey, data: Uint8Array): Promise<SignatureBytes> {\n    await assertSigningCapabilityIsAvailable();\n    const signedData = await crypto.subtle.sign('Ed25519', key, data);\n    return new Uint8Array(signedData) as SignatureBytes;\n}\n\nexport function signature(putativeSignature: string): Signature {\n    assertIsSignature(putativeSignature);\n    return putativeSignature;\n}\n\nexport async function verifySignature(key: CryptoKey, signature: SignatureBytes, 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,4 +1,5 @@
 import { assertKeyGenerationIsAvailable, assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';
+import { getBase58Encoder } from '@solana/codecs-strings';
 
 // src/key-pair.ts
 async function generateKeyPair() {
@@ -15,16 +16,115 @@ async function generateKeyPair() {
   );
   return keyPair;
 }
+
+// src/private-key.ts
+function addPkcs8Header(bytes) {
+  return new Uint8Array([
+    /**
+     * PKCS#8 header
+     */
+    48,
+    // ASN.1 sequence tag
+    46,
+    // Length of sequence (46 more bytes)
+    2,
+    // ASN.1 integer tag
+    1,
+    // Length of integer
+    0,
+    // Version number
+    48,
+    // ASN.1 sequence tag
+    5,
+    // Length of sequence
+    6,
+    // ASN.1 object identifier tag
+    3,
+    // Length of object identifier
+    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112
+    43,
+    // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)
+    101,
+    // thawte(101)
+    // Ed25519 identifier
+    112,
+    // id-Ed25519(112)
+    /**
+     * Private key payload
+     */
+    4,
+    // ASN.1 octet string tag
+    34,
+    // String length (34 more bytes)
+    // Private key bytes as octet string
+    4,
+    // ASN.1 octet string tag
+    32,
+    // String length (32 bytes)
+    ...bytes
+  ]);
+}
+async function createPrivateKeyFromBytes(bytes, extractable) {
+  if (bytes.byteLength !== 32) {
+    throw new Error("Private key bytes must be of length 32");
+  }
+  const privateKeyBytesPkcs8 = addPkcs8Header(bytes);
+  return await crypto.subtle.importKey("pkcs8", privateKeyBytesPkcs8, "Ed25519", extractable ?? false, ["sign"]);
+}
+var base58Encoder;
+function assertIsSignature(putativeSignature) {
+  if (!base58Encoder)
+    base58Encoder = getBase58Encoder();
+  try {
+    if (
+      // Lowest value (64 bytes of zeroes)
+      putativeSignature.length < 64 || // Highest value (64 bytes of 255)
+      putativeSignature.length > 88
+    ) {
+      throw new Error("Expected input string to decode to a byte array of length 64.");
+    }
+    const bytes = base58Encoder.encode(putativeSignature);
+    const numBytes = bytes.byteLength;
+    if (numBytes !== 64) {
+      throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
+    }
+  } catch (e) {
+    throw new Error(`\`${putativeSignature}\` is not a signature`, {
+      cause: e
+    });
+  }
+}
+function isSignature(putativeSignature) {
+  if (!base58Encoder)
+    base58Encoder = getBase58Encoder();
+  if (
+    // Lowest value (64 bytes of zeroes)
+    putativeSignature.length < 64 || // Highest value (64 bytes of 255)
+    putativeSignature.length > 88
+  ) {
+    return false;
+  }
+  const bytes = base58Encoder.encode(putativeSignature);
+  const numBytes = bytes.byteLength;
+  if (numBytes !== 64) {
+    return false;
+  }
+  return true;
+}
 async function signBytes(key, data) {
   await assertSigningCapabilityIsAvailable();
   const signedData = await crypto.subtle.sign("Ed25519", key, data);
   return new Uint8Array(signedData);
 }
-async function verifySignature(key, signature, data) {
+function signature(putativeSignature) {
+  assertIsSignature(putativeSignature);
+  return putativeSignature;
+}
+async function verifySignature(key, signature2, data) {
   await assertVerificationCapabilityIsAvailable();
-  return await crypto.subtle.verify("Ed25519", key, signature, data);
+  return await crypto.subtle.verify("Ed25519", key, signature2, data);
 }
 
-export { generateKeyPair, signBytes, verifySignature };
+export { assertIsSignature, createPrivateKeyFromBytes, generateKeyPair, isSignature, signBytes, signature, verifySignature };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.native.js.map

package/dist/index.native.js.map

@@ -1 +1 @@
-{"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 __brand: 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"]}
+{"version":3,"sources":["../src/key-pair.ts","../src/private-key.ts","../src/signatures.ts"],"names":["signature"],"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,eAAe,OAA+B;AAEnD,SAAO,IAAI,WAAW;AAAA;AAAA;AAAA;AAAA,IAIlB;AAAA;AAAA,IACA;AAAA;AAAA,IAEI;AAAA;AAAA,IACA;AAAA;AAAA,IACI;AAAA;AAAA,IAEJ;AAAA;AAAA,IACA;AAAA;AAAA,IACI;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAEQ;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAEA;AAAA;AAAA;AAAA;AAAA;AAAA,IAKhB;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAGI;AAAA;AAAA,IACA;AAAA;AAAA,IAEJ,GAAG;AAAA,EACP,CAAC;AACL;AAEA,eAAsB,0BAA0B,OAAmB,aAA2C;AAC1G,MAAI,MAAM,eAAe,IAAI;AAEzB,UAAM,IAAI,MAAM,wCAAwC;AAAA,EAC5D;AACA,QAAM,uBAAuB,eAAe,KAAK;AACjD,SAAO,MAAM,OAAO,OAAO,UAAU,SAAS,sBAAsB,WAAW,eAAe,OAAO,CAAC,MAAM,CAAC;AACjH;;;AC5CA,SAAS,oCAAoC,+CAA+C;AAE5F,SAAS,wBAAwB;AAKjC,IAAI;AAEG,SAAS,kBAAkB,mBAAmE;AACjG,MAAI,CAAC;AAAe,oBAAgB,iBAAiB;AAErD,MAAI;AAEA;AAAA;AAAA,MAEI,kBAAkB,SAAS;AAAA,MAE3B,kBAAkB,SAAS;AAAA,MAC7B;AACE,YAAM,IAAI,MAAM,+DAA+D;AAAA,IACnF;AAEA,UAAM,QAAQ,cAAc,OAAO,iBAAiB;AACpD,UAAM,WAAW,MAAM;AACvB,QAAI,aAAa,IAAI;AACjB,YAAM,IAAI,MAAM,gFAAgF,QAAQ,EAAE;AAAA,IAC9G;AAAA,EACJ,SAAS,GAAG;AACR,UAAM,IAAI,MAAM,KAAK,iBAAiB,yBAAyB;AAAA,MAC3D,OAAO;AAAA,IACX,CAAC;AAAA,EACL;AACJ;AAEO,SAAS,YAAY,mBAA2D;AACnF,MAAI,CAAC;AAAe,oBAAgB,iBAAiB;AAGrD;AAAA;AAAA,IAEI,kBAAkB,SAAS;AAAA,IAE3B,kBAAkB,SAAS;AAAA,IAC7B;AACE,WAAO;AAAA,EACX;AAEA,QAAM,QAAQ,cAAc,OAAO,iBAAiB;AACpD,QAAM,WAAW,MAAM;AACvB,MAAI,aAAa,IAAI;AACjB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAEA,eAAsB,UAAU,KAAgB,MAA2C;AACvF,QAAM,mCAAmC;AACzC,QAAM,aAAa,MAAM,OAAO,OAAO,KAAK,WAAW,KAAK,IAAI;AAChE,SAAO,IAAI,WAAW,UAAU;AACpC;AAEO,SAAS,UAAU,mBAAsC;AAC5D,oBAAkB,iBAAiB;AACnC,SAAO;AACX;AAEA,eAAsB,gBAAgB,KAAgBA,YAA2B,MAAoC;AACjH,QAAM,wCAAwC;AAC9C,SAAO,MAAM,OAAO,OAAO,OAAO,WAAW,KAAKA,YAAW,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","function addPkcs8Header(bytes: Uint8Array): Uint8Array {\n    // prettier-ignore\n    return new Uint8Array([\n        /**\n         * PKCS#8 header\n         */\n        0x30, // ASN.1 sequence tag\n        0x2e, // Length of sequence (46 more bytes)\n\n            0x02, // ASN.1 integer tag\n            0x01, // Length of integer\n                0x00, // Version number\n\n            0x30, // ASN.1 sequence tag\n            0x05, // Length of sequence\n                0x06, // ASN.1 object identifier tag\n                0x03, // Length of object identifier\n                    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112\n                        0x2b, // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)\n                        0x65, // thawte(101)\n                    // Ed25519 identifier\n                        0x70, // id-Ed25519(112)\n\n        /**\n         * Private key payload\n         */\n        0x04, // ASN.1 octet string tag\n        0x22, // String length (34 more bytes)\n\n            // Private key bytes as octet string\n            0x04, // ASN.1 octet string tag\n            0x20, // String length (32 bytes)\n\n        ...bytes\n    ]);\n}\n\nexport async function createPrivateKeyFromBytes(bytes: Uint8Array, extractable?: boolean): Promise<CryptoKey> {\n    if (bytes.byteLength !== 32) {\n        // TODO: Coded error.\n        throw new Error('Private key bytes must be of length 32');\n    }\n    const privateKeyBytesPkcs8 = addPkcs8Header(bytes);\n    return await crypto.subtle.importKey('pkcs8', privateKeyBytesPkcs8, 'Ed25519', extractable ?? false, ['sign']);\n}\n","import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';\nimport { Encoder } from '@solana/codecs-core';\nimport { getBase58Encoder } from '@solana/codecs-strings';\n\nexport type Signature = string & { readonly __brand: unique symbol };\nexport type SignatureBytes = Uint8Array & { readonly __brand: unique symbol };\n\nlet base58Encoder: Encoder<string> | undefined;\n\nexport function assertIsSignature(putativeSignature: string): asserts putativeSignature is Signature {\n    if (!base58Encoder) base58Encoder = getBase58Encoder();\n\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest value (64 bytes of zeroes)\n            putativeSignature.length < 64 ||\n            // Highest value (64 bytes of 255)\n            putativeSignature.length > 88\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 64.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = base58Encoder.encode(putativeSignature);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 64) {\n            throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeSignature}\\` is not a signature`, {\n            cause: e,\n        });\n    }\n}\n\nexport function isSignature(putativeSignature: string): putativeSignature is Signature {\n    if (!base58Encoder) base58Encoder = getBase58Encoder();\n\n    // Fast-path; see if the input string is of an acceptable length.\n    if (\n        // Lowest value (64 bytes of zeroes)\n        putativeSignature.length < 64 ||\n        // Highest value (64 bytes of 255)\n        putativeSignature.length > 88\n    ) {\n        return false;\n    }\n    // Slow-path; actually attempt to decode the input string.\n    const bytes = base58Encoder.encode(putativeSignature);\n    const numBytes = bytes.byteLength;\n    if (numBytes !== 64) {\n        return false;\n    }\n    return true;\n}\n\nexport async function signBytes(key: CryptoKey, data: Uint8Array): Promise<SignatureBytes> {\n    await assertSigningCapabilityIsAvailable();\n    const signedData = await crypto.subtle.sign('Ed25519', key, data);\n    return new Uint8Array(signedData) as SignatureBytes;\n}\n\nexport function signature(putativeSignature: string): Signature {\n    assertIsSignature(putativeSignature);\n    return putativeSignature;\n}\n\nexport async function verifySignature(key: CryptoKey, signature: SignatureBytes, 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,6 +1,7 @@
 'use strict';
 
 var assertions = require('@solana/assertions');
+var codecsStrings = require('@solana/codecs-strings');
 
 // src/key-pair.ts
 async function generateKeyPair() {
@@ -17,18 +18,121 @@ async function generateKeyPair() {
   );
   return keyPair;
 }
+
+// src/private-key.ts
+function addPkcs8Header(bytes) {
+  return new Uint8Array([
+    /**
+     * PKCS#8 header
+     */
+    48,
+    // ASN.1 sequence tag
+    46,
+    // Length of sequence (46 more bytes)
+    2,
+    // ASN.1 integer tag
+    1,
+    // Length of integer
+    0,
+    // Version number
+    48,
+    // ASN.1 sequence tag
+    5,
+    // Length of sequence
+    6,
+    // ASN.1 object identifier tag
+    3,
+    // Length of object identifier
+    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112
+    43,
+    // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)
+    101,
+    // thawte(101)
+    // Ed25519 identifier
+    112,
+    // id-Ed25519(112)
+    /**
+     * Private key payload
+     */
+    4,
+    // ASN.1 octet string tag
+    34,
+    // String length (34 more bytes)
+    // Private key bytes as octet string
+    4,
+    // ASN.1 octet string tag
+    32,
+    // String length (32 bytes)
+    ...bytes
+  ]);
+}
+async function createPrivateKeyFromBytes(bytes, extractable) {
+  if (bytes.byteLength !== 32) {
+    throw new Error("Private key bytes must be of length 32");
+  }
+  const privateKeyBytesPkcs8 = addPkcs8Header(bytes);
+  return await crypto.subtle.importKey("pkcs8", privateKeyBytesPkcs8, "Ed25519", extractable ?? false, ["sign"]);
+}
+var base58Encoder;
+function assertIsSignature(putativeSignature) {
+  if (!base58Encoder)
+    base58Encoder = codecsStrings.getBase58Encoder();
+  try {
+    if (
+      // Lowest value (64 bytes of zeroes)
+      putativeSignature.length < 64 || // Highest value (64 bytes of 255)
+      putativeSignature.length > 88
+    ) {
+      throw new Error("Expected input string to decode to a byte array of length 64.");
+    }
+    const bytes = base58Encoder.encode(putativeSignature);
+    const numBytes = bytes.byteLength;
+    if (numBytes !== 64) {
+      throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
+    }
+  } catch (e) {
+    throw new Error(`\`${putativeSignature}\` is not a signature`, {
+      cause: e
+    });
+  }
+}
+function isSignature(putativeSignature) {
+  if (!base58Encoder)
+    base58Encoder = codecsStrings.getBase58Encoder();
+  if (
+    // Lowest value (64 bytes of zeroes)
+    putativeSignature.length < 64 || // Highest value (64 bytes of 255)
+    putativeSignature.length > 88
+  ) {
+    return false;
+  }
+  const bytes = base58Encoder.encode(putativeSignature);
+  const numBytes = bytes.byteLength;
+  if (numBytes !== 64) {
+    return false;
+  }
+  return true;
+}
 async function signBytes(key, data) {
   await assertions.assertSigningCapabilityIsAvailable();
   const signedData = await crypto.subtle.sign("Ed25519", key, data);
   return new Uint8Array(signedData);
 }
-async function verifySignature(key, signature, data) {
+function signature(putativeSignature) {
+  assertIsSignature(putativeSignature);
+  return putativeSignature;
+}
+async function verifySignature(key, signature2, data) {
   await assertions.assertVerificationCapabilityIsAvailable();
-  return await crypto.subtle.verify("Ed25519", key, signature, data);
+  return await crypto.subtle.verify("Ed25519", key, signature2, data);
 }
 
+exports.assertIsSignature = assertIsSignature;
+exports.createPrivateKeyFromBytes = createPrivateKeyFromBytes;
 exports.generateKeyPair = generateKeyPair;
+exports.isSignature = isSignature;
 exports.signBytes = signBytes;
+exports.signature = signature;
 exports.verifySignature = verifySignature;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.node.cjs.map

package/dist/index.node.cjs.map

@@ -1 +1 @@
-{"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 __brand: 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"]}
+{"version":3,"sources":["../src/key-pair.ts","../src/private-key.ts","../src/signatures.ts"],"names":["signature"],"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,eAAe,OAA+B;AAEnD,SAAO,IAAI,WAAW;AAAA;AAAA;AAAA;AAAA,IAIlB;AAAA;AAAA,IACA;AAAA;AAAA,IAEI;AAAA;AAAA,IACA;AAAA;AAAA,IACI;AAAA;AAAA,IAEJ;AAAA;AAAA,IACA;AAAA;AAAA,IACI;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAEQ;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAEA;AAAA;AAAA;AAAA;AAAA;AAAA,IAKhB;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAGI;AAAA;AAAA,IACA;AAAA;AAAA,IAEJ,GAAG;AAAA,EACP,CAAC;AACL;AAEA,eAAsB,0BAA0B,OAAmB,aAA2C;AAC1G,MAAI,MAAM,eAAe,IAAI;AAEzB,UAAM,IAAI,MAAM,wCAAwC;AAAA,EAC5D;AACA,QAAM,uBAAuB,eAAe,KAAK;AACjD,SAAO,MAAM,OAAO,OAAO,UAAU,SAAS,sBAAsB,WAAW,eAAe,OAAO,CAAC,MAAM,CAAC;AACjH;;;AC5CA,SAAS,oCAAoC,+CAA+C;AAE5F,SAAS,wBAAwB;AAKjC,IAAI;AAEG,SAAS,kBAAkB,mBAAmE;AACjG,MAAI,CAAC;AAAe,oBAAgB,iBAAiB;AAErD,MAAI;AAEA;AAAA;AAAA,MAEI,kBAAkB,SAAS;AAAA,MAE3B,kBAAkB,SAAS;AAAA,MAC7B;AACE,YAAM,IAAI,MAAM,+DAA+D;AAAA,IACnF;AAEA,UAAM,QAAQ,cAAc,OAAO,iBAAiB;AACpD,UAAM,WAAW,MAAM;AACvB,QAAI,aAAa,IAAI;AACjB,YAAM,IAAI,MAAM,gFAAgF,QAAQ,EAAE;AAAA,IAC9G;AAAA,EACJ,SAAS,GAAG;AACR,UAAM,IAAI,MAAM,KAAK,iBAAiB,yBAAyB;AAAA,MAC3D,OAAO;AAAA,IACX,CAAC;AAAA,EACL;AACJ;AAEO,SAAS,YAAY,mBAA2D;AACnF,MAAI,CAAC;AAAe,oBAAgB,iBAAiB;AAGrD;AAAA;AAAA,IAEI,kBAAkB,SAAS;AAAA,IAE3B,kBAAkB,SAAS;AAAA,IAC7B;AACE,WAAO;AAAA,EACX;AAEA,QAAM,QAAQ,cAAc,OAAO,iBAAiB;AACpD,QAAM,WAAW,MAAM;AACvB,MAAI,aAAa,IAAI;AACjB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAEA,eAAsB,UAAU,KAAgB,MAA2C;AACvF,QAAM,mCAAmC;AACzC,QAAM,aAAa,MAAM,OAAO,OAAO,KAAK,WAAW,KAAK,IAAI;AAChE,SAAO,IAAI,WAAW,UAAU;AACpC;AAEO,SAAS,UAAU,mBAAsC;AAC5D,oBAAkB,iBAAiB;AACnC,SAAO;AACX;AAEA,eAAsB,gBAAgB,KAAgBA,YAA2B,MAAoC;AACjH,QAAM,wCAAwC;AAC9C,SAAO,MAAM,OAAO,OAAO,OAAO,WAAW,KAAKA,YAAW,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","function addPkcs8Header(bytes: Uint8Array): Uint8Array {\n    // prettier-ignore\n    return new Uint8Array([\n        /**\n         * PKCS#8 header\n         */\n        0x30, // ASN.1 sequence tag\n        0x2e, // Length of sequence (46 more bytes)\n\n            0x02, // ASN.1 integer tag\n            0x01, // Length of integer\n                0x00, // Version number\n\n            0x30, // ASN.1 sequence tag\n            0x05, // Length of sequence\n                0x06, // ASN.1 object identifier tag\n                0x03, // Length of object identifier\n                    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112\n                        0x2b, // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)\n                        0x65, // thawte(101)\n                    // Ed25519 identifier\n                        0x70, // id-Ed25519(112)\n\n        /**\n         * Private key payload\n         */\n        0x04, // ASN.1 octet string tag\n        0x22, // String length (34 more bytes)\n\n            // Private key bytes as octet string\n            0x04, // ASN.1 octet string tag\n            0x20, // String length (32 bytes)\n\n        ...bytes\n    ]);\n}\n\nexport async function createPrivateKeyFromBytes(bytes: Uint8Array, extractable?: boolean): Promise<CryptoKey> {\n    if (bytes.byteLength !== 32) {\n        // TODO: Coded error.\n        throw new Error('Private key bytes must be of length 32');\n    }\n    const privateKeyBytesPkcs8 = addPkcs8Header(bytes);\n    return await crypto.subtle.importKey('pkcs8', privateKeyBytesPkcs8, 'Ed25519', extractable ?? false, ['sign']);\n}\n","import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';\nimport { Encoder } from '@solana/codecs-core';\nimport { getBase58Encoder } from '@solana/codecs-strings';\n\nexport type Signature = string & { readonly __brand: unique symbol };\nexport type SignatureBytes = Uint8Array & { readonly __brand: unique symbol };\n\nlet base58Encoder: Encoder<string> | undefined;\n\nexport function assertIsSignature(putativeSignature: string): asserts putativeSignature is Signature {\n    if (!base58Encoder) base58Encoder = getBase58Encoder();\n\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest value (64 bytes of zeroes)\n            putativeSignature.length < 64 ||\n            // Highest value (64 bytes of 255)\n            putativeSignature.length > 88\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 64.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = base58Encoder.encode(putativeSignature);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 64) {\n            throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeSignature}\\` is not a signature`, {\n            cause: e,\n        });\n    }\n}\n\nexport function isSignature(putativeSignature: string): putativeSignature is Signature {\n    if (!base58Encoder) base58Encoder = getBase58Encoder();\n\n    // Fast-path; see if the input string is of an acceptable length.\n    if (\n        // Lowest value (64 bytes of zeroes)\n        putativeSignature.length < 64 ||\n        // Highest value (64 bytes of 255)\n        putativeSignature.length > 88\n    ) {\n        return false;\n    }\n    // Slow-path; actually attempt to decode the input string.\n    const bytes = base58Encoder.encode(putativeSignature);\n    const numBytes = bytes.byteLength;\n    if (numBytes !== 64) {\n        return false;\n    }\n    return true;\n}\n\nexport async function signBytes(key: CryptoKey, data: Uint8Array): Promise<SignatureBytes> {\n    await assertSigningCapabilityIsAvailable();\n    const signedData = await crypto.subtle.sign('Ed25519', key, data);\n    return new Uint8Array(signedData) as SignatureBytes;\n}\n\nexport function signature(putativeSignature: string): Signature {\n    assertIsSignature(putativeSignature);\n    return putativeSignature;\n}\n\nexport async function verifySignature(key: CryptoKey, signature: SignatureBytes, 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,4 +1,5 @@
 import { assertKeyGenerationIsAvailable, assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';
+import { getBase58Encoder } from '@solana/codecs-strings';
 
 // src/key-pair.ts
 async function generateKeyPair() {
@@ -15,16 +16,115 @@ async function generateKeyPair() {
   );
   return keyPair;
 }
+
+// src/private-key.ts
+function addPkcs8Header(bytes) {
+  return new Uint8Array([
+    /**
+     * PKCS#8 header
+     */
+    48,
+    // ASN.1 sequence tag
+    46,
+    // Length of sequence (46 more bytes)
+    2,
+    // ASN.1 integer tag
+    1,
+    // Length of integer
+    0,
+    // Version number
+    48,
+    // ASN.1 sequence tag
+    5,
+    // Length of sequence
+    6,
+    // ASN.1 object identifier tag
+    3,
+    // Length of object identifier
+    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112
+    43,
+    // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)
+    101,
+    // thawte(101)
+    // Ed25519 identifier
+    112,
+    // id-Ed25519(112)
+    /**
+     * Private key payload
+     */
+    4,
+    // ASN.1 octet string tag
+    34,
+    // String length (34 more bytes)
+    // Private key bytes as octet string
+    4,
+    // ASN.1 octet string tag
+    32,
+    // String length (32 bytes)
+    ...bytes
+  ]);
+}
+async function createPrivateKeyFromBytes(bytes, extractable) {
+  if (bytes.byteLength !== 32) {
+    throw new Error("Private key bytes must be of length 32");
+  }
+  const privateKeyBytesPkcs8 = addPkcs8Header(bytes);
+  return await crypto.subtle.importKey("pkcs8", privateKeyBytesPkcs8, "Ed25519", extractable ?? false, ["sign"]);
+}
+var base58Encoder;
+function assertIsSignature(putativeSignature) {
+  if (!base58Encoder)
+    base58Encoder = getBase58Encoder();
+  try {
+    if (
+      // Lowest value (64 bytes of zeroes)
+      putativeSignature.length < 64 || // Highest value (64 bytes of 255)
+      putativeSignature.length > 88
+    ) {
+      throw new Error("Expected input string to decode to a byte array of length 64.");
+    }
+    const bytes = base58Encoder.encode(putativeSignature);
+    const numBytes = bytes.byteLength;
+    if (numBytes !== 64) {
+      throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
+    }
+  } catch (e) {
+    throw new Error(`\`${putativeSignature}\` is not a signature`, {
+      cause: e
+    });
+  }
+}
+function isSignature(putativeSignature) {
+  if (!base58Encoder)
+    base58Encoder = getBase58Encoder();
+  if (
+    // Lowest value (64 bytes of zeroes)
+    putativeSignature.length < 64 || // Highest value (64 bytes of 255)
+    putativeSignature.length > 88
+  ) {
+    return false;
+  }
+  const bytes = base58Encoder.encode(putativeSignature);
+  const numBytes = bytes.byteLength;
+  if (numBytes !== 64) {
+    return false;
+  }
+  return true;
+}
 async function signBytes(key, data) {
   await assertSigningCapabilityIsAvailable();
   const signedData = await crypto.subtle.sign("Ed25519", key, data);
   return new Uint8Array(signedData);
 }
-async function verifySignature(key, signature, data) {
+function signature(putativeSignature) {
+  assertIsSignature(putativeSignature);
+  return putativeSignature;
+}
+async function verifySignature(key, signature2, data) {
   await assertVerificationCapabilityIsAvailable();
-  return await crypto.subtle.verify("Ed25519", key, signature, data);
+  return await crypto.subtle.verify("Ed25519", key, signature2, data);
 }
 
-export { generateKeyPair, signBytes, verifySignature };
+export { assertIsSignature, createPrivateKeyFromBytes, generateKeyPair, isSignature, signBytes, signature, verifySignature };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.node.js.map

package/dist/index.node.js.map

@@ -1 +1 @@
-{"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 __brand: 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"]}
+{"version":3,"sources":["../src/key-pair.ts","../src/private-key.ts","../src/signatures.ts"],"names":["signature"],"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,eAAe,OAA+B;AAEnD,SAAO,IAAI,WAAW;AAAA;AAAA;AAAA;AAAA,IAIlB;AAAA;AAAA,IACA;AAAA;AAAA,IAEI;AAAA;AAAA,IACA;AAAA;AAAA,IACI;AAAA;AAAA,IAEJ;AAAA;AAAA,IACA;AAAA;AAAA,IACI;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAEQ;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAEA;AAAA;AAAA;AAAA;AAAA;AAAA,IAKhB;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,IAGI;AAAA;AAAA,IACA;AAAA;AAAA,IAEJ,GAAG;AAAA,EACP,CAAC;AACL;AAEA,eAAsB,0BAA0B,OAAmB,aAA2C;AAC1G,MAAI,MAAM,eAAe,IAAI;AAEzB,UAAM,IAAI,MAAM,wCAAwC;AAAA,EAC5D;AACA,QAAM,uBAAuB,eAAe,KAAK;AACjD,SAAO,MAAM,OAAO,OAAO,UAAU,SAAS,sBAAsB,WAAW,eAAe,OAAO,CAAC,MAAM,CAAC;AACjH;;;AC5CA,SAAS,oCAAoC,+CAA+C;AAE5F,SAAS,wBAAwB;AAKjC,IAAI;AAEG,SAAS,kBAAkB,mBAAmE;AACjG,MAAI,CAAC;AAAe,oBAAgB,iBAAiB;AAErD,MAAI;AAEA;AAAA;AAAA,MAEI,kBAAkB,SAAS;AAAA,MAE3B,kBAAkB,SAAS;AAAA,MAC7B;AACE,YAAM,IAAI,MAAM,+DAA+D;AAAA,IACnF;AAEA,UAAM,QAAQ,cAAc,OAAO,iBAAiB;AACpD,UAAM,WAAW,MAAM;AACvB,QAAI,aAAa,IAAI;AACjB,YAAM,IAAI,MAAM,gFAAgF,QAAQ,EAAE;AAAA,IAC9G;AAAA,EACJ,SAAS,GAAG;AACR,UAAM,IAAI,MAAM,KAAK,iBAAiB,yBAAyB;AAAA,MAC3D,OAAO;AAAA,IACX,CAAC;AAAA,EACL;AACJ;AAEO,SAAS,YAAY,mBAA2D;AACnF,MAAI,CAAC;AAAe,oBAAgB,iBAAiB;AAGrD;AAAA;AAAA,IAEI,kBAAkB,SAAS;AAAA,IAE3B,kBAAkB,SAAS;AAAA,IAC7B;AACE,WAAO;AAAA,EACX;AAEA,QAAM,QAAQ,cAAc,OAAO,iBAAiB;AACpD,QAAM,WAAW,MAAM;AACvB,MAAI,aAAa,IAAI;AACjB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAEA,eAAsB,UAAU,KAAgB,MAA2C;AACvF,QAAM,mCAAmC;AACzC,QAAM,aAAa,MAAM,OAAO,OAAO,KAAK,WAAW,KAAK,IAAI;AAChE,SAAO,IAAI,WAAW,UAAU;AACpC;AAEO,SAAS,UAAU,mBAAsC;AAC5D,oBAAkB,iBAAiB;AACnC,SAAO;AACX;AAEA,eAAsB,gBAAgB,KAAgBA,YAA2B,MAAoC;AACjH,QAAM,wCAAwC;AAC9C,SAAO,MAAM,OAAO,OAAO,OAAO,WAAW,KAAKA,YAAW,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","function addPkcs8Header(bytes: Uint8Array): Uint8Array {\n    // prettier-ignore\n    return new Uint8Array([\n        /**\n         * PKCS#8 header\n         */\n        0x30, // ASN.1 sequence tag\n        0x2e, // Length of sequence (46 more bytes)\n\n            0x02, // ASN.1 integer tag\n            0x01, // Length of integer\n                0x00, // Version number\n\n            0x30, // ASN.1 sequence tag\n            0x05, // Length of sequence\n                0x06, // ASN.1 object identifier tag\n                0x03, // Length of object identifier\n                    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112\n                        0x2b, // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)\n                        0x65, // thawte(101)\n                    // Ed25519 identifier\n                        0x70, // id-Ed25519(112)\n\n        /**\n         * Private key payload\n         */\n        0x04, // ASN.1 octet string tag\n        0x22, // String length (34 more bytes)\n\n            // Private key bytes as octet string\n            0x04, // ASN.1 octet string tag\n            0x20, // String length (32 bytes)\n\n        ...bytes\n    ]);\n}\n\nexport async function createPrivateKeyFromBytes(bytes: Uint8Array, extractable?: boolean): Promise<CryptoKey> {\n    if (bytes.byteLength !== 32) {\n        // TODO: Coded error.\n        throw new Error('Private key bytes must be of length 32');\n    }\n    const privateKeyBytesPkcs8 = addPkcs8Header(bytes);\n    return await crypto.subtle.importKey('pkcs8', privateKeyBytesPkcs8, 'Ed25519', extractable ?? false, ['sign']);\n}\n","import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';\nimport { Encoder } from '@solana/codecs-core';\nimport { getBase58Encoder } from '@solana/codecs-strings';\n\nexport type Signature = string & { readonly __brand: unique symbol };\nexport type SignatureBytes = Uint8Array & { readonly __brand: unique symbol };\n\nlet base58Encoder: Encoder<string> | undefined;\n\nexport function assertIsSignature(putativeSignature: string): asserts putativeSignature is Signature {\n    if (!base58Encoder) base58Encoder = getBase58Encoder();\n\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest value (64 bytes of zeroes)\n            putativeSignature.length < 64 ||\n            // Highest value (64 bytes of 255)\n            putativeSignature.length > 88\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 64.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = base58Encoder.encode(putativeSignature);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 64) {\n            throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeSignature}\\` is not a signature`, {\n            cause: e,\n        });\n    }\n}\n\nexport function isSignature(putativeSignature: string): putativeSignature is Signature {\n    if (!base58Encoder) base58Encoder = getBase58Encoder();\n\n    // Fast-path; see if the input string is of an acceptable length.\n    if (\n        // Lowest value (64 bytes of zeroes)\n        putativeSignature.length < 64 ||\n        // Highest value (64 bytes of 255)\n        putativeSignature.length > 88\n    ) {\n        return false;\n    }\n    // Slow-path; actually attempt to decode the input string.\n    const bytes = base58Encoder.encode(putativeSignature);\n    const numBytes = bytes.byteLength;\n    if (numBytes !== 64) {\n        return false;\n    }\n    return true;\n}\n\nexport async function signBytes(key: CryptoKey, data: Uint8Array): Promise<SignatureBytes> {\n    await assertSigningCapabilityIsAvailable();\n    const signedData = await crypto.subtle.sign('Ed25519', key, data);\n    return new Uint8Array(signedData) as SignatureBytes;\n}\n\nexport function signature(putativeSignature: string): Signature {\n    assertIsSignature(putativeSignature);\n    return putativeSignature;\n}\n\nexport async function verifySignature(key: CryptoKey, signature: SignatureBytes, data: Uint8Array): Promise<boolean> {\n    await assertVerificationCapabilityIsAvailable();\n    return await crypto.subtle.verify('Ed25519', key, signature, data);\n}\n"]}

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
-export * from './key-pair';
-export * from './signatures';
+export * from './key-pair.js';
+export * from './private-key.js';
+export * from './signatures.js';
 //# 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,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC"}

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/private-key.d.ts

@@ -0,0 +1,2 @@
+export declare function createPrivateKeyFromBytes(bytes: Uint8Array, extractable?: boolean): Promise<CryptoKey>;
+//# sourceMappingURL=private-key.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"private-key.d.ts","sourceRoot":"","sources":["../../src/private-key.ts"],"names":[],"mappings":"AAqCA,wBAAsB,yBAAyB,CAAC,KAAK,EAAE,UAAU,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CAO5G"}

package/dist/types/signatures.d.ts

@@ -1,6 +1,12 @@
-export type Ed25519Signature = Uint8Array & {
+export type Signature = string & {
     readonly __brand: unique symbol;
 };
-export declare function signBytes(key: CryptoKey, data: Uint8Array): Promise<Ed25519Signature>;
-export declare function verifySignature(key: CryptoKey, signature: Ed25519Signature, data: Uint8Array): Promise<boolean>;
+export type SignatureBytes = Uint8Array & {
+    readonly __brand: unique symbol;
+};
+export declare function assertIsSignature(putativeSignature: string): asserts putativeSignature is Signature;
+export declare function isSignature(putativeSignature: string): putativeSignature is Signature;
+export declare function signBytes(key: CryptoKey, data: Uint8Array): Promise<SignatureBytes>;
+export declare function signature(putativeSignature: string): Signature;
+export declare function verifySignature(key: CryptoKey, signature: SignatureBytes, 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":"AAIA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,MAAM,CAAA;CAAE,CAAC;AACrE,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,MAAM,CAAA;CAAE,CAAC;AAI9E,wBAAgB,iBAAiB,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,IAAI,SAAS,CAwBnG;AAED,wBAAgB,WAAW,CAAC,iBAAiB,EAAE,MAAM,GAAG,iBAAiB,IAAI,SAAS,CAmBrF;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,cAAc,CAAC,CAIzF;AAED,wBAAgB,SAAS,CAAC,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAG9D;AAED,wBAAsB,eAAe,CAAC,GAAG,EAAE,SAAS,EAAE,SAAS,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAGnH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/keys",
-  "version": "2.0.0-experimental.f57da91",
+  "version": "2.0.0-experimental.f5d64e6",
   "description": "Helpers for generating and transforming key material",
   "exports": {
     "browser": {
@@ -49,24 +49,26 @@
     "node": ">=17.4"
   },
   "dependencies": {
-    "@solana/assertions": "2.0.0-experimental.f57da91"
+    "@solana/assertions": "2.0.0-experimental.f5d64e6",
+    "@solana/codecs-core": "2.0.0-experimental.f5d64e6",
+    "@solana/codecs-strings": "2.0.0-experimental.f5d64e6"
   },
   "devDependencies": {
     "@solana/eslint-config-solana": "^1.0.2",
-    "@swc/jest": "^0.2.28",
-    "@types/jest": "^29.5.5",
-    "@typescript-eslint/eslint-plugin": "^6.7.0",
+    "@swc/jest": "^0.2.29",
+    "@types/jest": "^29.5.11",
+    "@typescript-eslint/eslint-plugin": "^6.13.2",
     "@typescript-eslint/parser": "^6.3.0",
     "agadoo": "^3.0.0",
     "eslint": "^8.45.0",
-    "eslint-plugin-jest": "^27.2.3",
+    "eslint-plugin-jest": "^27.4.2",
     "eslint-plugin-sort-keys-fix": "^1.1.2",
     "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.6.4",
-    "jest-runner-eslint": "^2.1.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "jest-runner-eslint": "^2.1.2",
     "jest-runner-prettier": "^1.0.0",
-    "prettier": "^2.8",
-    "tsup": "7.2.0",
+    "prettier": "^3.1",
+    "tsup": "^8.0.1",
     "typescript": "^5.2.2",
     "version-from-git": "^1.1.1",
     "build-scripts": "0.0.0",
@@ -82,11 +84,11 @@
     ]
   },
   "scripts": {
-    "compile:js": "tsup --config build-scripts/tsup.config.library.ts",
-    "compile:typedefs": "tsc -p ./tsconfig.declarations.json",
+    "compile:js": "tsup --config build-scripts/tsup.config.package.ts",
+    "compile:typedefs": "tsc -p ./tsconfig.declarations.json && node node_modules/build-scripts/add-js-extension-to-types.mjs",
     "dev": "jest -c node_modules/test-config/jest-dev.config.ts --rootDir . --watch",
     "publish-packages": "pnpm publish --tag experimental --access public --no-git-checks",
-    "style:fix": "pnpm eslint --fix src/* && pnpm prettier -w src/*",
+    "style:fix": "pnpm eslint --fix src/* && pnpm prettier -w src/* package.json",
     "test:lint": "jest -c node_modules/test-config/jest-lint.config.ts --rootDir . --silent",
     "test:prettier": "jest -c node_modules/test-config/jest-prettier.config.ts --rootDir . --silent",
     "test:treeshakability:browser": "agadoo dist/index.browser.js",

package/dist/index.development.js

@@ -1,94 +0,0 @@
-this.globalThis = this.globalThis || {};
-this.globalThis.solanaWeb3 = (function (exports) {
-  'use strict';
-
-  // ../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"
-      );
-    }
-  }
-  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);
-        });
-      });
-    }
-    if (typeof cachedEd25519Decision === "boolean") {
-      return cachedEd25519Decision;
-    } else {
-      return await cachedEd25519Decision;
-    }
-  }
-  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");
-    }
-    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"
-      );
-    }
-  }
-  async function assertSigningCapabilityIsAvailable() {
-    assertIsSecureContext();
-    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.sign !== "function") {
-      throw new Error("No signing implementation could be found");
-    }
-  }
-  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");
-    }
-  }
-
-  // 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;
-  }
-
-  // src/signatures.ts
-  async function signBytes(key, data) {
-    await assertSigningCapabilityIsAvailable();
-    const signedData = await crypto.subtle.sign("Ed25519", key, data);
-    return new Uint8Array(signedData);
-  }
-  async function verifySignature(key, signature, data) {
-    await assertVerificationCapabilityIsAvailable();
-    return await crypto.subtle.verify("Ed25519", key, signature, data);
-  }
-
-  exports.generateKeyPair = generateKeyPair;
-  exports.signBytes = signBytes;
-  exports.verifySignature = verifySignature;
-
-  return exports;
-
-})({});
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.development.js.map

package/dist/index.development.js.map

@@ -1 +0,0 @@
-{"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 __brand: 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

@@ -1,17 +0,0 @@
-this.globalThis = this.globalThis || {};
-this.globalThis.solanaWeb3 = (function (exports) {
-	'use strict';
-
-	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.
-
-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;
-
-})({});