@bitgo/wasm-solana 1.4.0 → 1.4.2

package/dist/cjs/js/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findWithdrawAuthorityProgramAddress = exports.getAssociatedTokenAddress = exports.sysvarRecentBlockhashes = exports.nonceAccountSpace = exports.stakeAccountSpace = exports.stakePoolProgramId = exports.ataProgramId = exports.token2022ProgramId = exports.tokenProgramId = exports.memoProgramId = exports.computeBudgetProgramId = exports.stakeProgramId = exports.systemProgramId = exports.buildFromVersionedData = exports.buildTransaction = exports.parseTransaction = exports.isVersionedTransaction = exports.VersionedTransaction = exports.Transaction = exports.Pubkey = exports.Keypair = exports.builder = exports.parser = exports.transaction = exports.pubkey = exports.keypair = void 0;
+const wasm = __importStar(require("./wasm/wasm_solana.js"));
+// Force webpack to include the WASM module
+void wasm;
+// Namespace exports for explicit imports
+exports.keypair = __importStar(require("./keypair.js"));
+exports.pubkey = __importStar(require("./pubkey.js"));
+exports.transaction = __importStar(require("./transaction.js"));
+exports.parser = __importStar(require("./parser.js"));
+exports.builder = __importStar(require("./builder.js"));
+// Top-level class exports for convenience
+var keypair_js_1 = require("./keypair.js");
+Object.defineProperty(exports, "Keypair", { enumerable: true, get: function () { return keypair_js_1.Keypair; } });
+var pubkey_js_1 = require("./pubkey.js");
+Object.defineProperty(exports, "Pubkey", { enumerable: true, get: function () { return pubkey_js_1.Pubkey; } });
+var transaction_js_1 = require("./transaction.js");
+Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return transaction_js_1.Transaction; } });
+// Versioned transaction support
+var versioned_js_1 = require("./versioned.js");
+Object.defineProperty(exports, "VersionedTransaction", { enumerable: true, get: function () { return versioned_js_1.VersionedTransaction; } });
+Object.defineProperty(exports, "isVersionedTransaction", { enumerable: true, get: function () { return versioned_js_1.isVersionedTransaction; } });
+// Top-level function exports
+var parser_js_1 = require("./parser.js");
+Object.defineProperty(exports, "parseTransaction", { enumerable: true, get: function () { return parser_js_1.parseTransaction; } });
+var builder_js_1 = require("./builder.js");
+Object.defineProperty(exports, "buildTransaction", { enumerable: true, get: function () { return builder_js_1.buildTransaction; } });
+Object.defineProperty(exports, "buildFromVersionedData", { enumerable: true, get: function () { return builder_js_1.buildFromVersionedData; } });
+// Program ID constants (from WASM)
+var wasm_solana_js_1 = require("./wasm/wasm_solana.js");
+Object.defineProperty(exports, "systemProgramId", { enumerable: true, get: function () { return wasm_solana_js_1.system_program_id; } });
+Object.defineProperty(exports, "stakeProgramId", { enumerable: true, get: function () { return wasm_solana_js_1.stake_program_id; } });
+Object.defineProperty(exports, "computeBudgetProgramId", { enumerable: true, get: function () { return wasm_solana_js_1.compute_budget_program_id; } });
+Object.defineProperty(exports, "memoProgramId", { enumerable: true, get: function () { return wasm_solana_js_1.memo_program_id; } });
+Object.defineProperty(exports, "tokenProgramId", { enumerable: true, get: function () { return wasm_solana_js_1.token_program_id; } });
+Object.defineProperty(exports, "token2022ProgramId", { enumerable: true, get: function () { return wasm_solana_js_1.token_2022_program_id; } });
+Object.defineProperty(exports, "ataProgramId", { enumerable: true, get: function () { return wasm_solana_js_1.ata_program_id; } });
+Object.defineProperty(exports, "stakePoolProgramId", { enumerable: true, get: function () { return wasm_solana_js_1.stake_pool_program_id; } });
+Object.defineProperty(exports, "stakeAccountSpace", { enumerable: true, get: function () { return wasm_solana_js_1.stake_account_space; } });
+Object.defineProperty(exports, "nonceAccountSpace", { enumerable: true, get: function () { return wasm_solana_js_1.nonce_account_space; } });
+// Sysvar addresses
+Object.defineProperty(exports, "sysvarRecentBlockhashes", { enumerable: true, get: function () { return wasm_solana_js_1.sysvar_recent_blockhashes; } });
+// PDA derivation functions (eliminates @solana/web3.js dependency)
+Object.defineProperty(exports, "getAssociatedTokenAddress", { enumerable: true, get: function () { return wasm_solana_js_1.get_associated_token_address; } });
+Object.defineProperty(exports, "findWithdrawAuthorityProgramAddress", { enumerable: true, get: function () { return wasm_solana_js_1.find_withdraw_authority_program_address; } });

