@solana/addresses 6.3.1 → 6.3.2-canary-20260313112147

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/addresses",
-  "version": "6.3.1",
+  "version": "6.3.2-canary-20260313112147",
   "description": "Helpers for generating account addresses",
   "homepage": "https://www.solanakit.com/api#solanaaddresses",
   "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/nominal-types": "6.3.1",
-    "@solana/codecs-core": "6.3.1",
-    "@solana/errors": "6.3.1"
+    "@solana/assertions": "6.3.2-canary-20260313112147",
+    "@solana/codecs-core": "6.3.2-canary-20260313112147",
+    "@solana/codecs-strings": "6.3.2-canary-20260313112147",
+    "@solana/errors": "6.3.2-canary-20260313112147",
+    "@solana/nominal-types": "6.3.2-canary-20260313112147"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/src/address.ts

@@ -0,0 +1,220 @@
+import {
+    combineCodec,
+    Decoder,
+    Encoder,
+    fixDecoderSize,
+    FixedSizeCodec,
+    FixedSizeDecoder,
+    FixedSizeEncoder,
+    fixEncoderSize,
+    transformEncoder,
+} from '@solana/codecs-core';
+import { getBase58Decoder, getBase58Encoder } from '@solana/codecs-strings';
+import {
+    SOLANA_ERROR__ADDRESSES__INVALID_BYTE_LENGTH,
+    SOLANA_ERROR__ADDRESSES__STRING_LENGTH_OUT_OF_RANGE,
+    SolanaError,
+} from '@solana/errors';
+import { Brand, EncodedString } from '@solana/nominal-types';
+
+/**
+ * Represents a string that validates as a Solana address. 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
+ * {@link address}, {@link assertIsAddress}, or {@link isAddress} functions in this package.
+ */
+export type Address<TAddress extends string = string> = Brand<EncodedString<TAddress, 'base58'>, 'Address'>;
+
+let memoizedBase58Encoder: Encoder<string> | undefined;
+let memoizedBase58Decoder: Decoder<string> | undefined;
+
+function getMemoizedBase58Encoder(): Encoder<string> {
+    if (!memoizedBase58Encoder) memoizedBase58Encoder = getBase58Encoder();
+    return memoizedBase58Encoder;
+}
+
+function getMemoizedBase58Decoder(): Decoder<string> {
+    if (!memoizedBase58Decoder) memoizedBase58Decoder = getBase58Decoder();
+    return memoizedBase58Decoder;
+}
+
+/**
+ * A type guard that returns `true` if the input string conforms to the {@link Address} type, and
+ * refines its type for use in your program.
+ *
+ * @example
+ * ```ts
+ * import { isAddress } from '@solana/addresses';
+ *
+ * if (isAddress(ownerAddress)) {
+ *     // At this point, `ownerAddress` has been refined to a
+ *     // `Address` that can be used with the RPC.
+ *     const { value: lamports } = await rpc.getBalance(ownerAddress).send();
+ *     setBalanceLamports(lamports);
+ * } else {
+ *     setError(`${ownerAddress} is not an address`);
+ * }
+ * ```
+ */
+export function isAddress(putativeAddress: string): putativeAddress is Address<typeof putativeAddress> {
+    // Fast-path; see if the input string is of an acceptable length.
+    if (
+        // Lowest address (32 bytes of zeroes)
+        putativeAddress.length < 32 ||
+        // Highest address (32 bytes of 255)
+        putativeAddress.length > 44
+    ) {
+        return false;
+    }
+    // Slow-path; actually attempt to decode the input string.
+    const base58Encoder = getMemoizedBase58Encoder();
+    try {
+        return base58Encoder.encode(putativeAddress).byteLength === 32;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * From time to time you might acquire a string, that you expect to validate as an address or public
+ * key, from an untrusted network API or user input. Use this function to assert that such an
+ * arbitrary string is a base58-encoded address.
+ *
+ * @example
+ * ```ts
+ * import { assertIsAddress } from '@solana/addresses';
+ *
+ * // 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 `Address`.
+ *         assertIsAddress(address);
+ *         // At this point, `address` is an `Address` 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
+ *     }
+ * }
+ * ```
+ */
+export function assertIsAddress(putativeAddress: string): asserts putativeAddress is Address<typeof putativeAddress> {
+    // Fast-path; see if the input string is of an acceptable length.
+    if (
+        // Lowest address (32 bytes of zeroes)
+        putativeAddress.length < 32 ||
+        // Highest address (32 bytes of 255)
+        putativeAddress.length > 44
+    ) {
+        throw new SolanaError(SOLANA_ERROR__ADDRESSES__STRING_LENGTH_OUT_OF_RANGE, {
+            actualLength: putativeAddress.length,
+        });
+    }
+    // Slow-path; actually attempt to decode the input string.
+    const base58Encoder = getMemoizedBase58Encoder();
+    const bytes = base58Encoder.encode(putativeAddress);
+    const numBytes = bytes.byteLength;
+    if (numBytes !== 32) {
+        throw new SolanaError(SOLANA_ERROR__ADDRESSES__INVALID_BYTE_LENGTH, {
+            actualLength: numBytes,
+        });
+    }
+}
+
+/**
+ * Combines _asserting_ that a string is an address with _coercing_ it to the {@link Address} type.
+ * It's most useful with untrusted input.
+ *
+ * @example
+ * ```ts
+ * import { address } from '@solana/addresses';
+ *
+ * await transfer(address(fromAddress), address(toAddress), lamports(100000n));
+ * ```
+ *
+ * > [!TIP]
+ * > When starting from a known-good address as a string, it's more efficient to typecast it rather
+ * than to use the {@link address} helper, because the helper unconditionally performs validation on
+ * its input.
+ * >
+ * > ```ts
+ * > import { Address } from '@solana/addresses';
+ * >
+ * > const MEMO_PROGRAM_ADDRESS =
+ * >     'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr' as Address<'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'>;
+ * > ```
+ */
+export function address<TAddress extends string = string>(putativeAddress: TAddress): Address<TAddress> {
+    assertIsAddress(putativeAddress);
+    return putativeAddress as Address<TAddress>;
+}
+
+/**
+ * Returns an encoder that you can use to encode a base58-encoded address to a byte array.
+ *
+ * @example
+ * ```ts
+ * import { getAddressEncoder } from '@solana/addresses';
+ *
+ * const address = 'B9Lf9z5BfNPT4d5KMeaBFx8x1G4CULZYR1jA2kmxRDka' as Address;
+ * const addressEncoder = getAddressEncoder();
+ * const addressBytes = addressEncoder.encode(address);
+ * // Uint8Array(32) [
+ * //   150, 183, 190,  48, 171,   8, 39, 156,
+ * //   122, 213, 172, 108, 193,  95, 26, 158,
+ * //   149, 243, 115, 254,  20, 200, 36,  30,
+ * //   248, 179, 178, 232, 220,  89, 53, 127
+ * // ]
+ * ```
+ */
+export function getAddressEncoder(): FixedSizeEncoder<Address, 32> {
+    return transformEncoder(fixEncoderSize(getMemoizedBase58Encoder(), 32), putativeAddress =>
+        address(putativeAddress),
+    );
+}
+
+/**
+ * Returns a decoder that you can use to convert an array of 32 bytes representing an address to the
+ * base58-encoded representation of that address.
+ *
+ * @example
+ * ```ts
+ * import { getAddressDecoder } from '@solana/addresses';
+ *
+ * const addressBytes = new Uint8Array([
+ *     150, 183, 190,  48, 171,   8, 39, 156,
+ *     122, 213, 172, 108, 193,  95, 26, 158,
+ *     149, 243, 115, 254,  20, 200, 36,  30,
+ *     248, 179, 178, 232, 220,  89, 53, 127
+ * ]);
+ * const addressDecoder = getAddressDecoder();
+ * const address = addressDecoder.decode(addressBytes); // B9Lf9z5BfNPT4d5KMeaBFx8x1G4CULZYR1jA2kmxRDka
+ * ```
+ */
+export function getAddressDecoder(): FixedSizeDecoder<Address, 32> {
+    return fixDecoderSize(getMemoizedBase58Decoder(), 32) as FixedSizeDecoder<Address, 32>;
+}
+
+/**
+ * Returns a codec that you can use to encode from or decode to a base-58 encoded address.
+ *
+ * @see {@link getAddressDecoder}
+ * @see {@link getAddressEncoder}
+ */
+export function getAddressCodec(): FixedSizeCodec<Address, Address, 32> {
+    return combineCodec(getAddressEncoder(), getAddressDecoder());
+}
+
+export function getAddressComparator(): (x: string, y: string) => number {
+    return new Intl.Collator('en', {
+        caseFirst: 'lower',
+        ignorePunctuation: false,
+        localeMatcher: 'best fit',
+        numeric: false,
+        sensitivity: 'variant',
+        usage: 'sort',
+    }).compare;
+}

package/src/curve-internal.ts

@@ -0,0 +1,26 @@
+import { ReadonlyUint8Array } from '@solana/codecs-core';
+
+import { pointIsOnCurve } from './vendor/noble/ed25519';
+
+function byteToHex(byte: number): string {
+    const hexString = byte.toString(16);
+    if (hexString.length === 1) {
+        return `0${hexString}`;
+    } else {
+        return hexString;
+    }
+}
+
+function decompressPointBytes(bytes: ReadonlyUint8Array): bigint {
+    const hexString = bytes.reduce((acc, byte, ii) => `${byteToHex(ii === 31 ? byte & ~0x80 : byte)}${acc}`, '');
+    const integerLiteralString = `0x${hexString}`;
+    return BigInt(integerLiteralString);
+}
+
+export function compressedPointBytesAreOnCurve(bytes: ReadonlyUint8Array): boolean {
+    if (bytes.byteLength !== 32) {
+        return false;
+    }
+    const y = decompressPointBytes(bytes);
+    return pointIsOnCurve(y, bytes[31]);
+}

package/src/curve.ts

@@ -0,0 +1,85 @@
+import { SOLANA_ERROR__ADDRESSES__INVALID_OFF_CURVE_ADDRESS, SolanaError } from '@solana/errors';
+import type { AffinePoint } from '@solana/nominal-types';
+
+import { type Address, getAddressCodec } from './address';
+import { compressedPointBytesAreOnCurve } from './curve-internal';
+
+/**
+ * Represents an {@link Address} that validates as being off-curve. Functions that require off-curve
+ * addresses should specify their inputs in terms of this type.
+ *
+ * Whenever you need to validate an address as being off-curve, use the {@link offCurveAddress},
+ * {@link assertIsOffCurveAddress}, or {@link isOffCurveAddress} functions in this package.
+ */
+export type OffCurveAddress<TAddress extends string = string> = AffinePoint<Address<TAddress>, 'invalid'>;
+
+/**
+ * A type guard that returns `true` if the input address conforms to the {@link OffCurveAddress}
+ * type, and refines its type for use in your application.
+ *
+ * @example
+ * ```ts
+ * import { isOffCurveAddress } from '@solana/addresses';
+ *
+ * if (isOffCurveAddress(accountAddress)) {
+ *     // At this point, `accountAddress` has been refined to a
+ *     // `OffCurveAddress` that can be used within your business logic.
+ *     const { value: account } = await rpc.getAccountInfo(accountAddress).send();
+ * } else {
+ *     setError(`${accountAddress} is not off-curve`);
+ * }
+ * ```
+ */
+export function isOffCurveAddress<TAddress extends Address>(
+    putativeOffCurveAddress: TAddress,
+): putativeOffCurveAddress is OffCurveAddress<TAddress> {
+    const addressBytes = getAddressCodec().encode(putativeOffCurveAddress);
+    return compressedPointBytesAreOnCurve(addressBytes) === false;
+}
+
+/**
+ * From time to time you might acquire an {@link Address}, that you expect to validate as an
+ * off-curve address, from an untrusted source. Use this function to assert that such an address is
+ * off-curve.
+ *
+ * @example
+ * ```ts
+ * import { assertIsOffCurveAddress } from '@solana/addresses';
+ *
+ * // Imagine a function that fetches an account's balance when a user submits a form.
+ * function handleSubmit() {
+ *     // We know only that the input 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 `Address`.
+ *         assertIsAddress(address);
+ *         // If this type assertion function doesn't throw, then
+ *         // Typescript will upcast `address` to `OffCurveAddress`.
+ *         assertIsOffCurveAddress(address);
+ *         // At this point, `address` is an `OffCurveAddress` that can be used with the RPC.
+ *         const balanceInLamports = await rpc.getBalance(address).send();
+ *     } catch (e) {
+ *         // `address` turned out to NOT be a base58-encoded off-curve address
+ *     }
+ * }
+ * ```
+ */
+export function assertIsOffCurveAddress<TAddress extends Address>(
+    putativeOffCurveAddress: TAddress,
+): asserts putativeOffCurveAddress is OffCurveAddress<TAddress> {
+    if (!isOffCurveAddress(putativeOffCurveAddress)) {
+        throw new SolanaError(SOLANA_ERROR__ADDRESSES__INVALID_OFF_CURVE_ADDRESS);
+    }
+}
+
+/**
+ * Combines _asserting_ that an {@link Address} is off-curve with _coercing_ it to the
+ * {@link OffCurveAddress} type. It's most useful with untrusted input.
+ */
+export function offCurveAddress<TAddress extends Address>(
+    putativeOffCurveAddress: TAddress,
+): OffCurveAddress<TAddress> {
+    assertIsOffCurveAddress(putativeOffCurveAddress);
+    return putativeOffCurveAddress;
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * This package contains utilities for generating account addresses. 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 './curve';
+export * from './program-derived-address';
+export * from './public-key';

package/src/program-derived-address.ts

@@ -0,0 +1,223 @@
+import { assertDigestCapabilityIsAvailable } from '@solana/assertions';
+import { bytesEqual, type ReadonlyUint8Array } from '@solana/codecs-core';
+import {
+    isSolanaError,
+    SOLANA_ERROR__ADDRESSES__FAILED_TO_FIND_VIABLE_PDA_BUMP_SEED,
+    SOLANA_ERROR__ADDRESSES__INVALID_SEEDS_POINT_ON_CURVE,
+    SOLANA_ERROR__ADDRESSES__MALFORMED_PDA,
+    SOLANA_ERROR__ADDRESSES__MAX_NUMBER_OF_PDA_SEEDS_EXCEEDED,
+    SOLANA_ERROR__ADDRESSES__MAX_PDA_SEED_LENGTH_EXCEEDED,
+    SOLANA_ERROR__ADDRESSES__PDA_BUMP_SEED_OUT_OF_RANGE,
+    SOLANA_ERROR__ADDRESSES__PDA_ENDS_WITH_PDA_MARKER,
+    SolanaError,
+} from '@solana/errors';
+import { Brand } from '@solana/nominal-types';
+
+import { Address, assertIsAddress, getAddressCodec, isAddress } from './address';
+import { compressedPointBytesAreOnCurve } from './curve-internal';
+
+/**
+ * A tuple representing a program derived address (derived from the address of some program and a
+ * set of seeds) and the associated bump seed used to ensure that the address, as derived, does not
+ * fall on the Ed25519 curve.
+ *
+ * Whenever you need to validate an arbitrary tuple as one that represents a program derived
+ * address, use the {@link assertIsProgramDerivedAddress} or {@link isProgramDerivedAddress}
+ * functions in this package.
+ */
+export type ProgramDerivedAddress<TAddress extends string = string> = Readonly<
+    [Address<TAddress>, ProgramDerivedAddressBump]
+>;
+
+/**
+ * Represents an integer in the range [0,255] used in the derivation of a program derived address to
+ * ensure that it does not fall on the Ed25519 curve.
+ */
+export type ProgramDerivedAddressBump = Brand<number, 'ProgramDerivedAddressBump'>;
+
+/**
+ * A type guard that returns `true` if the input tuple conforms to the {@link ProgramDerivedAddress}
+ * type, and refines its type for use in your program.
+ *
+ * @see The {@link isAddress} function for an example of how to use a type guard.
+ */
+export function isProgramDerivedAddress<TAddress extends string = string>(
+    value: unknown,
+): value is ProgramDerivedAddress<TAddress> {
+    return (
+        Array.isArray(value) &&
+        value.length === 2 &&
+        typeof value[0] === 'string' &&
+        typeof value[1] === 'number' &&
+        value[1] >= 0 &&
+        value[1] <= 255 &&
+        isAddress(value[0])
+    );
+}
+
+/**
+ * In the event that you receive an address/bump-seed tuple from some untrusted source, use this
+ * function to assert that it conforms to the {@link ProgramDerivedAddress} interface.
+ *
+ * @see The {@link assertIsAddress} function for an example of how to use an assertion function.
+ */
+export function assertIsProgramDerivedAddress<TAddress extends string = string>(
+    value: unknown,
+): asserts value is ProgramDerivedAddress<TAddress> {
+    const validFormat =
+        Array.isArray(value) && value.length === 2 && typeof value[0] === 'string' && typeof value[1] === 'number';
+    if (!validFormat) {
+        throw new SolanaError(SOLANA_ERROR__ADDRESSES__MALFORMED_PDA);
+    }
+    if (value[1] < 0 || value[1] > 255) {
+        throw new SolanaError(SOLANA_ERROR__ADDRESSES__PDA_BUMP_SEED_OUT_OF_RANGE, {
+            bump: value[1],
+        });
+    }
+    assertIsAddress(value[0]);
+}
+
+type ProgramDerivedAddressInput = Readonly<{
+    programAddress: Address;
+    seeds: Seed[];
+}>;
+
+type SeedInput = Readonly<{
+    baseAddress: Address;
+    programAddress: Address;
+    seed: Seed;
+}>;
+
+type Seed = ReadonlyUint8Array | string;
+
+const MAX_SEED_LENGTH = 32;
+const MAX_SEEDS = 16;
+const PDA_MARKER_BYTES = [
+    // The string 'ProgramDerivedAddress'
+    80, 114, 111, 103, 114, 97, 109, 68, 101, 114, 105, 118, 101, 100, 65, 100, 100, 114, 101, 115, 115,
+] as const;
+
+async function createProgramDerivedAddress({ programAddress, seeds }: ProgramDerivedAddressInput): Promise<Address> {
+    assertDigestCapabilityIsAvailable();
+    if (seeds.length > MAX_SEEDS) {
+        throw new SolanaError(SOLANA_ERROR__ADDRESSES__MAX_NUMBER_OF_PDA_SEEDS_EXCEEDED, {
+            actual: seeds.length,
+            maxSeeds: MAX_SEEDS,
+        });
+    }
+    let textEncoder: TextEncoder;
+    const seedBytes = seeds.reduce((acc, seed, ii) => {
+        const bytes = typeof seed === 'string' ? (textEncoder ||= new TextEncoder()).encode(seed) : seed;
+        if (bytes.byteLength > MAX_SEED_LENGTH) {
+            throw new SolanaError(SOLANA_ERROR__ADDRESSES__MAX_PDA_SEED_LENGTH_EXCEEDED, {
+                actual: bytes.byteLength,
+                index: ii,
+                maxSeedLength: MAX_SEED_LENGTH,
+            });
+        }
+        acc.push(...bytes);
+        return acc;
+    }, [] as number[]);
+    const base58EncodedAddressCodec = getAddressCodec();
+    const programAddressBytes = base58EncodedAddressCodec.encode(programAddress);
+    const addressBytesBuffer = await crypto.subtle.digest(
+        'SHA-256',
+        new Uint8Array([...seedBytes, ...programAddressBytes, ...PDA_MARKER_BYTES]),
+    );
+    const addressBytes = new Uint8Array(addressBytesBuffer);
+    if (compressedPointBytesAreOnCurve(addressBytes)) {
+        throw new SolanaError(SOLANA_ERROR__ADDRESSES__INVALID_SEEDS_POINT_ON_CURVE);
+    }
+    return base58EncodedAddressCodec.decode(addressBytes);
+}
+
+/**
+ * Given a program's {@link Address} and up to 16 {@link Seed | Seeds}, this method will return the
+ * program derived address (PDA) associated with each.
+ *
+ * @example
+ * ```ts
+ * import { getAddressEncoder, getProgramDerivedAddress } from '@solana/addresses';
+ *
+ * const addressEncoder = getAddressEncoder();
+ * const [pda, bumpSeed] = await getProgramDerivedAddress({
+ *     programAddress: 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL' as Address,
+ *     seeds: [
+ *         // Owner
+ *         addressEncoder.encode('9fYLFVoVqwH37C3dyPi6cpeobfbQ2jtLpN5HgAYDDdkm' as Address),
+ *         // Token program
+ *         addressEncoder.encode('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA' as Address),
+ *         // Mint
+ *         addressEncoder.encode('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' as Address),
+ *     ],
+ * });
+ * ```
+ */
+export async function getProgramDerivedAddress({
+    programAddress,
+    seeds,
+}: ProgramDerivedAddressInput): Promise<ProgramDerivedAddress> {
+    let bumpSeed = 255;
+    while (bumpSeed > 0) {
+        try {
+            const address = await createProgramDerivedAddress({
+                programAddress,
+                seeds: [...seeds, new Uint8Array([bumpSeed])],
+            });
+            return [address, bumpSeed as ProgramDerivedAddressBump];
+        } catch (e) {
+            if (isSolanaError(e, SOLANA_ERROR__ADDRESSES__INVALID_SEEDS_POINT_ON_CURVE)) {
+                bumpSeed--;
+            } else {
+                throw e;
+            }
+        }
+    }
+    throw new SolanaError(SOLANA_ERROR__ADDRESSES__FAILED_TO_FIND_VIABLE_PDA_BUMP_SEED);
+}
+
+/**
+ * Returns a base58-encoded address derived from some base address, some program address, and a seed
+ * string or byte array.
+ *
+ * @example
+ * ```ts
+ * import { createAddressWithSeed } from '@solana/addresses';
+ *
+ * const derivedAddress = await createAddressWithSeed({
+ *     // The private key associated with this address will be able to sign for `derivedAddress`.
+ *     baseAddress: 'B9Lf9z5BfNPT4d5KMeaBFx8x1G4CULZYR1jA2kmxRDka' as Address,
+ *     // Only this program will be able to write data to this account.
+ *     programAddress: '445erYq578p2aERrGW9mn9KiYe3fuG6uHdcJ2LPPShGw' as Address,
+ *     seed: 'data-account',
+ * });
+ * ```
+ */
+export async function createAddressWithSeed({ baseAddress, programAddress, seed }: SeedInput): Promise<Address> {
+    const { encode, decode } = getAddressCodec();
+
+    const seedBytes = typeof seed === 'string' ? new TextEncoder().encode(seed) : seed;
+    if (seedBytes.byteLength > MAX_SEED_LENGTH) {
+        throw new SolanaError(SOLANA_ERROR__ADDRESSES__MAX_PDA_SEED_LENGTH_EXCEEDED, {
+            actual: seedBytes.byteLength,
+            index: 0,
+            maxSeedLength: MAX_SEED_LENGTH,
+        });
+    }
+
+    const programAddressBytes = encode(programAddress);
+    if (
+        programAddressBytes.length >= PDA_MARKER_BYTES.length &&
+        bytesEqual(programAddressBytes.slice(-PDA_MARKER_BYTES.length), new Uint8Array(PDA_MARKER_BYTES))
+    ) {
+        throw new SolanaError(SOLANA_ERROR__ADDRESSES__PDA_ENDS_WITH_PDA_MARKER);
+    }
+
+    const addressBytesBuffer = await crypto.subtle.digest(
+        'SHA-256',
+        new Uint8Array([...encode(baseAddress), ...seedBytes, ...programAddressBytes]),
+    );
+    const addressBytes = new Uint8Array(addressBytesBuffer);
+
+    return decode(addressBytes);
+}

package/src/public-key.ts

@@ -0,0 +1,38 @@
+import { assertKeyExporterIsAvailable } from '@solana/assertions';
+import { SOLANA_ERROR__ADDRESSES__INVALID_ED25519_PUBLIC_KEY, SolanaError } from '@solana/errors';
+
+import { Address, getAddressDecoder, getAddressEncoder } from './address';
+
+/**
+ * Given a public {@link CryptoKey}, this method will return its associated {@link Address}.
+ *
+ * @example
+ * ```ts
+ * import { getAddressFromPublicKey } from '@solana/addresses';
+ *
+ * const address = await getAddressFromPublicKey(publicKey);
+ * ```
+ */
+export async function getAddressFromPublicKey(publicKey: CryptoKey): Promise<Address> {
+    assertKeyExporterIsAvailable();
+    if (publicKey.type !== 'public' || publicKey.algorithm.name !== 'Ed25519') {
+        throw new SolanaError(SOLANA_ERROR__ADDRESSES__INVALID_ED25519_PUBLIC_KEY);
+    }
+    const publicKeyBytes = await crypto.subtle.exportKey('raw', publicKey);
+    return getAddressDecoder().decode(new Uint8Array(publicKeyBytes));
+}
+
+/**
+ * Given an {@link Address}, return a {@link CryptoKey} that can be used to verify signatures.
+ *
+ * @example
+ * ```ts
+ * import { getAddressFromPublicKey } from '@solana/addresses';
+ *
+ * const publicKey = await getPublicKeyFromAddress(address);
+ * ```
+ */
+export async function getPublicKeyFromAddress(address: Address) {
+    const addressBytes = getAddressEncoder().encode(address);
+    return await crypto.subtle.importKey('raw', addressBytes, { name: 'Ed25519' }, true /* extractable */, ['verify']);
+}

package/src/vendor/noble/ed25519.ts

@@ -0,0 +1,94 @@
+/**!
+ * noble-ed25519
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Paul Miller (https://paulmillr.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the “Software”), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+const D = 37095705934669439343138083508754565189542113879843219016388785533085940283555n;
+const P = 57896044618658097711785492504343953926634992332820282019728792003956564819949n; // 2n ** 255n - 19n;  ed25519 is twisted edwards curve
+const RM1 = 19681161376707505956807079304988542015446066515923890162744021073123829784752n; // √-1
+
+// mod division
+function mod(a: bigint): bigint {
+    const r = a % P;
+    return r >= 0n ? r : P + r;
+}
+function pow2(x: bigint, power: bigint): bigint {
+    // pow2(x, 4) == x^(2^4)
+    let r = x;
+    while (power-- > 0n) {
+        r *= r;
+        r %= P;
+    }
+    return r;
+}
+function pow_2_252_3(x: bigint): bigint {
+    // x^(2^252-3) unrolled util for square root
+    const x2 = (x * x) % P; // x^2,       bits 1
+    const b2 = (x2 * x) % P; // x^3,       bits 11
+    const b4 = (pow2(b2, 2n) * b2) % P; // x^(2^4-1), bits 1111
+    const b5 = (pow2(b4, 1n) * x) % P; // x^(2^5-1), bits 11111
+    const b10 = (pow2(b5, 5n) * b5) % P; // x^(2^10)
+    const b20 = (pow2(b10, 10n) * b10) % P; // x^(2^20)
+    const b40 = (pow2(b20, 20n) * b20) % P; // x^(2^40)
+    const b80 = (pow2(b40, 40n) * b40) % P; // x^(2^80)
+    const b160 = (pow2(b80, 80n) * b80) % P; // x^(2^160)
+    const b240 = (pow2(b160, 80n) * b80) % P; // x^(2^240)
+    const b250 = (pow2(b240, 10n) * b10) % P; // x^(2^250)
+    const pow_p_5_8 = (pow2(b250, 2n) * x) % P; // < To pow to (p+3)/8, multiply it by x.
+    return pow_p_5_8;
+}
+function uvRatio(u: bigint, v: bigint): bigint | null {
+    // for sqrt comp
+    const v3 = mod(v * v * v); // v³
+    const v7 = mod(v3 * v3 * v); // v⁷
+    const pow = pow_2_252_3(u * v7); // (uv⁷)^(p-5)/8
+    let x = mod(u * v3 * pow); // (uv³)(uv⁷)^(p-5)/8
+    const vx2 = mod(v * x * x); // vx²
+    const root1 = x; // First root candidate
+    const root2 = mod(x * RM1); // Second root candidate; RM1 is √-1
+    const useRoot1 = vx2 === u; // If vx² = u (mod p), x is a square root
+    const useRoot2 = vx2 === mod(-u); // If vx² = -u, set x <-- x * 2^((p-1)/4)
+    const noRoot = vx2 === mod(-u * RM1); // There is no valid root, vx² = -u√-1
+    if (useRoot1) x = root1;
+    if (useRoot2 || noRoot) x = root2; // We return root2 anyway, for const-time
+    if ((mod(x) & 1n) === 1n) x = mod(-x); // edIsNegative
+    if (!useRoot1 && !useRoot2) {
+        return null;
+    }
+    return x;
+}
+// https://datatracker.ietf.org/doc/html/rfc8032#section-5.1.3
+export function pointIsOnCurve(y: bigint, lastByte: number): boolean {
+    const y2 = mod(y * y); // y²
+    const u = mod(y2 - 1n); // u=y²-1
+    const v = mod(D * y2 + 1n);
+    const x = uvRatio(u, v); // (uv³)(uv⁷)^(p-5)/8; square root
+    if (x === null) {
+        return false;
+    }
+    const isLastByteOdd = (lastByte & 0x80) !== 0; // x_0, last bit
+    if (x === 0n && isLastByteOdd) {
+        return false;
+    }
+    return true;
+}