@solana/keys 6.3.1 → 6.3.2-canary-20260313143218

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/keys",
-  "version": "6.3.1",
+  "version": "6.3.2-canary-20260313143218",
   "description": "Helpers for generating and transforming key material",
   "homepage": "https://www.solanakit.com/api#solanakeys",
   "exports": {
@@ -33,7 +33,8 @@
   "types": "./dist/types/index.d.ts",
   "type": "commonjs",
   "files": [
-    "./dist/"
+    "./dist/",
+    "./src/"
   ],
   "sideEffects": false,
   "keywords": [
@@ -55,11 +56,11 @@
     "maintained node versions"
   ],
   "dependencies": {
-    "@solana/assertions": "6.3.1",
-    "@solana/codecs-strings": "6.3.1",
-    "@solana/errors": "6.3.1",
-    "@solana/nominal-types": "6.3.1",
-    "@solana/codecs-core": "6.3.1"
+    "@solana/assertions": "6.3.2-canary-20260313143218",
+    "@solana/codecs-strings": "6.3.2-canary-20260313143218",
+    "@solana/codecs-core": "6.3.2-canary-20260313143218",
+    "@solana/nominal-types": "6.3.2-canary-20260313143218",
+    "@solana/errors": "6.3.2-canary-20260313143218"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/src/algorithm.ts

@@ -0,0 +1,4 @@
+export const ED25519_ALGORITHM_IDENTIFIER =
+    // Resist the temptation to convert this to a simple string; As of version 133.0.3, Firefox
+    // requires the object form of `AlgorithmIdentifier` and will throw a `DOMException` otherwise.
+    Object.freeze({ name: 'Ed25519' });

package/src/index.ts

@@ -0,0 +1,10 @@
+/**
+ * This package contains utilities for validating, generating, and manipulating addresses and key
+ * material. It can be used standalone, but it is also exported as part of Kit
+ * [`@solana/kit`](https://github.com/anza-xyz/kit/tree/main/packages/kit).
+ * @packageDocumentation
+ */
+export * from './key-pair';
+export * from './private-key';
+export * from './public-key';
+export * from './signatures';

package/src/key-pair.ts

@@ -0,0 +1,140 @@
+import { assertKeyGenerationIsAvailable, assertPRNGIsAvailable } from '@solana/assertions';
+import { ReadonlyUint8Array } from '@solana/codecs-core';
+import {
+    SOLANA_ERROR__KEYS__INVALID_KEY_PAIR_BYTE_LENGTH,
+    SOLANA_ERROR__KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY,
+    SolanaError,
+} from '@solana/errors';
+
+import { ED25519_ALGORITHM_IDENTIFIER } from './algorithm';
+import { createPrivateKeyFromBytes } from './private-key';
+import { getPublicKeyFromPrivateKey } from './public-key';
+import { signBytes, verifySignature } from './signatures';
+
+/**
+ * Generates an Ed25519 public/private key pair for use with other methods in this package that
+ * accept [`CryptoKey`](https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey) objects.
+ *
+ * @example
+ * ```ts
+ * import { generateKeyPair } from '@solana/keys';
+ *
+ * const { privateKey, publicKey } = await generateKeyPair();
+ * ```
+ */
+export async function generateKeyPair(): Promise<CryptoKeyPair> {
+    await assertKeyGenerationIsAvailable();
+    const keyPair = await crypto.subtle.generateKey(
+        /* algorithm */ ED25519_ALGORITHM_IDENTIFIER, // 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;
+}
+
+/**
+ * Given a 64-byte `Uint8Array` secret key, creates an Ed25519 public/private key pair for use with
+ * other methods in this package that accept [`CryptoKey`](https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey)
+ * objects.
+ *
+ * @param bytes 64 bytes, the first 32 of which represent the private key and the last 32 of which
+ * represent its associated public key
+ * @param extractable Setting this to `true` makes it possible to extract the bytes of the private
+ * key using the [`crypto.subtle.exportKey()`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/exportKey)
+ * API. Defaults to `false`.
+ *
+ * @example
+ * ```ts
+ * import fs from 'fs';
+ * import { createKeyPairFromBytes } from '@solana/keys';
+ *
+ * // Get bytes from local keypair file.
+ * const keypairFile = fs.readFileSync('~/.config/solana/id.json');
+ * const keypairBytes = new Uint8Array(JSON.parse(keypairFile.toString()));
+ *
+ * // Create a CryptoKeyPair from the bytes.
+ * const { privateKey, publicKey } = await createKeyPairFromBytes(keypairBytes);
+ * ```
+ */
+export async function createKeyPairFromBytes(
+    bytes: ReadonlyUint8Array,
+    extractable: boolean = false,
+): Promise<CryptoKeyPair> {
+    assertPRNGIsAvailable();
+
+    if (bytes.byteLength !== 64) {
+        throw new SolanaError(SOLANA_ERROR__KEYS__INVALID_KEY_PAIR_BYTE_LENGTH, { byteLength: bytes.byteLength });
+    }
+    const [publicKey, privateKey] = await Promise.all([
+        crypto.subtle.importKey('raw', bytes.slice(32), ED25519_ALGORITHM_IDENTIFIER, /* extractable */ true, [
+            'verify',
+        ]),
+        createPrivateKeyFromBytes(bytes.slice(0, 32), extractable),
+    ]);
+
+    // Verify the key pair
+    const randomBytes = new Uint8Array(32);
+    crypto.getRandomValues(randomBytes);
+    const signedData = await signBytes(privateKey, randomBytes);
+    const isValid = await verifySignature(publicKey, signedData, randomBytes);
+    if (!isValid) {
+        throw new SolanaError(SOLANA_ERROR__KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY);
+    }
+
+    return { privateKey, publicKey } as CryptoKeyPair;
+}
+
+/**
+ * Given a private key represented as a 32-byte `Uint8Array`, creates an Ed25519 public/private key
+ * pair for use with other methods in this package that accept [`CryptoKey`](https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey)
+ * objects.
+ *
+ * @param bytes 32 bytes that represent the private key
+ * @param extractable Setting this to `true` makes it possible to extract the bytes of the private
+ * key using the [`crypto.subtle.exportKey()`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/exportKey)
+ * API. Defaults to `false`.
+ *
+ * @example
+ * ```ts
+ * import { createKeyPairFromPrivateKeyBytes } from '@solana/keys';
+ *
+ * const { privateKey, publicKey } = await createKeyPairFromPrivateKeyBytes(new Uint8Array([...]));
+ * ```
+ *
+ * This can be useful when you have a private key but not the corresponding public key or when you
+ * need to derive key pairs from seeds. For instance, the following code snippet derives a key pair
+ * from the hash of a message.
+ *
+ * ```ts
+ * import { getUtf8Encoder } from '@solana/codecs-strings';
+ * import { createKeyPairFromPrivateKeyBytes } from '@solana/keys';
+ *
+ * const message = getUtf8Encoder().encode('Hello, World!');
+ * const seed = new Uint8Array(await crypto.subtle.digest('SHA-256', message));
+ *
+ * const derivedKeypair = await createKeyPairFromPrivateKeyBytes(seed);
+ * ```
+ */
+export async function createKeyPairFromPrivateKeyBytes(
+    bytes: ReadonlyUint8Array,
+    extractable: boolean = false,
+): Promise<CryptoKeyPair> {
+    const privateKeyPromise = createPrivateKeyFromBytes(bytes, extractable);
+
+    // Here we need the private key to be extractable in order to export
+    // it as a public key. Therefore, if the `extractable` parameter
+    // is `false`, we need to create two private keys such that:
+    //   - The extractable one is used to create the public key and
+    //   - The non-extractable one is the one we will return.
+    const [publicKey, privateKey] = await Promise.all([
+        // This nested promise makes things efficient by
+        // creating the public key in parallel with the
+        // second private key creation, if it is needed.
+        (extractable ? privateKeyPromise : createPrivateKeyFromBytes(bytes, true /* extractable */)).then(
+            async privateKey => await getPublicKeyFromPrivateKey(privateKey, true /* extractable */),
+        ),
+        privateKeyPromise,
+    ]);
+
+    return { privateKey, publicKey };
+}

package/src/private-key.ts

@@ -0,0 +1,75 @@
+import { ReadonlyUint8Array } from '@solana/codecs-core';
+import { SOLANA_ERROR__KEYS__INVALID_PRIVATE_KEY_BYTE_LENGTH, SolanaError } from '@solana/errors';
+
+import { ED25519_ALGORITHM_IDENTIFIER } from './algorithm';
+
+function addPkcs8Header(bytes: ReadonlyUint8Array): ReadonlyUint8Array<ArrayBuffer> {
+    // prettier-ignore
+    return new Uint8Array([
+        /**
+         * PKCS#8 header
+         */
+        0x30, // ASN.1 sequence tag
+        0x2e, // Length of sequence (46 more bytes)
+
+            0x02, // ASN.1 integer tag
+            0x01, // Length of integer
+                0x00, // Version number
+
+            0x30, // ASN.1 sequence tag
+            0x05, // Length of sequence
+                0x06, // ASN.1 object identifier tag
+                0x03, // Length of object identifier
+                    // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112
+                        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)
+                        0x65, // thawte(101)
+                    // Ed25519 identifier
+                        0x70, // id-Ed25519(112)
+
+        /**
+         * Private key payload
+         */
+        0x04, // ASN.1 octet string tag
+        0x22, // String length (34 more bytes)
+
+            // Private key bytes as octet string
+            0x04, // ASN.1 octet string tag
+            0x20, // String length (32 bytes)
+
+        ...bytes
+    ]);
+}
+
+/**
+ * Given a private key represented as a 32-byte `Uint8Array`, creates an Ed25519 private key for use
+ * with other methods in this package that accept
+ * [`CryptoKey`](https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey) objects.
+ *
+ * @param bytes 32 bytes that represent the private key
+ * @param extractable Setting this to `true` makes it possible to extract the bytes of the private
+ * key using the [`crypto.subtle.exportKey()`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/exportKey)
+ * API. Defaults to `false`.
+ *
+ * @example
+ * ```ts
+ * import { createPrivateKeyFromBytes } from '@solana/keys';
+ *
+ * const privateKey = await createPrivateKeyFromBytes(new Uint8Array([...]));
+ * const extractablePrivateKey = await createPrivateKeyFromBytes(new Uint8Array([...]), true);
+ * ```
+ */
+export async function createPrivateKeyFromBytes(
+    bytes: ReadonlyUint8Array,
+    extractable: boolean = false,
+): Promise<CryptoKey> {
+    const actualLength = bytes.byteLength;
+    if (actualLength !== 32) {
+        throw new SolanaError(SOLANA_ERROR__KEYS__INVALID_PRIVATE_KEY_BYTE_LENGTH, {
+            actualLength,
+        });
+    }
+    const privateKeyBytesPkcs8 = addPkcs8Header(bytes);
+    return await crypto.subtle.importKey('pkcs8', privateKeyBytesPkcs8, ED25519_ALGORITHM_IDENTIFIER, extractable, [
+        'sign',
+    ]);
+}

package/src/public-key.ts

@@ -0,0 +1,50 @@
+import { assertKeyExporterIsAvailable } from '@solana/assertions';
+import { SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY, SolanaError } from '@solana/errors';
+
+/**
+ * Given an extractable [`CryptoKey`](https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey)
+ * private key, gets the corresponding public key as a
+ * [`CryptoKey`](https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey).
+ *
+ * @param extractable Setting this to `true` makes it possible to extract the bytes of the public
+ * key using the [`crypto.subtle.exportKey()`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/exportKey)
+ * API. Defaults to `false`.
+ *
+ * @example
+ * ```ts
+ * import { createPrivateKeyFromBytes, getPublicKeyFromPrivateKey } from '@solana/keys';
+ *
+ * const privateKey = await createPrivateKeyFromBytes(new Uint8Array([...]), true);
+ *
+ * const publicKey = await getPublicKeyFromPrivateKey(privateKey);
+ * const extractablePublicKey = await getPublicKeyFromPrivateKey(privateKey, true);
+ * ```
+ */
+export async function getPublicKeyFromPrivateKey(
+    privateKey: CryptoKey,
+    extractable: boolean = false,
+): Promise<CryptoKey> {
+    assertKeyExporterIsAvailable();
+
+    if (privateKey.extractable === false) {
+        throw new SolanaError(SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY, { key: privateKey });
+    }
+
+    // Export private key.
+    const jwk = await crypto.subtle.exportKey('jwk', privateKey);
+
+    // Import public key.
+    return await crypto.subtle.importKey(
+        'jwk',
+        {
+            crv /* curve */: 'Ed25519',
+            ext /* extractable */: extractable,
+            key_ops /* key operations */: ['verify'],
+            kty /* key type */: 'OKP' /* octet key pair */,
+            x /* public key x-coordinate */: jwk.x,
+        },
+        'Ed25519',
+        extractable,
+        ['verify'],
+    );
+}

package/src/signatures.ts

@@ -0,0 +1,253 @@
+import { assertSigningCapabilityIsAvailable, assertVerificationCapabilityIsAvailable } from '@solana/assertions';
+import { Encoder, ReadonlyUint8Array, toArrayBuffer } from '@solana/codecs-core';
+import { getBase58Encoder } from '@solana/codecs-strings';
+import {
+    SOLANA_ERROR__KEYS__INVALID_SIGNATURE_BYTE_LENGTH,
+    SOLANA_ERROR__KEYS__SIGNATURE_STRING_LENGTH_OUT_OF_RANGE,
+    SolanaError,
+} from '@solana/errors';
+import { Brand, EncodedString } from '@solana/nominal-types';
+
+import { ED25519_ALGORITHM_IDENTIFIER } from './algorithm';
+
+/**
+ * A 64-byte Ed25519 signature as a base58-encoded string.
+ */
+export type Signature = Brand<EncodedString<string, 'base58'>, 'Signature'>;
+/**
+ * A 64-byte Ed25519 signature.
+ *
+ * Whenever you need to verify that a particular signature is, in fact, the one that would have been
+ * produced by signing some known bytes using the private key associated with some known public key,
+ * use the {@link verifySignature} function in this package.
+ */
+export type SignatureBytes = Brand<Uint8Array, 'SignatureBytes'>;
+
+let base58Encoder: Encoder<string> | undefined;
+
+/**
+ * Asserts that an arbitrary string is a base58-encoded Ed25519 signature.
+ *
+ * Useful when you receive a string from user input or an untrusted network API that you expect to
+ * represent an Ed25519 signature (eg. of a transaction).
+ *
+ * @example
+ * ```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
+ *     }
+ * }
+ * ```
+ */
+export function assertIsSignature(putativeSignature: string): asserts putativeSignature is Signature {
+    if (!base58Encoder) base58Encoder = getBase58Encoder();
+    // Fast-path; see if the input string is of an acceptable length.
+    if (
+        // Lowest value (64 bytes of zeroes)
+        putativeSignature.length < 64 ||
+        // Highest value (64 bytes of 255)
+        putativeSignature.length > 88
+    ) {
+        throw new SolanaError(SOLANA_ERROR__KEYS__SIGNATURE_STRING_LENGTH_OUT_OF_RANGE, {
+            actualLength: putativeSignature.length,
+        });
+    }
+    // Slow-path; actually attempt to decode the input string.
+    const bytes = base58Encoder.encode(putativeSignature);
+    assertIsSignatureBytes(bytes);
+}
+
+/**
+ * Asserts that an arbitrary `ReadonlyUint8Array` is an Ed25519 signature.
+ *
+ * Useful when you receive a `ReadonlyUint8Array` from an external interface (like the browser wallets' `signMessage` API) that you expect to
+ * represent an Ed25519 signature.
+ *
+ * @example
+ * ```ts
+ * import { assertIsSignatureBytes } from '@solana/keys';
+ *
+ * // Imagine a function that verifies a signature.
+ * function verifySignature() {
+ *     // We know only that the input conforms to the `ReadonlyUint8Array` type.
+ *     const signatureBytes: ReadonlyUint8Array = signatureBytesInput;
+ *     try {
+ *         // If this type assertion function doesn't throw, then
+ *         // Typescript will upcast `signatureBytes` to `SignatureBytes`.
+ *         assertIsSignatureBytes(signatureBytes);
+ *         // At this point, `signatureBytes` is a `SignatureBytes` that can be used with `verifySignature`.
+ *         if (!(await verifySignature(publicKey, signatureBytes, data))) {
+ *             throw new Error('The data were *not* signed by the private key associated with `publicKey`');
+ *         }
+ *     } catch (e) {
+ *         // `signatureBytes` turned out not to be a 64-byte Ed25519 signature
+ *     }
+ * }
+ * ```
+ */
+export function assertIsSignatureBytes(
+    putativeSignatureBytes: ReadonlyUint8Array,
+): asserts putativeSignatureBytes is SignatureBytes {
+    const numBytes = putativeSignatureBytes.byteLength;
+    if (numBytes !== 64) {
+        throw new SolanaError(SOLANA_ERROR__KEYS__INVALID_SIGNATURE_BYTE_LENGTH, {
+            actualLength: numBytes,
+        });
+    }
+}
+
+/**
+ * A type guard that accepts a string as input. It will both return `true` if the string conforms to
+ * the {@link Signature} type and will refine the type for use in your program.
+ *
+ * @example
+ * ```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`);
+ * }
+ * ```
+ */
+export function isSignature(putativeSignature: string): putativeSignature is Signature {
+    if (!base58Encoder) base58Encoder = getBase58Encoder();
+
+    // Fast-path; see if the input string is of an acceptable length.
+    if (
+        // Lowest value (64 bytes of zeroes)
+        putativeSignature.length < 64 ||
+        // Highest value (64 bytes of 255)
+        putativeSignature.length > 88
+    ) {
+        return false;
+    }
+    // Slow-path; actually attempt to decode the input string.
+    const bytes = base58Encoder.encode(putativeSignature);
+    return isSignatureBytes(bytes);
+}
+
+/**
+ * A type guard that accepts a `ReadonlyUint8Array` as input. It will both return `true` if the `ReadonlyUint8Array` conforms to
+ * the {@link SignatureBytes} type and will refine the type for use in your program.
+ *
+ * @example
+ * ```ts
+ * import { isSignatureBytes } from '@solana/keys';
+ *
+ * if (isSignatureBytes(signatureBytes)) {
+ *     // At this point, `signatureBytes` has been refined to a
+ *     // `SignatureBytes` that can be used with `verifySignature`.
+ *     if (!(await verifySignature(publicKey, signatureBytes, data))) {
+ *         throw new Error('The data were *not* signed by the private key associated with `publicKey`');
+ *     }
+ * } else {
+ *     setError(`${signatureBytes} is not a 64-byte Ed25519 signature`);
+ * }
+ * ```
+ */
+export function isSignatureBytes(putativeSignatureBytes: ReadonlyUint8Array): putativeSignatureBytes is SignatureBytes {
+    return putativeSignatureBytes.byteLength === 64;
+}
+
+/**
+ * Given a private [`CryptoKey`](https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey) and a
+ * `Uint8Array` of bytes, this method will return the 64-byte Ed25519 signature of that data as a
+ * `Uint8Array`.
+ *
+ * @example
+ * ```ts
+ * import { signBytes } from '@solana/keys';
+ *
+ * const data = new Uint8Array([1, 2, 3]);
+ * const signature = await signBytes(privateKey, data);
+ * ```
+ */
+export async function signBytes(key: CryptoKey, data: ReadonlyUint8Array): Promise<SignatureBytes> {
+    assertSigningCapabilityIsAvailable();
+    const signedData = await crypto.subtle.sign(ED25519_ALGORITHM_IDENTIFIER, key, toArrayBuffer(data));
+    return new Uint8Array(signedData) as SignatureBytes;
+}
+
+/**
+ * This helper combines _asserting_ that a string is an Ed25519 signature with _coercing_ it to the
+ * {@link Signature} type. It's best used with untrusted input.
+ *
+ * @example
+ * ```ts
+ * import { signature } from '@solana/keys';
+ *
+ * const signature = signature(userSuppliedSignature);
+ * const {
+ *     value: [status],
+ * } = await rpc.getSignatureStatuses([signature]).send();
+ * ```
+ */
+export function signature(putativeSignature: string): Signature {
+    assertIsSignature(putativeSignature);
+    return putativeSignature;
+}
+
+/**
+ * This helper combines _asserting_ that a `ReadonlyUint8Array` is an Ed25519 signature with _coercing_ it to the
+ * {@link SignatureBytes} type. It's best used with untrusted input.
+ *
+ * @example
+ * ```ts
+ * import { signatureBytes } from '@solana/keys';
+ *
+ * const signature = signatureBytes(userSuppliedSignatureBytes);
+ * if (!(await verifySignature(publicKey, signature, data))) {
+ *     throw new Error('The data were *not* signed by the private key associated with `publicKey`');
+ * }
+ * ```
+ */
+export function signatureBytes(putativeSignatureBytes: ReadonlyUint8Array): SignatureBytes {
+    assertIsSignatureBytes(putativeSignatureBytes);
+    return putativeSignatureBytes;
+}
+
+/**
+ * Given a public [`CryptoKey`](https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey), some
+ * {@link 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.
+ *
+ * @example
+ * ```ts
+ * import { verifySignature } from '@solana/keys';
+ *
+ * const data = new Uint8Array([1, 2, 3]);
+ * if (!(await verifySignature(publicKey, signature, data))) {
+ *     throw new Error('The data were *not* signed by the private key associated with `publicKey`');
+ * }
+ * ```
+ */
+export async function verifySignature(
+    key: CryptoKey,
+    signature: SignatureBytes,
+    data: ReadonlyUint8Array,
+): Promise<boolean> {
+    assertVerificationCapabilityIsAvailable();
+    return await crypto.subtle.verify(ED25519_ALGORITHM_IDENTIFIER, key, toArrayBuffer(signature), toArrayBuffer(data));
+}