package/dist/cjs/js/keypair.d.ts

@@ -0,0 +1,47 @@
+import { WasmKeypair } from "./wasm/wasm_solana.js";
+/**
+ * Solana Ed25519 Keypair for address generation and signing
+ *
+ * A keypair consists of a 32-byte secret key and a 32-byte public key.
+ * The public key (base58-encoded) is the Solana address.
+ */
+export declare class Keypair {
+    private _wasm;
+    private constructor();
+    /**
+     * Create a keypair from a 32-byte secret key
+     * @param secretKey - The 32-byte Ed25519 secret key
+     * @returns A Keypair instance
+     */
+    static fromSecretKey(secretKey: Uint8Array): Keypair;
+    /**
+     * Create a keypair from a 64-byte Solana secret key (secret + public concatenated)
+     * This is the format used by @solana/web3.js Keypair.fromSecretKey()
+     * @param secretKey - The 64-byte Solana secret key
+     * @returns A Keypair instance
+     */
+    static fromSolanaSecretKey(secretKey: Uint8Array): Keypair;
+    /**
+     * Get the public key as a 32-byte Uint8Array
+     */
+    get publicKey(): Uint8Array;
+    /**
+     * Get the secret key as a 32-byte Uint8Array
+     */
+    get secretKey(): Uint8Array;
+    /**
+     * Get the Solana address (base58-encoded public key)
+     * @returns The address as a base58 string
+     */
+    getAddress(): string;
+    /**
+     * Get the public key as a base58 string
+     * @returns The public key as a base58 string
+     */
+    toBase58(): string;
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm(): WasmKeypair;
+}

package/dist/cjs/js/keypair.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Keypair = void 0;
+const wasm_solana_js_1 = require("./wasm/wasm_solana.js");
+/**
+ * Solana Ed25519 Keypair for address generation and signing
+ *
+ * A keypair consists of a 32-byte secret key and a 32-byte public key.
+ * The public key (base58-encoded) is the Solana address.
+ */
+class Keypair {
+    _wasm;
+    constructor(_wasm) {
+        this._wasm = _wasm;
+    }
+    /**
+     * Create a keypair from a 32-byte secret key
+     * @param secretKey - The 32-byte Ed25519 secret key
+     * @returns A Keypair instance
+     */
+    static fromSecretKey(secretKey) {
+        const wasm = wasm_solana_js_1.WasmKeypair.from_secret_key(secretKey);
+        return new Keypair(wasm);
+    }
+    /**
+     * Create a keypair from a 64-byte Solana secret key (secret + public concatenated)
+     * This is the format used by @solana/web3.js Keypair.fromSecretKey()
+     * @param secretKey - The 64-byte Solana secret key
+     * @returns A Keypair instance
+     */
+    static fromSolanaSecretKey(secretKey) {
+        const wasm = wasm_solana_js_1.WasmKeypair.from_solana_secret_key(secretKey);
+        return new Keypair(wasm);
+    }
+    /**
+     * Get the public key as a 32-byte Uint8Array
+     */
+    get publicKey() {
+        return this._wasm.public_key;
+    }
+    /**
+     * Get the secret key as a 32-byte Uint8Array
+     */
+    get secretKey() {
+        return this._wasm.secret_key;
+    }
+    /**
+     * Get the Solana address (base58-encoded public key)
+     * @returns The address as a base58 string
+     */
+    getAddress() {
+        return this._wasm.address();
+    }
+    /**
+     * Get the public key as a base58 string
+     * @returns The public key as a base58 string
+     */
+    toBase58() {
+        return this._wasm.to_base58();
+    }
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm() {
+        return this._wasm;
+    }
+}
+exports.Keypair = Keypair;

