@lobstercove/lichen-sdk 1.0.0

package/dist/lichenswap.js

@@ -0,0 +1,311 @@
+import { PublicKey } from './publickey.js';
+const PROGRAM_SYMBOL_CANDIDATES = ['LICHENSWAP', 'lichenswap'];
+const MAX_U64 = (1n << 64n) - 1n;
+function normalizeAddress(value) {
+    return value instanceof PublicKey ? value : new PublicKey(value);
+}
+function normalizeUnsignedU64(value, fieldName) {
+    const normalized = typeof value === 'bigint'
+        ? value
+        : Number.isSafeInteger(value) && value >= 0
+            ? BigInt(value)
+            : null;
+    if (normalized === null || normalized < 0n || normalized > MAX_U64) {
+        throw new Error(`${fieldName} must be a u64-safe integer value`);
+    }
+    return normalized;
+}
+function addUnsignedU64(left, right, fieldName) {
+    const sum = normalizeUnsignedU64(left, fieldName) + normalizeUnsignedU64(right, fieldName);
+    if (sum > MAX_U64) {
+        throw new Error(`${fieldName} must be a u64-safe integer value`);
+    }
+    return sum;
+}
+function u32LE(value) {
+    if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+        throw new Error('u32 values must fit within 0 to 4,294,967,295');
+    }
+    const out = new Uint8Array(4);
+    new DataView(out.buffer).setUint32(0, value, true);
+    return out;
+}
+function u64LE(value, fieldName) {
+    const out = new Uint8Array(8);
+    new DataView(out.buffer).setBigUint64(0, normalizeUnsignedU64(value, fieldName), true);
+    return out;
+}
+function buildLayoutArgs(layout, chunks) {
+    const header = Uint8Array.from([0xAB, ...layout]);
+    const total = chunks.reduce((sum, chunk) => sum + chunk.length, header.length);
+    const out = new Uint8Array(total);
+    out.set(header, 0);
+    let offset = header.length;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+function encodeCreatePoolArgs(params) {
+    return buildLayoutArgs([0x20, 0x20], [
+        normalizeAddress(params.tokenA).toBytes(),
+        normalizeAddress(params.tokenB).toBytes(),
+    ]);
+}
+function encodeAddLiquidityArgs(provider, params) {
+    return buildLayoutArgs([0x20, 0x08, 0x08, 0x08], [
+        provider.toBytes(),
+        u64LE(params.amountA, 'amountA'),
+        u64LE(params.amountB, 'amountB'),
+        u64LE(params.minLiquidity ?? 0, 'minLiquidity'),
+    ]);
+}
+function encodeSwapArgs(params, aToB) {
+    return buildLayoutArgs([0x08, 0x08, 0x04], [
+        u64LE(params.amountIn, 'amountIn'),
+        u64LE(params.minAmountOut ?? 0, 'minAmountOut'),
+        u32LE(aToB ? 1 : 0),
+    ]);
+}
+function encodeDirectionalSwapArgs(params) {
+    return buildLayoutArgs([0x08, 0x08], [
+        u64LE(params.amountIn, 'amountIn'),
+        u64LE(params.minAmountOut ?? 0, 'minAmountOut'),
+    ]);
+}
+function encodeDirectionalSwapWithDeadlineArgs(params) {
+    return buildLayoutArgs([0x08, 0x08, 0x08], [
+        u64LE(params.amountIn, 'amountIn'),
+        u64LE(params.minAmountOut ?? 0, 'minAmountOut'),
+        u64LE(params.deadline, 'deadline'),
+    ]);
+}
+function encodeQuoteArgs(amountIn, aToB) {
+    return buildLayoutArgs([0x08, 0x04], [
+        u64LE(amountIn, 'amountIn'),
+        u32LE(aToB ? 1 : 0),
+    ]);
+}
+function encodeLiquidityBalanceArgs(provider) {
+    return buildLayoutArgs([0x20], [provider.toBytes()]);
+}
+function encodeAmountArgs(amount, fieldName) {
+    return buildLayoutArgs([0x08], [u64LE(amount, fieldName)]);
+}
+function decodeReturnData(returnData) {
+    return Uint8Array.from(Buffer.from(returnData, 'base64'));
+}
+function readU64(bytes, offset) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return view.getBigUint64(offset, true);
+}
+function ensureReadonlySuccess(result, functionName, allowedReturnCodes = [0]) {
+    const code = result.returnCode ?? 0;
+    if (!allowedReturnCodes.includes(code)) {
+        throw new Error(result.error ?? `LichenSwap ${functionName} returned code ${code}`);
+    }
+    if (result.success === false && result.error) {
+        throw new Error(result.error);
+    }
+}
+function decodeU64Return(result, functionName) {
+    ensureReadonlySuccess(result, functionName);
+    if (!result.returnData) {
+        throw new Error(`LichenSwap ${functionName} did not return payload data`);
+    }
+    const bytes = decodeReturnData(result.returnData);
+    if (bytes.length < 8) {
+        throw new Error(`LichenSwap ${functionName} payload was shorter than expected`);
+    }
+    return readU64(bytes, 0);
+}
+function decodePoolInfo(result) {
+    ensureReadonlySuccess(result, 'get_pool_info', [0, 1]);
+    if (!result.returnData) {
+        throw new Error('LichenSwap get_pool_info did not return pool data');
+    }
+    const bytes = decodeReturnData(result.returnData);
+    if (bytes.length < 24) {
+        throw new Error('LichenSwap get_pool_info payload was shorter than expected');
+    }
+    return {
+        reserveA: readU64(bytes, 0),
+        reserveB: readU64(bytes, 8),
+        totalLiquidity: readU64(bytes, 16),
+    };
+}
+function decodeVolumeTotals(result, functionName) {
+    ensureReadonlySuccess(result, functionName);
+    if (!result.returnData) {
+        throw new Error(`LichenSwap ${functionName} did not return volume data`);
+    }
+    const bytes = decodeReturnData(result.returnData);
+    if (bytes.length < 16) {
+        throw new Error(`LichenSwap ${functionName} payload was shorter than expected`);
+    }
+    return {
+        volumeA: readU64(bytes, 0),
+        volumeB: readU64(bytes, 8),
+    };
+}
+function decodeProtocolFees(result) {
+    ensureReadonlySuccess(result, 'get_protocol_fees');
+    if (!result.returnData) {
+        throw new Error('LichenSwap get_protocol_fees did not return fee data');
+    }
+    const bytes = decodeReturnData(result.returnData);
+    if (bytes.length < 16) {
+        throw new Error('LichenSwap get_protocol_fees payload was shorter than expected');
+    }
+    return {
+        feesA: readU64(bytes, 0),
+        feesB: readU64(bytes, 8),
+    };
+}
+function decodeTwapCumulatives(result) {
+    ensureReadonlySuccess(result, 'get_twap_cumulatives');
+    if (!result.returnData) {
+        throw new Error('LichenSwap get_twap_cumulatives did not return TWAP data');
+    }
+    const bytes = decodeReturnData(result.returnData);
+    if (bytes.length < 24) {
+        throw new Error('LichenSwap get_twap_cumulatives payload was shorter than expected');
+    }
+    return {
+        cumulativePriceA: readU64(bytes, 0),
+        cumulativePriceB: readU64(bytes, 8),
+        lastUpdatedAt: readU64(bytes, 16),
+    };
+}
+function decodeSwapStats(result) {
+    ensureReadonlySuccess(result, 'get_swap_stats');
+    if (!result.returnData) {
+        throw new Error('LichenSwap get_swap_stats did not return stats data');
+    }
+    const bytes = decodeReturnData(result.returnData);
+    if (bytes.length < 40) {
+        throw new Error('LichenSwap get_swap_stats payload was shorter than expected');
+    }
+    return {
+        swapCount: readU64(bytes, 0),
+        volumeA: readU64(bytes, 8),
+        volumeB: readU64(bytes, 16),
+        poolCount: readU64(bytes, 24),
+        totalLiquidity: readU64(bytes, 32),
+    };
+}
+export class LichenSwapClient {
+    constructor(connection, programId) {
+        this.connection = connection;
+        this.resolvedProgram = programId;
+    }
+    async callReadonly(functionName, args = new Uint8Array()) {
+        const programId = await this.getProgramId();
+        return this.connection.callReadonlyContract(programId, functionName, args);
+    }
+    async getProgramId() {
+        if (this.resolvedProgram) {
+            return this.resolvedProgram;
+        }
+        for (const symbol of PROGRAM_SYMBOL_CANDIDATES) {
+            try {
+                const entry = await this.connection.getSymbolRegistry(symbol);
+                if (entry?.program) {
+                    this.resolvedProgram = new PublicKey(entry.program);
+                    return this.resolvedProgram;
+                }
+            }
+            catch {
+                // Try the next known registry alias.
+            }
+        }
+        throw new Error('Unable to resolve the LichenSwap program via getSymbolRegistry("LICHENSWAP")');
+    }
+    async getPoolInfo() {
+        return decodePoolInfo(await this.callReadonly('get_pool_info'));
+    }
+    async getQuote(amountIn, aToB = true) {
+        return decodeU64Return(await this.callReadonly('get_quote', encodeQuoteArgs(amountIn, aToB)), 'get_quote');
+    }
+    async getLiquidityBalance(provider) {
+        return decodeU64Return(await this.callReadonly('get_liquidity_balance', encodeLiquidityBalanceArgs(normalizeAddress(provider))), 'get_liquidity_balance');
+    }
+    async getTotalLiquidity() {
+        return decodeU64Return(await this.callReadonly('get_total_liquidity'), 'get_total_liquidity');
+    }
+    async getFlashLoanFee(amount) {
+        return decodeU64Return(await this.callReadonly('get_flash_loan_fee', encodeAmountArgs(amount, 'amount')), 'get_flash_loan_fee');
+    }
+    async getTwapCumulatives() {
+        return decodeTwapCumulatives(await this.callReadonly('get_twap_cumulatives'));
+    }
+    async getTwapSnapshotCount() {
+        return decodeU64Return(await this.callReadonly('get_twap_snapshot_count'), 'get_twap_snapshot_count');
+    }
+    async getProtocolFees() {
+        return decodeProtocolFees(await this.callReadonly('get_protocol_fees'));
+    }
+    async getPoolCount() {
+        return decodeU64Return(await this.callReadonly('get_pool_count'), 'get_pool_count');
+    }
+    async getSwapCount() {
+        return decodeU64Return(await this.callReadonly('get_swap_count'), 'get_swap_count');
+    }
+    async getTotalVolume() {
+        return decodeVolumeTotals(await this.callReadonly('get_total_volume'), 'get_total_volume');
+    }
+    async getSwapStats() {
+        return decodeSwapStats(await this.callReadonly('get_swap_stats'));
+    }
+    async getStats() {
+        const stats = await this.connection.getLichenSwapStats();
+        return {
+            swapCount: stats.swap_count ?? 0,
+            volumeA: stats.volume_a ?? 0,
+            volumeB: stats.volume_b ?? 0,
+            paused: Boolean(stats.paused),
+        };
+    }
+    async createPool(owner, params) {
+        const programId = await this.getProgramId();
+        const args = encodeCreatePoolArgs(params);
+        return this.connection.callContract(owner, programId, 'create_pool', args);
+    }
+    async addLiquidity(provider, params) {
+        const programId = await this.getProgramId();
+        const args = encodeAddLiquidityArgs(provider.pubkey(), params);
+        const value = params.valueSpores ?? addUnsignedU64(params.amountA, params.amountB, 'valueSpores');
+        return this.connection.callContract(provider, programId, 'add_liquidity', args, value);
+    }
+    async swap(provider, params, aToB = true) {
+        const programId = await this.getProgramId();
+        const args = encodeSwapArgs(params, aToB);
+        const value = params.valueSpores ?? normalizeUnsignedU64(params.amountIn, 'valueSpores');
+        return this.connection.callContract(provider, programId, 'swap', args, value);
+    }
+    async swapAToB(provider, params) {
+        const programId = await this.getProgramId();
+        const args = encodeDirectionalSwapArgs(params);
+        const value = params.valueSpores ?? normalizeUnsignedU64(params.amountIn, 'valueSpores');
+        return this.connection.callContract(provider, programId, 'swap_a_for_b', args, value);
+    }
+    async swapBToA(provider, params) {
+        const programId = await this.getProgramId();
+        const args = encodeDirectionalSwapArgs(params);
+        const value = params.valueSpores ?? normalizeUnsignedU64(params.amountIn, 'valueSpores');
+        return this.connection.callContract(provider, programId, 'swap_b_for_a', args, value);
+    }
+    async swapAToBWithDeadline(provider, params) {
+        const programId = await this.getProgramId();
+        const args = encodeDirectionalSwapWithDeadlineArgs(params);
+        const value = params.valueSpores ?? normalizeUnsignedU64(params.amountIn, 'valueSpores');
+        return this.connection.callContract(provider, programId, 'swap_a_for_b_with_deadline', args, value);
+    }
+    async swapBToAWithDeadline(provider, params) {
+        const programId = await this.getProgramId();
+        const args = encodeDirectionalSwapWithDeadlineArgs(params);
+        const value = params.valueSpores ?? normalizeUnsignedU64(params.amountIn, 'valueSpores');
+        return this.connection.callContract(provider, programId, 'swap_b_for_a_with_deadline', args, value);
+    }
+}

