Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
@solana/keys
Advanced tools
@solana/keys - npm Package Compare versions
Comparing version 2.0.0-experimental.f464b8b to 2.0.0-experimental.f5c87d2
@@ -1,103 +0,3 @@ | ||
| 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 | ||
| }); | ||
| } | ||
| } | ||
| function getBase58EncodedAddressCodec(config) { | ||
| return string({ | ||
| description: config?.description ?? (__DEV__ ? "A 32-byte account address" : ""), | ||
| encoding: base58, | ||
| size: 32 | ||
| }); | ||
| } | ||
| function getBase58EncodedAddressComparator() { | ||
| return new Intl.Collator("en", { | ||
| caseFirst: "lower", | ||
| ignorePunctuation: false, | ||
| localeMatcher: "best fit", | ||
| numeric: false, | ||
| sensitivity: "variant", | ||
| usage: "sort" | ||
| }).compare; | ||
| } | ||
| // src/guard.ts | ||
| 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 assertKeyExporterIsAvailable() { | ||
| assertIsSecureContext(); | ||
| if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.exportKey !== "function") { | ||
| throw new Error("No key export implementation could be found"); | ||
| } | ||
| } | ||
| 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 | ||
@@ -118,15 +18,2 @@ async function generateKeyPair() { | ||
| } | ||
| // src/pubkey.ts | ||
| async function getBase58EncodedAddressFromPublicKey(publicKey) { | ||
| await assertKeyExporterIsAvailable(); | ||
| if (publicKey.type !== "public" || publicKey.algorithm.name !== "Ed25519") { | ||
| throw new Error("The `CryptoKey` must be an `Ed25519` public key"); | ||
| } | ||
| const publicKeyBytes = await crypto.subtle.exportKey("raw", publicKey); | ||
| const [base58EncodedAddress] = getBase58EncodedAddressCodec().deserialize(new Uint8Array(publicKeyBytes)); | ||
| return base58EncodedAddress; | ||
| } | ||
| // src/signatures.ts | ||
| async function signBytes(key, data) { | ||
@@ -142,4 +29,4 @@ await assertSigningCapabilityIsAvailable(); | ||
| export { assertIsBase58EncodedAddress, generateKeyPair, getBase58EncodedAddressCodec, getBase58EncodedAddressComparator, getBase58EncodedAddressFromPublicKey, signBytes, verifySignature }; | ||
| export { generateKeyPair, signBytes, verifySignature }; | ||
| //# sourceMappingURL=out.js.map | ||
| //# sourceMappingURL=index.browser.js.map |
@@ -5,306 +5,3 @@ this.globalThis = this.globalThis || {}; | ||
| 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"); | ||
| } | ||
| }; | ||
| // ../../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"); | ||
| } | ||
| }; | ||
| // ../../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)"; | ||
| } | ||
| 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); | ||
| } | ||
| }; | ||
| var assertEnoughBytes = (serializer, bytes, expected) => { | ||
| if (bytes.length === 0) { | ||
| throw new DeserializingEmptyBufferError(serializer); | ||
| } | ||
| 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.5/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.5/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 | ||
| }; | ||
| } | ||
| if (typeof size === "number") { | ||
| return fixSerializer(encoding, size, description); | ||
| } | ||
| 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 | ||
| }); | ||
| } | ||
| } | ||
| function getBase58EncodedAddressCodec(config) { | ||
| return string({ | ||
| description: config?.description ?? ("A 32-byte account address" ), | ||
| encoding: base58, | ||
| size: 32 | ||
| }); | ||
| } | ||
| function getBase58EncodedAddressComparator() { | ||
| return new Intl.Collator("en", { | ||
| caseFirst: "lower", | ||
| ignorePunctuation: false, | ||
| localeMatcher: "best fit", | ||
| numeric: false, | ||
| sensitivity: "variant", | ||
| usage: "sort" | ||
| }).compare; | ||
| } | ||
| // src/guard.ts | ||
| // ../assertions/dist/index.browser.js | ||
| function assertIsSecureContext() { | ||
@@ -350,8 +47,2 @@ if (!globalThis.isSecureContext) { | ||
| } | ||
| async function assertKeyExporterIsAvailable() { | ||
| assertIsSecureContext(); | ||
| if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.exportKey !== "function") { | ||
| throw new Error("No key export implementation could be found"); | ||
| } | ||
| } | ||
| async function assertSigningCapabilityIsAvailable() { | ||
@@ -386,13 +77,2 @@ assertIsSecureContext(); | ||
| // src/pubkey.ts | ||
| async function getBase58EncodedAddressFromPublicKey(publicKey) { | ||
| await assertKeyExporterIsAvailable(); | ||
| if (publicKey.type !== "public" || publicKey.algorithm.name !== "Ed25519") { | ||
| throw new Error("The `CryptoKey` must be an `Ed25519` public key"); | ||
| } | ||
| const publicKeyBytes = await crypto.subtle.exportKey("raw", publicKey); | ||
| const [base58EncodedAddress] = getBase58EncodedAddressCodec().deserialize(new Uint8Array(publicKeyBytes)); | ||
| return base58EncodedAddress; | ||
| } | ||
| // src/signatures.ts | ||
@@ -409,7 +89,3 @@ async function signBytes(key, data) { | ||
| exports.assertIsBase58EncodedAddress = assertIsBase58EncodedAddress; | ||
| exports.generateKeyPair = generateKeyPair; | ||
| exports.getBase58EncodedAddressCodec = getBase58EncodedAddressCodec; | ||
| exports.getBase58EncodedAddressComparator = getBase58EncodedAddressComparator; | ||
| exports.getBase58EncodedAddressFromPublicKey = getBase58EncodedAddressFromPublicKey; | ||
| exports.signBytes = signBytes; | ||
@@ -416,0 +92,0 @@ exports.verifySignature = verifySignature; |
@@ -1,90 +0,3 @@ | ||
| 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 | ||
| }); | ||
| } | ||
| } | ||
| function getBase58EncodedAddressCodec(config) { | ||
| return string({ | ||
| description: config?.description ?? (__DEV__ ? "A 32-byte account address" : ""), | ||
| encoding: base58, | ||
| size: 32 | ||
| }); | ||
| } | ||
| function getBase58EncodedAddressComparator() { | ||
| return new Intl.Collator("en", { | ||
| caseFirst: "lower", | ||
| ignorePunctuation: false, | ||
| localeMatcher: "best fit", | ||
| numeric: false, | ||
| sensitivity: "variant", | ||
| usage: "sort" | ||
| }).compare; | ||
| } | ||
| 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() { | ||
| 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 assertKeyExporterIsAvailable() { | ||
| if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.exportKey !== "function") { | ||
| throw new Error("No key export implementation could be found"); | ||
| } | ||
| } | ||
| async function assertSigningCapabilityIsAvailable() { | ||
| if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.sign !== "function") { | ||
| throw new Error("No signing implementation could be found"); | ||
| } | ||
| } | ||
| async function assertVerificationCapabilityIsAvailable() { | ||
| 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 | ||
@@ -105,15 +18,2 @@ async function generateKeyPair() { | ||
| } | ||
| // src/pubkey.ts | ||
| async function getBase58EncodedAddressFromPublicKey(publicKey) { | ||
| await assertKeyExporterIsAvailable(); | ||
| if (publicKey.type !== "public" || publicKey.algorithm.name !== "Ed25519") { | ||
| throw new Error("The `CryptoKey` must be an `Ed25519` public key"); | ||
| } | ||
| const publicKeyBytes = await crypto.subtle.exportKey("raw", publicKey); | ||
| const [base58EncodedAddress] = getBase58EncodedAddressCodec().deserialize(new Uint8Array(publicKeyBytes)); | ||
| return base58EncodedAddress; | ||
| } | ||
| // src/signatures.ts | ||
| async function signBytes(key, data) { | ||
@@ -129,4 +29,4 @@ await assertSigningCapabilityIsAvailable(); | ||
| export { assertIsBase58EncodedAddress, generateKeyPair, getBase58EncodedAddressCodec, getBase58EncodedAddressComparator, getBase58EncodedAddressFromPublicKey, signBytes, verifySignature }; | ||
| export { generateKeyPair, signBytes, verifySignature }; | ||
| //# sourceMappingURL=out.js.map | ||
| //# sourceMappingURL=index.native.js.map |
@@ -1,90 +0,3 @@ | ||
| 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 | ||
| }); | ||
| } | ||
| } | ||
| function getBase58EncodedAddressCodec(config) { | ||
| return string({ | ||
| description: config?.description ?? (__DEV__ ? "A 32-byte account address" : ""), | ||
| encoding: base58, | ||
| size: 32 | ||
| }); | ||
| } | ||
| function getBase58EncodedAddressComparator() { | ||
| return new Intl.Collator("en", { | ||
| caseFirst: "lower", | ||
| ignorePunctuation: false, | ||
| localeMatcher: "best fit", | ||
| numeric: false, | ||
| sensitivity: "variant", | ||
| usage: "sort" | ||
| }).compare; | ||
| } | ||
| 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() { | ||
| 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 assertKeyExporterIsAvailable() { | ||
| if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.exportKey !== "function") { | ||
| throw new Error("No key export implementation could be found"); | ||
| } | ||
| } | ||
| async function assertSigningCapabilityIsAvailable() { | ||
| if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.sign !== "function") { | ||
| throw new Error("No signing implementation could be found"); | ||
| } | ||
| } | ||
| async function assertVerificationCapabilityIsAvailable() { | ||
| 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 | ||
@@ -105,15 +18,2 @@ async function generateKeyPair() { | ||
| } | ||
| // src/pubkey.ts | ||
| async function getBase58EncodedAddressFromPublicKey(publicKey) { | ||
| await assertKeyExporterIsAvailable(); | ||
| if (publicKey.type !== "public" || publicKey.algorithm.name !== "Ed25519") { | ||
| throw new Error("The `CryptoKey` must be an `Ed25519` public key"); | ||
| } | ||
| const publicKeyBytes = await crypto.subtle.exportKey("raw", publicKey); | ||
| const [base58EncodedAddress] = getBase58EncodedAddressCodec().deserialize(new Uint8Array(publicKeyBytes)); | ||
| return base58EncodedAddress; | ||
| } | ||
| // src/signatures.ts | ||
| async function signBytes(key, data) { | ||
@@ -129,4 +29,4 @@ await assertSigningCapabilityIsAvailable(); | ||
| export { assertIsBase58EncodedAddress, generateKeyPair, getBase58EncodedAddressCodec, getBase58EncodedAddressComparator, getBase58EncodedAddressFromPublicKey, signBytes, verifySignature }; | ||
| export { generateKeyPair, signBytes, verifySignature }; | ||
| //# sourceMappingURL=out.js.map | ||
| //# sourceMappingURL=index.node.js.map |
@@ -5,15 +5,11 @@ this.globalThis = this.globalThis || {}; | ||
| var O=Object.defineProperty;var R=(e,r,t)=>r in e?O(e,r,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[r]=t;var m=(e,r,t)=>(R(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},I=(e,r)=>{if(e.length>=r)return e;let t=new Uint8Array(r).fill(0);return t.set(e),t},x=(e,r)=>I(e.slice(0,r),r);var g=class extends Error{constructor(t){super(`Serializer [${t}] cannot deserialize empty buffers.`);m(this,"name","DeserializingEmptyBufferError");}},p=class extends Error{constructor(t,o,n){super(`Serializer [${t}] expected ${o} bytes, got ${n}.`);m(this,"name","NotEnoughBytesError");}};function A(e,r,t){return {description:t??`fixed(${r}, ${e.description})`,fixedSize:r,maxSize:r,serialize:o=>x(e.serialize(o),r),deserialize:(o,n=0)=>{if(o=o.slice(n,n+r),o.length<r)throw new p("fixSerializer",r,o.length);e.fixedSize!==null&&(o=x(o,e.fixedSize));let[i]=e.deserialize(o,0);return [i,n+r]}}}var h=class extends Error{constructor(t,o,n){let i=`Expected a string of base ${o}, got [${t}].`;super(i);m(this,"name","InvalidBaseStringError");this.cause=n;}};var N=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 h(o,r);if(o==="")return new Uint8Array;let n=[...o],i=n.findIndex(d=>d!==e[0]);i=i===-1?n.length:i;let a=Array(i).fill(0);if(i===n.length)return Uint8Array.from(a);let u=n.slice(i),l=0n,c=1n;for(let d=u.length-1;d>=0;d-=1)l+=c*BigInt(e.indexOf(u[d])),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 u=e[0].repeat(a);if(a===i.length)return [u,o.length];let l=i.slice(a).reduce((f,d)=>f*256n+BigInt(d),0n),c=[];for(;l>0n;)c.unshift(e[Number(l%t)]),l/=t;return [u+c.join(""),o.length]}}};var E=N("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");var $=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 [$(t),e.length]}};var b;(function(e){e.Little="le",e.Big="be";})(b||(b={}));var w=class extends RangeError{constructor(t,o,n,i){super(`Serializer [${t}] expected number to be between ${o} and ${n}, got ${i}.`);m(this,"name","NumberOutOfRangeError");}};function U(e){let r,t=e.name;return e.size>1&&(r=!("endian"in e.options)||e.options.endian===b.Little,t+=r?"(le)":"(be)"),{description:e.options.description??t,fixedSize:e.size,maxSize:e.size,serialize(o){e.range&&F(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);j("i8",i,e.size);let a=V(i);return [e.get(a,r),n+e.size]}}}var L=e=>e.buffer.slice(e.byteOffset,e.byteLength+e.byteOffset),V=e=>new DataView(L(e)),F=(e,r,t,o)=>{if(o<r||o>t)throw new w(e,r,t,o)},j=(e,r,t)=>{if(r.length===0)throw new g(e);if(r.length<t)throw new p(e,t,r.length)};var v=(e={})=>U({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 C(e={}){let r=e.size??v(),t=e.encoding??B,o=e.description??`string(${t.description}; ${D(r)})`;return r==="variable"?{...t,description:o}:typeof r=="number"?A(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 g("string");let[a,u]=r.deserialize(n,i),l=Number(a);i=u;let c=n.slice(i,i+l);if(c.length<l)throw new p("string",l,c.length);let[f,d]=t.deserialize(c);return i+=d,[f,i]}}}function nr(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=E.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 K(e){return C({description:e?.description??"",encoding:E,size:32})}function ir(){return new Intl.Collator("en",{caseFirst:"lower",ignorePunctuation:!1,localeMatcher:"best fit",numeric:!1,sensitivity:"variant",usage:"sort"}).compare}function z(){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 y;async function X(e){return y===void 0&&(y=new Promise(r=>{e.generateKey("Ed25519",!1,["sign","verify"]).catch(()=>{r(y=!1);}).then(()=>{r(y=!0);});})),typeof y=="boolean"?y:await y}async function _(){if(z(),typeof globalThis.crypto>"u"||typeof globalThis.crypto.subtle?.generateKey!="function")throw new Error("No key generation implementation could be found");if(!await X(globalThis.crypto.subtle))throw new Error(`This runtime does not support the generation of Ed25519 key pairs. | ||
| 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 P(){if(z(),typeof globalThis.crypto>"u"||typeof globalThis.crypto.subtle?.exportKey!="function")throw new Error("No key export implementation could be found")}async function T(){if(z(),typeof globalThis.crypto>"u"||typeof globalThis.crypto.subtle?.sign!="function")throw new Error("No signing implementation could be found")}async function k(){if(z(),typeof globalThis.crypto>"u"||typeof globalThis.crypto.subtle?.verify!="function")throw new Error("No signature verification implementation could be found")}async function pr(){return await _(),await crypto.subtle.generateKey("Ed25519",!1,["sign","verify"])}async function xr(e){if(await P(),e.type!=="public"||e.algorithm.name!=="Ed25519")throw new Error("The `CryptoKey` must be an `Ed25519` public key");let r=await crypto.subtle.exportKey("raw",e),[t]=K().deserialize(new Uint8Array(r));return t}async function wr(e,r){await T();let t=await crypto.subtle.sign("Ed25519",e,r);return new Uint8Array(t)}async function zr(e,r,t){return await k(),await crypto.subtle.verify("Ed25519",e,r,t)} | ||
| 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.assertIsBase58EncodedAddress = nr; | ||
| exports.generateKeyPair = pr; | ||
| exports.getBase58EncodedAddressCodec = K; | ||
| exports.getBase58EncodedAddressComparator = ir; | ||
| exports.getBase58EncodedAddressFromPublicKey = xr; | ||
| exports.signBytes = wr; | ||
| exports.verifySignature = zr; | ||
| exports.generateKeyPair = d; | ||
| exports.signBytes = m; | ||
| exports.verifySignature = w; | ||
@@ -20,0 +16,0 @@ return exports; |
@@ -1,5 +0,3 @@ | ||
| export * from './base58'; | ||
| export * from './key-pair'; | ||
| export * from './pubkey'; | ||
| export * from './signatures'; | ||
| //# sourceMappingURL=index.d.ts.map |
| { | ||
| "name": "@solana/keys", | ||
| "version": "2.0.0-experimental.f464b8b", | ||
| "version": "2.0.0-experimental.f5c87d2", | ||
| "description": "Helpers for generating and transforming key material", | ||
@@ -52,9 +52,8 @@ "exports": { | ||
| "dependencies": { | ||
| "@metaplex-foundation/umi-serializers": "^0.8.5" | ||
| "@solana/assertions": "2.0.0-experimental.f5c87d2" | ||
| }, | ||
| "devDependencies": { | ||
| "@solana/eslint-config-solana": "^1.0.2", | ||
| "@swc/core": "^1.3.18", | ||
| "@swc/jest": "^0.2.26", | ||
| "@types/jest": "^29.5.2", | ||
| "@swc/jest": "^0.2.27", | ||
| "@types/jest": "^29.5.3", | ||
| "@typescript-eslint/eslint-plugin": "^6.0.0", | ||
@@ -65,12 +64,9 @@ "@typescript-eslint/parser": "^6.0.0", | ||
| "eslint-plugin-jest": "^27.2.3", | ||
| "eslint-plugin-react-hooks": "^4.6.0", | ||
| "eslint-plugin-sort-keys-fix": "^1.1.2", | ||
| "jest": "^29.6.1", | ||
| "jest-environment-jsdom": "^29.6.0", | ||
| "jest-environment-jsdom": "^29.6.2", | ||
| "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", | ||
| "tsup": "7.2.0", | ||
| "typescript": "^5.1.6", | ||
@@ -77,0 +73,0 @@ "version-from-git": "^1.1.1", |
@@ -21,8 +21,2 @@ [![npm][npm-image]][npm-url] | ||
| ### `Base58EncodedAddress` | ||
| 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. | ||
| Whenever you need to validate an arbitrary string as a base58-encoded address, use the `assertIsBase58EncodedAddress()` function in this package. | ||
| ### `Ed25519Signature` | ||
@@ -36,27 +30,2 @@ | ||
| ### `assertIsBase58EncodedAddress()` | ||
| 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. | ||
| 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 { assertIsBase58EncodedAddress } from '@solana/keys'; | ||
| // 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 | ||
| } | ||
| } | ||
| ``` | ||
| ### `generateKeyPair()` | ||
@@ -72,12 +41,2 @@ | ||
| ### `getBase58EncodedAddressFromPublicKey()` | ||
| Given a public `CryptoKey`, this method will return its associated `Base58EncodedAddress`. | ||
| ```ts | ||
| import { getBase58EncodedAddressFromPublicKey } from '@solana/keys'; | ||
| const address = await getBase58EncodedAddressFromPublicKey(publicKey); | ||
| ``` | ||
| ### `signBytes()` | ||
@@ -84,0 +43,0 @@ |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Improved metrics
- Dev dependency count
- decreased by-16.67%
20
Worsened metrics
- Total package byte prevSize
- decreased by-77.54%
34806
- Number of package files
- decreased by-31.03%
20
- Lines of code
- decreased by-77.49%
282
- Number of lines in readme file
- decreased by-39.81%
62
Dependency changes
+ Added@solana/assertions@2.0.0-experimental.f5c87d2(transitive)
- Removed@metaplex-foundation/umi-options@0.8.9(transitive)
- Removed@metaplex-foundation/umi-public-keys@0.8.9(transitive)
- Removed@metaplex-foundation/umi-serializers@0.8.9(transitive)
- Removed@metaplex-foundation/umi-serializers-core@0.8.9(transitive)
- Removed@metaplex-foundation/umi-serializers-encodings@0.8.9(transitive)
- Removed@metaplex-foundation/umi-serializers-numbers@0.8.9(transitive)