package/dist/cjs/js/parser.d.ts

@@ -0,0 +1,253 @@
+/**
+ * High-level transaction parsing.
+ *
+ * Provides types and functions for parsing Solana transactions into semantic data
+ * matching BitGoJS's TxData format.
+ *
+ * All monetary amounts (amount, fee, lamports, poolTokens) are returned as bigint.
+ * Accepts both raw bytes and Transaction objects for convenience.
+ */
+import type { Transaction } from "./transaction.js";
+import type { VersionedTransaction } from "./versioned.js";
+/**
+ * Input type for parseTransaction - accepts bytes or Transaction objects.
+ */
+export type TransactionInput = Uint8Array | Transaction | VersionedTransaction;
+/** SOL transfer parameters */
+export interface TransferParams {
+    type: "Transfer";
+    fromAddress: string;
+    toAddress: string;
+    amount: bigint;
+}
+/** Create account parameters */
+export interface CreateAccountParams {
+    type: "CreateAccount";
+    fromAddress: string;
+    newAddress: string;
+    amount: bigint;
+    space: number;
+    owner: string;
+}
+/** Nonce advance parameters */
+export interface NonceAdvanceParams {
+    type: "NonceAdvance";
+    walletNonceAddress: string;
+    authWalletAddress: string;
+}
+/** Create nonce account parameters (combined type) */
+export interface CreateNonceAccountParams {
+    type: "CreateNonceAccount";
+    fromAddress: string;
+    nonceAddress: string;
+    authAddress: string;
+    amount: bigint;
+}
+/** Nonce initialize parameters (intermediate - combined into CreateNonceAccount) */
+export interface NonceInitializeParams {
+    type: "NonceInitialize";
+    nonceAddress: string;
+    authAddress: string;
+}
+/** Stake initialize parameters (intermediate - combined into StakingActivate) */
+export interface StakeInitializeParams {
+    type: "StakeInitialize";
+    stakingAddress: string;
+    staker: string;
+    withdrawer: string;
+}
+/** Staking activate parameters (combined type) */
+export interface StakingActivateParams {
+    type: "StakingActivate";
+    fromAddress: string;
+    stakingAddress: string;
+    amount: bigint;
+    validator: string;
+    stakingType: "NATIVE" | "JITO" | "MARINADE";
+}
+/** Staking deactivate parameters */
+export interface StakingDeactivateParams {
+    type: "StakingDeactivate";
+    stakingAddress: string;
+    fromAddress: string;
+}
+/** Staking withdraw parameters */
+export interface StakingWithdrawParams {
+    type: "StakingWithdraw";
+    fromAddress: string;
+    stakingAddress: string;
+    amount: bigint;
+}
+/** Staking delegate parameters */
+export interface StakingDelegateParams {
+    type: "StakingDelegate";
+    stakingAddress: string;
+    fromAddress: string;
+    validator: string;
+}
+/** Staking authorize parameters */
+export interface StakingAuthorizeParams {
+    type: "StakingAuthorize";
+    stakingAddress: string;
+    oldAuthorizeAddress: string;
+    newAuthorizeAddress: string;
+    authorizeType: "Staker" | "Withdrawer";
+    custodianAddress?: string;
+}
+/** Stake initialize parameters (intermediate type) */
+export interface StakeInitializeParams {
+    type: "StakeInitialize";
+    stakingAddress: string;
+    staker: string;
+    withdrawer: string;
+}
+/** Set compute unit limit parameters */
+export interface SetComputeUnitLimitParams {
+    type: "SetComputeUnitLimit";
+    units: number;
+}
+/** Set priority fee parameters */
+export interface SetPriorityFeeParams {
+    type: "SetPriorityFee";
+    fee: bigint;
+}
+/** Token transfer parameters */
+export interface TokenTransferParams {
+    type: "TokenTransfer";
+    fromAddress: string;
+    toAddress: string;
+    amount: bigint;
+    sourceAddress: string;
+    tokenAddress?: string;
+    programId: string;
+    decimalPlaces?: number;
+}
+/** Create associated token account parameters */
+export interface CreateAtaParams {
+    type: "CreateAssociatedTokenAccount";
+    mintAddress: string;
+    ataAddress: string;
+    ownerAddress: string;
+    payerAddress: string;
+    programId: string;
+}
+/** Close associated token account parameters */
+export interface CloseAtaParams {
+    type: "CloseAssociatedTokenAccount";
+    accountAddress: string;
+    destinationAddress: string;
+    authorityAddress: string;
+}
+/** Memo parameters */
+export interface MemoParams {
+    type: "Memo";
+    memo: string;
+}
+/** Stake pool deposit SOL parameters (Jito liquid staking) */
+export interface StakePoolDepositSolParams {
+    type: "StakePoolDepositSol";
+    stakePool: string;
+    withdrawAuthority: string;
+    reserveStake: string;
+    fundingAccount: string;
+    destinationPoolAccount: string;
+    managerFeeAccount: string;
+    referralPoolAccount: string;
+    poolMint: string;
+    lamports: bigint;
+}
+/** Stake pool withdraw stake parameters (Jito liquid staking) */
+export interface StakePoolWithdrawStakeParams {
+    type: "StakePoolWithdrawStake";
+    stakePool: string;
+    validatorList: string;
+    withdrawAuthority: string;
+    validatorStake: string;
+    destinationStake: string;
+    destinationStakeAuthority: string;
+    sourceTransferAuthority: string;
+    sourcePoolAccount: string;
+    managerFeeAccount: string;
+    poolMint: string;
+    poolTokens: bigint;
+}
+/** Account metadata for unknown instructions */
+export interface AccountMeta {
+    pubkey: string;
+    isSigner: boolean;
+    isWritable: boolean;
+}
+/** Unknown instruction parameters */
+export interface UnknownInstructionParams {
+    type: "Unknown";
+    programId: string;
+    accounts: AccountMeta[];
+    data: string;
+}
+/** Union of all instruction parameter types */
+export type InstructionParams = TransferParams | CreateAccountParams | NonceAdvanceParams | CreateNonceAccountParams | NonceInitializeParams | StakingActivateParams | StakingDeactivateParams | StakingWithdrawParams | StakingDelegateParams | StakingAuthorizeParams | StakeInitializeParams | SetComputeUnitLimitParams | SetPriorityFeeParams | TokenTransferParams | CreateAtaParams | CloseAtaParams | MemoParams | StakePoolDepositSolParams | StakePoolWithdrawStakeParams | UnknownInstructionParams;
+/** Durable nonce information */
+export interface DurableNonce {
+    walletNonceAddress: string;
+    authWalletAddress: string;
+}
+/**
+ * A fully parsed Solana transaction with decoded instructions.
+ *
+ * This structure matches BitGoJS's TxData interface for seamless integration.
+ * All monetary amounts are returned as bigint directly from WASM.
+ */
+export interface ParsedTransaction {
+    /** The fee payer address (base58) */
+    feePayer: string;
+    /** Number of required signatures */
+    numSignatures: number;
+    /** The blockhash or nonce value (base58) */
+    nonce: string;
+    /** If this is a durable nonce transaction, contains the nonce info */
+    durableNonce?: DurableNonce;
+    /** All decoded instructions with semantic types */
+    instructionsData: InstructionParams[];
+    /** All account keys (base58 strings) */
+    accountKeys: string[];
+    /** All signatures (base58 strings). Non-empty signatures indicate signed transaction. */
+    signatures: string[];
+}
+/**
+ * Parse a Solana transaction into structured data.
+ *
+ * This is the main entry point for transaction parsing. It deserializes the
+ * transaction and decodes all instructions into semantic types.
+ *
+ * All monetary amounts (amount, fee, lamports, poolTokens) are returned as bigint
+ * directly from WASM - no post-processing needed.
+ *
+ * Note: This returns the raw parsed data including NonceAdvance instructions.
+ * Consumers (like BitGoJS) may choose to filter NonceAdvance from instructionsData
+ * since that info is also available in durableNonce.
+ *
+ * @param input - Raw transaction bytes, Transaction, or VersionedTransaction
+ * @returns A ParsedTransaction with all instructions decoded
+ * @throws Error if the transaction cannot be parsed
+ *
+ * @example
+ * ```typescript
+ * import { parseTransaction, buildTransaction, Transaction } from '@bitgo/wasm-solana';
+ *
+ * // From bytes
+ * const txBytes = Buffer.from(base64EncodedTx, 'base64');
+ * const parsed = parseTransaction(txBytes);
+ *
+ * // Directly from a Transaction object (no roundtrip through bytes)
+ * const tx = buildTransaction(intent);
+ * const parsed = parseTransaction(tx);
+ *
+ * console.log(parsed.feePayer);
+ * for (const instr of parsed.instructionsData) {
+ *   if (instr.type === 'Transfer') {
+ *     console.log(`Transfer ${instr.amount} from ${instr.fromAddress} to ${instr.toAddress}`);
+ *   }
+ * }
+ * ```
+ */
+export declare function parseTransaction(input: TransactionInput): ParsedTransaction;