package/dist/pq.d.ts

@@ -0,0 +1,57 @@
+import { PublicKey } from './publickey.js';
+export declare const PQ_SCHEME_ML_DSA_65 = 1;
+export declare const ML_DSA_65_PUBLIC_KEY_BYTES = 1952;
+export declare const ML_DSA_65_SIGNATURE_BYTES = 3309;
+export interface JsonPqPublicKey {
+    scheme_version: number;
+    bytes: string;
+}
+export interface JsonPqSignature {
+    scheme_version: number;
+    public_key: JsonPqPublicKey;
+    sig: string;
+}
+type BytesLike = Uint8Array | number[];
+type PqPublicKeyInput = {
+    schemeVersion?: number;
+    scheme_version?: number;
+    bytes: string | BytesLike;
+};
+type PqSignatureInput = {
+    schemeVersion?: number;
+    scheme_version?: number;
+    publicKey?: PqPublicKeyInput | PqPublicKey;
+    public_key?: PqPublicKeyInput | PqPublicKey;
+    sig: string | BytesLike;
+};
+export declare function generateMlDsa65Seed(): Uint8Array;
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare class PqPublicKey {
+    readonly schemeVersion: number;
+    private readonly _bytes;
+    constructor(schemeVersion: number, bytes: string | BytesLike);
+    static mlDsa65(bytes: string | BytesLike): PqPublicKey;
+    toBytes(): Uint8Array;
+    address(): PublicKey;
+    equals(other: PqPublicKey): boolean;
+    toJSON(): JsonPqPublicKey;
+    toString(): string;
+    static fromJSON(value: PqPublicKeyInput | PqPublicKey): PqPublicKey;
+}
+export declare class PqSignature {
+    readonly schemeVersion: number;
+    readonly publicKey: PqPublicKey;
+    private readonly _sig;
+    constructor(schemeVersion: number, publicKey: PqPublicKey, sig: string | BytesLike);
+    static mlDsa65(publicKey: PqPublicKey, sig: string | BytesLike): PqSignature;
+    signerAddress(): PublicKey;
+    toBytes(): Uint8Array;
+    verify(message: Uint8Array): boolean;
+    toJSON(): JsonPqSignature;
+    toString(): string;
+    static fromJSON(value: PqSignatureInput | PqSignature): PqSignature;
+}
+export declare function toPqPublicKey(value: PqPublicKeyInput | PqPublicKey): PqPublicKey;
+export declare function toPqSignature(value: string | PqSignatureInput | PqSignature): PqSignature;
+export {};

