@solana/compat 6.3.1 → 6.3.2-canary-20260313112147

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/compat",
-  "version": "6.3.1",
+  "version": "6.3.2-canary-20260313112147",
   "description": "Helpers for converting from legacy web3js classes",
   "homepage": "https://www.solanakit.com/api#solanacompat",
   "exports": {
@@ -33,7 +33,8 @@
   "types": "./dist/types/index.d.ts",
   "type": "commonjs",
   "files": [
-    "./dist/"
+    "./dist/",
+    "./src/"
   ],
   "sideEffects": false,
   "keywords": [
@@ -55,12 +56,12 @@
     "maintained node versions"
   ],
   "dependencies": {
-    "@solana/addresses": "6.3.1",
-    "@solana/codecs-core": "6.3.1",
-    "@solana/errors": "6.3.1",
-    "@solana/instructions": "6.3.1",
-    "@solana/keys": "6.3.1",
-    "@solana/transactions": "6.3.1"
+    "@solana/addresses": "6.3.2-canary-20260313112147",
+    "@solana/codecs-core": "6.3.2-canary-20260313112147",
+    "@solana/errors": "6.3.2-canary-20260313112147",
+    "@solana/keys": "6.3.2-canary-20260313112147",
+    "@solana/instructions": "6.3.2-canary-20260313112147",
+    "@solana/transactions": "6.3.2-canary-20260313112147"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/src/address.ts

@@ -0,0 +1,18 @@
+import { Address } from '@solana/addresses';
+import { PublicKey } from '@solana/web3.js';
+
+/**
+ * Converts a legacy [PublicKey](https://solana-foundation.github.io/solana-web3.js/classes/PublicKey.html)
+ * object to an {@link Address}.
+ *
+ * @example
+ * ```ts
+ * import { fromLegacyPublicKey } from '@solana/compat';
+ *
+ * const legacyPublicKey = new PublicKey('49XBVQsvSW44ULKL9qufS9YqQPbdcps1TQRijx4FQ9sH');
+ * const address = fromLegacyPublicKey(legacyPublicKey);
+ * ```
+ */
+export function fromLegacyPublicKey<TAddress extends string>(publicKey: PublicKey): Address<TAddress> {
+    return publicKey.toBase58() as Address<TAddress>;
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * This package contains utilities for converting from legacy web3.js classes to the data
+ * structures in Kit. 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 './address';
+export * from './instruction';
+export * from './keypair';
+export * from './transaction';

package/src/instruction.ts

@@ -0,0 +1,40 @@
+import { AccountRole, Instruction } from '@solana/instructions';
+import { TransactionInstruction } from '@solana/web3.js';
+
+import { fromLegacyPublicKey } from './address';
+
+/**
+ * This can be used to convert a legacy [`TransactionInstruction`](https://solana-foundation.github.io/solana-web3.js/classes/TransactionInstruction.html)
+ * object to an {@link Instruction}.
+ *
+ * @example
+ * ```ts
+ * import { fromLegacyTransactionInstruction } from '@solana/compat';
+ *
+ * // Imagine a function that returns a legacy `TransactionInstruction`
+ * const legacyInstruction = getMyLegacyInstruction();
+ * const instruction = fromLegacyTransactionInstruction(legacyInstruction);
+ * ```
+ */
+export function fromLegacyTransactionInstruction(legacyInstruction: TransactionInstruction): Instruction {
+    const data = legacyInstruction.data?.byteLength > 0 ? Uint8Array.from(legacyInstruction.data) : undefined;
+    const accounts = legacyInstruction.keys.map(accountMeta =>
+        Object.freeze({
+            address: fromLegacyPublicKey(accountMeta.pubkey),
+            role: determineRole(accountMeta.isSigner, accountMeta.isWritable),
+        }),
+    );
+    const programAddress = fromLegacyPublicKey(legacyInstruction.programId);
+    return Object.freeze({
+        ...(accounts.length ? { accounts: Object.freeze(accounts) } : null),
+        ...(data ? { data } : null),
+        programAddress,
+    });
+}
+
+function determineRole(isSigner: boolean, isWritable: boolean): AccountRole {
+    if (isSigner && isWritable) return AccountRole.WRITABLE_SIGNER;
+    if (isSigner) return AccountRole.READONLY_SIGNER;
+    if (isWritable) return AccountRole.WRITABLE;
+    return AccountRole.READONLY;
+}

package/src/keypair.ts

@@ -0,0 +1,21 @@
+import { createKeyPairFromBytes } from '@solana/keys';
+import { Keypair } from '@solana/web3.js';
+
+/**
+ * Converts a legacy [Keypair](https://solana-foundation.github.io/solana-web3.js/classes/Keypair.html)
+ * object to a native Ed25519 {@link CryptoKeyPair} object.
+ *
+ * @example
+ * ```ts
+ * import { fromLegacyKeypair } from '@solana/compat';
+ *
+ * const legacyKeyPair = Keypair.generate();
+ * const { privateKey, publicKey } = await fromLegacyKeypair(legacyKeyPair);
+ * ```
+ */
+export async function fromLegacyKeypair(keypair: Keypair, extractable?: boolean): Promise<CryptoKeyPair> {
+    const bytes = new Uint8Array(64);
+    bytes.set(keypair.secretKey);
+    bytes.set(keypair.publicKey.toBytes(), /* offset */ 32);
+    return await createKeyPairFromBytes(bytes, extractable);
+}

package/src/transaction.ts

@@ -0,0 +1,54 @@
+import { ReadonlyUint8Array } from '@solana/codecs-core';
+import { SOLANA_ERROR__TRANSACTION__MESSAGE_SIGNATURES_MISMATCH, SolanaError } from '@solana/errors';
+import type { SignatureBytes } from '@solana/keys';
+import { type SignaturesMap, Transaction, TransactionMessageBytes } from '@solana/transactions';
+import type { PublicKey, VersionedTransaction } from '@solana/web3.js';
+
+function convertSignatures(transaction: VersionedTransaction, staticAccountKeys: PublicKey[]): SignaturesMap {
+    return Object.fromEntries(
+        transaction.signatures.map((sig, index) => {
+            const address = staticAccountKeys[index];
+            if (sig.every(b => b === 0)) {
+                // all-0 signatures are stored as null
+                return [address, null];
+            } else {
+                return [address, sig as ReadonlyUint8Array as SignatureBytes];
+            }
+        }),
+    );
+}
+
+/**
+ * This can be used to convert a legacy [VersionedTransaction](https://solana-foundation.github.io/solana-web3.js/classes/VersionedTransaction.html)
+ * object to a {@link Transaction}.
+ *
+ * @example
+ * ```ts
+ * import { fromVersionedTransaction } from '@solana/compat';
+ *
+ * // Imagine a function that returns a legacy `VersionedTransaction`
+ * const legacyVersionedTransaction = getMyLegacyVersionedTransaction();
+ * const transaction = fromVersionedTransaction(legacyVersionedTransaction);
+ * ```
+ */
+export function fromVersionedTransaction(transaction: VersionedTransaction): Transaction {
+    const { message } = transaction;
+    const staticAccountKeys = message.staticAccountKeys;
+
+    const { numRequiredSignatures } = message.header;
+    if (numRequiredSignatures !== transaction.signatures.length) {
+        throw new SolanaError(SOLANA_ERROR__TRANSACTION__MESSAGE_SIGNATURES_MISMATCH, {
+            numRequiredSignatures: transaction.message.header.numRequiredSignatures,
+            signaturesLength: transaction.signatures.length,
+            signerAddresses: staticAccountKeys.slice(0, numRequiredSignatures).map(p => p.toBase58()),
+        });
+    }
+
+    const messageBytes = message.serialize() as ReadonlyUint8Array as TransactionMessageBytes;
+    const signatures = convertSignatures(transaction, staticAccountKeys);
+
+    return {
+        messageBytes,
+        signatures: Object.freeze(signatures),
+    };
+}