package/dist/cjs/js/parser.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * High-level transaction parsing.
+ *
+ * Provides types and functions for parsing Solana transactions into semantic data
+ * matching BitGoJS's TxData format.
+ *
+ * All monetary amounts (amount, fee, lamports, poolTokens) are returned as bigint.
+ * Accepts both raw bytes and Transaction objects for convenience.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTransaction = parseTransaction;
+const wasm_solana_js_1 = require("./wasm/wasm_solana.js");
+// =============================================================================
+// parseTransaction function
+// =============================================================================
+/**
+ * Parse a Solana transaction into structured data.
+ *
+ * This is the main entry point for transaction parsing. It deserializes the
+ * transaction and decodes all instructions into semantic types.
+ *
+ * All monetary amounts (amount, fee, lamports, poolTokens) are returned as bigint
+ * directly from WASM - no post-processing needed.
+ *
+ * Note: This returns the raw parsed data including NonceAdvance instructions.
+ * Consumers (like BitGoJS) may choose to filter NonceAdvance from instructionsData
+ * since that info is also available in durableNonce.
+ *
+ * @param input - Raw transaction bytes, Transaction, or VersionedTransaction
+ * @returns A ParsedTransaction with all instructions decoded
+ * @throws Error if the transaction cannot be parsed
+ *
+ * @example
+ * ```typescript
+ * import { parseTransaction, buildTransaction, Transaction } from '@bitgo/wasm-solana';
+ *
+ * // From bytes
+ * const txBytes = Buffer.from(base64EncodedTx, 'base64');
+ * const parsed = parseTransaction(txBytes);
+ *
+ * // Directly from a Transaction object (no roundtrip through bytes)
+ * const tx = buildTransaction(intent);
+ * const parsed = parseTransaction(tx);
+ *
+ * console.log(parsed.feePayer);
+ * for (const instr of parsed.instructionsData) {
+ *   if (instr.type === 'Transfer') {
+ *     console.log(`Transfer ${instr.amount} from ${instr.fromAddress} to ${instr.toAddress}`);
+ *   }
+ * }
+ * ```
+ */
+function parseTransaction(input) {
+    // If input is a Transaction or VersionedTransaction, extract bytes
+    const bytes = input instanceof Uint8Array ? input : input.toBytes();
+    return wasm_solana_js_1.ParserNamespace.parse_transaction(bytes);
+}