package/dist/pq.js

@@ -0,0 +1,178 @@
+import { createHash, randomBytes as nodeRandomBytes } from 'crypto';
+import { ml_dsa65 } from '@noble/post-quantum/ml-dsa.js';
+import { PublicKey } from './publickey.js';
+export const PQ_SCHEME_ML_DSA_65 = 0x01;
+export const ML_DSA_65_PUBLIC_KEY_BYTES = 1952;
+export const ML_DSA_65_SIGNATURE_BYTES = 3309;
+function copyBytes(bytes) {
+    return new Uint8Array(bytes);
+}
+function schemePublicKeyLength(schemeVersion) {
+    switch (schemeVersion) {
+        case PQ_SCHEME_ML_DSA_65:
+            return ML_DSA_65_PUBLIC_KEY_BYTES;
+        default:
+            throw new Error(`Unsupported PQ public key scheme: 0x${schemeVersion.toString(16).padStart(2, '0')}`);
+    }
+}
+function schemeSignatureLength(schemeVersion) {
+    switch (schemeVersion) {
+        case PQ_SCHEME_ML_DSA_65:
+            return ML_DSA_65_SIGNATURE_BYTES;
+        default:
+            throw new Error(`Unsupported PQ signature scheme: 0x${schemeVersion.toString(16).padStart(2, '0')}`);
+    }
+}
+function normalizeBytes(value, label) {
+    if (typeof value === 'string') {
+        return hexToBytes(value);
+    }
+    return new Uint8Array(value);
+}
+function sha256(bytes) {
+    return new Uint8Array(createHash('sha256').update(bytes).digest());
+}
+export function generateMlDsa65Seed() {
+    return new Uint8Array(nodeRandomBytes(32));
+}
+export function hexToBytes(hex) {
+    const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
+    if (clean.length % 2 !== 0) {
+        throw new Error('Invalid hex string');
+    }
+    const out = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < out.length; i++) {
+        out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+    }
+    return out;
+}
+export function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+export class PqPublicKey {
+    constructor(schemeVersion, bytes) {
+        this.schemeVersion = schemeVersion;
+        this._bytes = normalizeBytes(bytes, 'public key');
+        const expectedLength = schemePublicKeyLength(this.schemeVersion);
+        if (this._bytes.length !== expectedLength) {
+            throw new Error(`Invalid PQ public key length for scheme 0x${this.schemeVersion.toString(16).padStart(2, '0')}: `
+                + `${this._bytes.length}, expected ${expectedLength}`);
+        }
+    }
+    static mlDsa65(bytes) {
+        return new PqPublicKey(PQ_SCHEME_ML_DSA_65, bytes);
+    }
+    toBytes() {
+        return copyBytes(this._bytes);
+    }
+    address() {
+        const digest = sha256(this._bytes);
+        const address = new Uint8Array(32);
+        address[0] = this.schemeVersion;
+        address.set(digest.subarray(0, 31), 1);
+        return new PublicKey(address);
+    }
+    equals(other) {
+        if (this.schemeVersion !== other.schemeVersion) {
+            return false;
+        }
+        const left = this._bytes;
+        const right = other._bytes;
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let i = 0; i < left.length; i++) {
+            if (left[i] !== right[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    toJSON() {
+        return {
+            scheme_version: this.schemeVersion,
+            bytes: bytesToHex(this._bytes),
+        };
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+    static fromJSON(value) {
+        if (value instanceof PqPublicKey) {
+            return value;
+        }
+        const schemeVersion = value.scheme_version ?? value.schemeVersion;
+        if (schemeVersion === undefined) {
+            throw new Error('PQ public key is missing scheme version');
+        }
+        return new PqPublicKey(schemeVersion, value.bytes);
+    }
+}
+export class PqSignature {
+    constructor(schemeVersion, publicKey, sig) {
+        this.schemeVersion = schemeVersion;
+        this.publicKey = publicKey;
+        this._sig = normalizeBytes(sig, 'signature');
+        if (this.publicKey.schemeVersion !== this.schemeVersion) {
+            throw new Error(`PQ signature/public-key scheme mismatch: 0x${this.schemeVersion.toString(16).padStart(2, '0')} `
+                + `vs 0x${this.publicKey.schemeVersion.toString(16).padStart(2, '0')}`);
+        }
+        const expectedLength = schemeSignatureLength(this.schemeVersion);
+        if (this._sig.length !== expectedLength) {
+            throw new Error(`Invalid PQ signature length for scheme 0x${this.schemeVersion.toString(16).padStart(2, '0')}: `
+                + `${this._sig.length}, expected ${expectedLength}`);
+        }
+    }
+    static mlDsa65(publicKey, sig) {
+        return new PqSignature(PQ_SCHEME_ML_DSA_65, publicKey, sig);
+    }
+    signerAddress() {
+        return this.publicKey.address();
+    }
+    toBytes() {
+        return copyBytes(this._sig);
+    }
+    verify(message) {
+        switch (this.schemeVersion) {
+            case PQ_SCHEME_ML_DSA_65:
+                return ml_dsa65.verify(this._sig, message, this.publicKey.toBytes());
+            default:
+                return false;
+        }
+    }
+    toJSON() {
+        return {
+            scheme_version: this.schemeVersion,
+            public_key: this.publicKey.toJSON(),
+            sig: bytesToHex(this._sig),
+        };
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+    static fromJSON(value) {
+        if (value instanceof PqSignature) {
+            return value;
+        }
+        const schemeVersion = value.scheme_version ?? value.schemeVersion;
+        if (schemeVersion === undefined) {
+            throw new Error('PQ signature is missing scheme version');
+        }
+        const publicKey = value.public_key ?? value.publicKey;
+        if (!publicKey) {
+            throw new Error('PQ signature is missing public key');
+        }
+        return new PqSignature(schemeVersion, PqPublicKey.fromJSON(publicKey), value.sig);
+    }
+}
+export function toPqPublicKey(value) {
+    return PqPublicKey.fromJSON(value);
+}
+export function toPqSignature(value) {
+    if (typeof value === 'string') {
+        return PqSignature.fromJSON(JSON.parse(value));
+    }
+    return PqSignature.fromJSON(value);
+}

package/dist/publickey.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A 32-byte address digest.
+ *
+ * The historical `PublicKey` name is preserved for SDK compatibility, but
+ * native PQ verifying keys live in `PqPublicKey`.
+ */
+export declare class PublicKey {
+    private readonly bytes;
+    constructor(value: string | Uint8Array | number[]);
+    /**
+     * Convert to base58 string
+     */
+    toBase58(): string;
+    /**
+     * Convert to bytes
+     * AUDIT-FIX J-6: Returns a copy to prevent external mutation of internal state
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Convert to string (base58)
+     */
+    toString(): string;
+    /**
+     * Check equality
+     */
+    equals(other: PublicKey): boolean;
+    /**
+     * Create from base58 string
+     */
+    static fromBase58(str: string): PublicKey;
+    /**
+     * Create from bytes
+     */
+    static fromBytes(bytes: Uint8Array): PublicKey;
+}

package/dist/publickey.js

@@ -0,0 +1,71 @@
+// Lichen SDK - PublicKey Utilities
+import bs58 from 'bs58';
+/**
+ * A 32-byte address digest.
+ *
+ * The historical `PublicKey` name is preserved for SDK compatibility, but
+ * native PQ verifying keys live in `PqPublicKey`.
+ */
+export class PublicKey {
+    constructor(value) {
+        if (typeof value === 'string') {
+            // Decode from base58
+            this.bytes = bs58.decode(value);
+        }
+        else if (Array.isArray(value)) {
+            this.bytes = new Uint8Array(value);
+        }
+        else {
+            // AUDIT-FIX J-6: Defensive copy to prevent external mutation
+            this.bytes = new Uint8Array(value);
+        }
+        if (this.bytes.length !== 32) {
+            throw new Error(`Invalid public key length: ${this.bytes.length}, expected 32`);
+        }
+    }
+    /**
+     * Convert to base58 string
+     */
+    toBase58() {
+        return bs58.encode(this.bytes);
+    }
+    /**
+     * Convert to bytes
+     * AUDIT-FIX J-6: Returns a copy to prevent external mutation of internal state
+     */
+    toBytes() {
+        return new Uint8Array(this.bytes);
+    }
+    /**
+     * Convert to string (base58)
+     */
+    toString() {
+        return this.toBase58();
+    }
+    /**
+     * Check equality
+     */
+    equals(other) {
+        if (this.bytes.length !== other.bytes.length) {
+            return false;
+        }
+        for (let i = 0; i < this.bytes.length; i++) {
+            if (this.bytes[i] !== other.bytes[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Create from base58 string
+     */
+    static fromBase58(str) {
+        return new PublicKey(str);
+    }
+    /**
+     * Create from bytes
+     */
+    static fromBytes(bytes) {
+        return new PublicKey(bytes);
+    }
+}