package/dist/cjs/js/pubkey.d.ts

@@ -0,0 +1,54 @@
+import { WasmPubkey } from "./wasm/wasm_solana.js";
+/**
+ * Solana public key (address)
+ *
+ * A Solana address is a 32-byte Ed25519 public key, typically represented as a base58 string.
+ */
+export declare class Pubkey {
+    private _wasm;
+    private constructor();
+    /**
+     * Create a Pubkey from a base58 string
+     * @param address - The base58-encoded address
+     * @returns A Pubkey instance
+     */
+    static fromBase58(address: string): Pubkey;
+    /**
+     * Create a Pubkey from raw bytes (32 bytes)
+     * @param bytes - The 32-byte public key
+     * @returns A Pubkey instance
+     */
+    static fromBytes(bytes: Uint8Array): Pubkey;
+    /**
+     * Convert to base58 string (the standard Solana address format)
+     * @returns The address as a base58 string
+     */
+    toBase58(): string;
+    /**
+     * Get as raw bytes (32 bytes)
+     * @returns The public key as a Uint8Array
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Check if two pubkeys are equal
+     * @param other - The other Pubkey to compare
+     * @returns true if the pubkeys are equal
+     */
+    equals(other: Pubkey): boolean;
+    /**
+     * Check if this public key is on the Ed25519 curve.
+     *
+     * Regular Solana keypair addresses are on the curve, while Program Derived Addresses (PDAs)
+     * are intentionally off the curve to ensure they can only be signed by programs.
+     *
+     * This is equivalent to `@solana/web3.js` `PublicKey.isOnCurve()`.
+     *
+     * @returns true if the public key is on the Ed25519 curve
+     */
+    isOnCurve(): boolean;
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm(): WasmPubkey;
+}

package/dist/cjs/js/pubkey.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pubkey = void 0;
+const wasm_solana_js_1 = require("./wasm/wasm_solana.js");
+/**
+ * Solana public key (address)
+ *
+ * A Solana address is a 32-byte Ed25519 public key, typically represented as a base58 string.
+ */
+class Pubkey {
+    _wasm;
+    constructor(_wasm) {
+        this._wasm = _wasm;
+    }
+    /**
+     * Create a Pubkey from a base58 string
+     * @param address - The base58-encoded address
+     * @returns A Pubkey instance
+     */
+    static fromBase58(address) {
+        const wasm = wasm_solana_js_1.WasmPubkey.from_base58(address);
+        return new Pubkey(wasm);
+    }
+    /**
+     * Create a Pubkey from raw bytes (32 bytes)
+     * @param bytes - The 32-byte public key
+     * @returns A Pubkey instance
+     */
+    static fromBytes(bytes) {
+        const wasm = wasm_solana_js_1.WasmPubkey.from_bytes(bytes);
+        return new Pubkey(wasm);
+    }
+    /**
+     * Convert to base58 string (the standard Solana address format)
+     * @returns The address as a base58 string
+     */
+    toBase58() {
+        return this._wasm.to_base58();
+    }
+    /**
+     * Get as raw bytes (32 bytes)
+     * @returns The public key as a Uint8Array
+     */
+    toBytes() {
+        return this._wasm.to_bytes();
+    }
+    /**
+     * Check if two pubkeys are equal
+     * @param other - The other Pubkey to compare
+     * @returns true if the pubkeys are equal
+     */
+    equals(other) {
+        return this._wasm.equals(other._wasm);
+    }
+    /**
+     * Check if this public key is on the Ed25519 curve.
+     *
+     * Regular Solana keypair addresses are on the curve, while Program Derived Addresses (PDAs)
+     * are intentionally off the curve to ensure they can only be signed by programs.
+     *
+     * This is equivalent to `@solana/web3.js` `PublicKey.isOnCurve()`.
+     *
+     * @returns true if the public key is on the Ed25519 curve
+     */
+    isOnCurve() {
+        return this._wasm.is_on_curve();
+    }
+    /**
+     * Get the underlying WASM instance (internal use only)
+     * @internal
+     */
+    get wasm() {
+        return this._wasm;
+    }
+}
+exports.Pubkey = Pubkey;