@dimcool/sdk 0.1.1 → 0.1.6

package/dist/index.js

@@ -11854,655 +11854,6 @@ var NodeStorage = class {
 // src/version.ts
 var SDK_VERSION = "1.0.0";
 
-// src/http-client.ts
-var HttpClient = class {
-  constructor(baseUrl, storage, logger2, appId) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.storage = storage;
-    this.logger = logger2 || logger;
-    this.appId = appId;
-  }
-  async request(endpoint, options = {}) {
-    const url2 = `${this.baseUrl}${endpoint}`;
-    const token = this.storage.get(TOKEN_KEY);
-    this.logger.debug("HTTP request", {
-      method: options.method || "GET",
-      endpoint,
-      url: url2,
-      hasToken: !!token
-    });
-    const headers = {
-      "Content-Type": "application/json",
-      "X-SDK-Version": SDK_VERSION,
-      ...options.headers
-    };
-    if (this.appId) {
-      headers["X-App-Id"] = this.appId;
-    }
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    const response = await fetch(url2, {
-      ...options,
-      headers
-    });
-    this.logger.debug("HTTP response", {
-      method: options.method || "GET",
-      endpoint,
-      status: response.status,
-      ok: response.ok
-    });
-    if (!response.ok) {
-      if (response.status === 426) {
-        let upgradeMessage = "SDK version outdated. Run: npm install @dimcool/sdk@latest";
-        try {
-          const errorData = await response.json();
-          if (typeof errorData.message === "string") {
-            upgradeMessage = errorData.message;
-          }
-        } catch {
-        }
-        this.logger.error("SDK upgrade required", {
-          endpoint,
-          sdkVersion: SDK_VERSION,
-          message: upgradeMessage
-        });
-        const error2 = new Error(upgradeMessage);
-        error2.code = "SDK_UPGRADE_REQUIRED";
-        error2.statusCode = 426;
-        throw error2;
-      }
-      if (response.status === 401) {
-        this.logger.warn("Unauthorized response, clearing token", { endpoint });
-        this.storage.delete(TOKEN_KEY);
-        throw new Error("Unauthorized - please login again");
-      }
-      let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-      let errorCode;
-      try {
-        const errorData = await response.json();
-        errorCode = errorData.code;
-        if (typeof errorData.message === "string" && errorData.message.trim()) {
-          errorMessage = errorData.message;
-        } else if (Array.isArray(errorData.message) && errorData.message.length) {
-          errorMessage = errorData.message.join(", ");
-        } else if (typeof errorData.error === "string" && errorData.error.trim()) {
-          errorMessage = errorData.error;
-        }
-      } catch {
-      }
-      this.logger.error("HTTP request failed", {
-        endpoint,
-        status: response.status,
-        error: errorMessage,
-        code: errorCode
-      });
-      const error = new Error(errorMessage);
-      error.code = errorCode;
-      error.statusCode = response.status;
-      throw error;
-    }
-    const contentType = response.headers.get("content-type");
-    if (contentType && contentType.includes("application/json")) {
-      const data = await response.json();
-      this.logger.debug("HTTP response parsed", { endpoint, hasData: !!data });
-      return data;
-    }
-    this.logger.debug("HTTP response empty", { endpoint });
-    return {};
-  }
-  get(endpoint, options) {
-    return this.request(endpoint, { ...options, method: "GET" });
-  }
-  post(endpoint, data, options) {
-    return this.request(endpoint, {
-      ...options,
-      method: "POST",
-      body: data ? JSON.stringify(data) : void 0
-    });
-  }
-  patch(endpoint, data, options) {
-    return this.request(endpoint, {
-      ...options,
-      method: "PATCH",
-      body: data ? JSON.stringify(data) : void 0
-    });
-  }
-  delete(endpoint, options) {
-    return this.request(endpoint, { ...options, method: "DELETE" });
-  }
-  async upload(endpoint, formData) {
-    const url2 = `${this.baseUrl}${endpoint}`;
-    const token = this.storage.get(TOKEN_KEY);
-    this.logger.debug("HTTP upload request", {
-      method: "POST",
-      endpoint,
-      url: url2,
-      hasToken: !!token
-    });
-    const headers = {
-      "X-SDK-Version": SDK_VERSION
-    };
-    if (this.appId) {
-      headers["X-App-Id"] = this.appId;
-    }
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    const response = await fetch(url2, {
-      method: "POST",
-      headers,
-      body: formData
-    });
-    this.logger.debug("HTTP upload response", {
-      method: "POST",
-      endpoint,
-      status: response.status,
-      ok: response.ok
-    });
-    if (!response.ok) {
-      if (response.status === 426) {
-        let upgradeMessage = "SDK version outdated. Run: npm install @dimcool/sdk@latest";
-        try {
-          const errorData = await response.json();
-          if (typeof errorData.message === "string") {
-            upgradeMessage = errorData.message;
-          }
-        } catch {
-        }
-        this.logger.error("SDK upgrade required", {
-          endpoint,
-          sdkVersion: SDK_VERSION,
-          message: upgradeMessage
-        });
-        const error = new Error(upgradeMessage);
-        error.code = "SDK_UPGRADE_REQUIRED";
-        error.statusCode = 426;
-        throw error;
-      }
-      if (response.status === 401) {
-        this.logger.warn("Unauthorized response, clearing token", { endpoint });
-        this.storage.delete(TOKEN_KEY);
-        throw new Error("Unauthorized - please login again");
-      }
-      let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-      try {
-        const errorData = await response.json();
-        errorMessage = errorData.error || errorMessage;
-      } catch {
-      }
-      this.logger.error("HTTP upload failed", {
-        endpoint,
-        status: response.status,
-        error: errorMessage
-      });
-      throw new Error(errorMessage);
-    }
-    const contentType = response.headers.get("content-type");
-    if (contentType && contentType.includes("application/json")) {
-      const data = await response.json();
-      this.logger.debug("HTTP upload response parsed", {
-        endpoint,
-        hasData: !!data
-      });
-      return data;
-    }
-    this.logger.debug("HTTP upload response empty", { endpoint });
-    return {};
-  }
-};
-
-// src/auth.ts
-function toBase64(bytes) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(bytes).toString("base64");
-  }
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  if (typeof btoa === "undefined") {
-    throw new Error("Base64 encoding is not available in this environment");
-  }
-  return btoa(binary);
-}
-var Auth = class {
-  constructor(http2, storage, wallet, logger2) {
-    this.http = http2;
-    this.storage = storage;
-    this.wallet = wallet;
-    this.logger = logger2 || logger;
-  }
-  async login(email, password) {
-    this.logger.debug("Auth.login called", { email });
-    const response = await this.http.post("/auth/login", {
-      email,
-      password
-    });
-    this.logger.debug("Login response received", {
-      userId: response.user.id,
-      hasToken: !!response.access_token,
-      tokenLength: response.access_token?.length
-    });
-    if (!response.access_token) {
-      throw new Error("Login response missing access_token");
-    }
-    this.storage.set(TOKEN_KEY, response.access_token);
-    const storedToken = this.storage.get(TOKEN_KEY);
-    if (!storedToken || storedToken !== response.access_token) {
-      throw new Error(
-        `Token storage failed! Expected: ${response.access_token.substring(0, 20)}..., Got: ${storedToken?.substring(0, 20)}...`
-      );
-    }
-    this.logger.debug("Token stored in storage", {
-      tokenKey: TOKEN_KEY,
-      stored: !!storedToken,
-      storedTokenLength: storedToken?.length,
-      storageType: this.storage.constructor.name
-    });
-    return response;
-  }
-  async generateHandshake(walletAddress) {
-    this.logger.debug("Auth.generateHandshake called", { walletAddress });
-    const response = await this.http.post(
-      "/auth/handshake",
-      {
-        walletAddress
-      }
-    );
-    this.logger.debug("Handshake generated", {
-      hasMessage: !!response.message,
-      hasNonce: !!response.nonce
-    });
-    return response;
-  }
-  async loginWithWallet(options) {
-    const address = this.wallet.getSignerAddress();
-    if (!address) {
-      throw new Error(
-        "Wallet signer address is required for wallet login. Set sdk.wallet.setSigner({ address, signMessage, signTransaction })."
-      );
-    }
-    if (!this.wallet.hasSigner()) {
-      throw new Error(
-        "No signer configured. Call sdk.wallet.setSigner(...) before wallet login."
-      );
-    }
-    const { message } = await this.generateHandshake(address);
-    const signatureResult = await this.wallet.signMessage(message);
-    const signedMessage = typeof signatureResult === "string" ? signatureResult : toBase64(signatureResult);
-    this.logger.debug("Auth.loginWithWallet called", {
-      address,
-      walletMeta: options?.walletMeta
-    });
-    const response = await this.http.post("/auth/login-wallet", {
-      signedMessage,
-      address,
-      referralCode: options?.referralCode,
-      walletMeta: options?.walletMeta
-    });
-    this.logger.debug("Wallet login response received", {
-      userId: response.user.id,
-      hasToken: !!response.access_token
-    });
-    this.storage.set(TOKEN_KEY, response.access_token);
-    this.logger.debug("Token stored in storage", { tokenKey: TOKEN_KEY });
-    return response;
-  }
-  logout() {
-    this.logger.debug("Auth.logout called");
-    const hadToken = this.storage.get(TOKEN_KEY) !== null;
-    this.storage.delete(TOKEN_KEY);
-    this.logger.debug("Token removed from storage", { hadToken });
-  }
-  isAuthenticated() {
-    const isAuth = this.storage.get(TOKEN_KEY) !== null;
-    this.logger.debug("Auth.isAuthenticated called", {
-      isAuthenticated: isAuth
-    });
-    return isAuth;
-  }
-  async getLatestSessions(limit) {
-    this.logger.debug("Auth.getLatestSessions called", { limit });
-    const params = new URLSearchParams();
-    if (limit !== void 0) {
-      params.append("limit", limit.toString());
-    }
-    const queryString = params.toString();
-    const endpoint = queryString ? `/auth/sessions?${queryString}` : "/auth/sessions";
-    const response = await this.http.get(endpoint);
-    this.logger.debug("Latest sessions retrieved", { total: response.total });
-    return response;
-  }
-};
-
-// src/admin.ts
-var Admin = class {
-  constructor(http2, logger2) {
-    this.http = http2;
-    this.logger = logger2;
-  }
-  async getUserById(id) {
-    return this.http.get(`/admin/users/${id}`);
-  }
-  async getStats() {
-    return this.http.get("/admin/stats");
-  }
-  // Backward-compatible alias used in some consumers.
-  async getAdminStats() {
-    return this.getStats();
-  }
-  async getDailyStats(days) {
-    const params = new URLSearchParams();
-    if (days != null) params.append("days", String(days));
-    const queryString = params.toString();
-    const endpoint = queryString ? `/admin/stats/daily?${queryString}` : "/admin/stats/daily";
-    return this.http.get(endpoint);
-  }
-  // Backward-compatible alias used in some consumers.
-  async getAdminDailyStats(days) {
-    return this.getDailyStats(days);
-  }
-  async getEscrowSweepPreview() {
-    return this.http.post("/admin/escrow/sweep-preview");
-  }
-  async getEscrowSweeps(limit = 20) {
-    return this.http.get(
-      `/admin/escrow/sweeps?limit=${limit}`
-    );
-  }
-  async executeEscrowSweep(amountUsdcMinor, idempotencyKey) {
-    return this.http.post("/admin/escrow/sweep", {
-      amountUsdcMinor,
-      idempotencyKey
-    });
-  }
-  async banUser(userId, reason) {
-    return this.http.post(`/admin/users/${userId}/ban`, { reason });
-  }
-  async unbanUser(userId) {
-    return this.http.post(`/admin/users/${userId}/unban`, {});
-  }
-  async getCriticalIncidentSummary(hours = 24) {
-    return this.http.get(
-      `/admin/critical-incidents/summary?hours=${hours}`
-    );
-  }
-  async getCriticalIncidents(input) {
-    const params = new URLSearchParams();
-    if (input.page != null) params.append("page", String(input.page));
-    if (input.limit != null) params.append("limit", String(input.limit));
-    if (input.status) params.append("status", input.status);
-    if (input.severity) params.append("severity", input.severity);
-    if (input.category) params.append("category", input.category);
-    const query = params.toString();
-    return this.http.get(
-      `/admin/critical-incidents${query ? `?${query}` : ""}`
-    );
-  }
-  async resolveCriticalIncident(id, resolutionNote) {
-    return this.http.patch(
-      `/admin/critical-incidents/${id}/resolve`,
-      { resolutionNote }
-    );
-  }
-};
-
-// src/users.ts
-var Users = class {
-  constructor(http2, logger2) {
-    this.http = http2;
-    this.logger = logger2;
-  }
-  async getUsers(page, limit, username, address) {
-    const params = new URLSearchParams();
-    if (page !== void 0) params.append("page", page.toString());
-    if (limit !== void 0) params.append("limit", limit.toString());
-    if (username !== void 0) params.append("username", username);
-    if (address !== void 0) params.append("address", address);
-    const queryString = params.toString();
-    const endpoint = queryString ? `/users?${queryString}` : "/users";
-    return this.http.get(endpoint);
-  }
-  async getUserById(id) {
-    return this.http.get(`/users/${id}`);
-  }
-  async isUsernameAvailable(username) {
-    const params = new URLSearchParams();
-    params.append("username", username);
-    return this.http.get(
-      `/users/username/availability?${params.toString()}`
-    );
-  }
-  async updateUsername(username) {
-    return this.http.patch("/users/me/username", { username });
-  }
-  async getPublicUserByUsername(username) {
-    return this.http.get(`/users/username/${username}`);
-  }
-  /**
-   * Get a public user profile by ID.
-   * Returns PublicUser with optional spectatorCount.
-   */
-  async getPublicUserById(userId) {
-    return this.http.get(`/users/${userId}`);
-  }
-  async searchUsers(username, page, limit) {
-    const params = new URLSearchParams();
-    params.append("username", username);
-    if (page !== void 0) params.append("page", page.toString());
-    if (limit !== void 0) params.append("limit", limit.toString());
-    return this.http.get(
-      `/users/search?${params.toString()}`
-    );
-  }
-  async getFriends(userId, page, limit, search) {
-    const params = new URLSearchParams();
-    if (page !== void 0) params.append("page", page.toString());
-    if (limit !== void 0) params.append("limit", limit.toString());
-    if (search !== void 0) params.append("search", search);
-    const queryString = params.toString();
-    const endpoint = queryString ? `/friends/${userId}?${queryString}` : `/friends/${userId}`;
-    return this.http.get(endpoint);
-  }
-  async addFriend(userId) {
-    return this.http.post(`/friends/${userId}`, {});
-  }
-  async removeFriend(userId) {
-    return this.http.delete(`/friends/${userId}`);
-  }
-  async getIncomingFriendRequests() {
-    return this.http.get("/friends/requests/incoming");
-  }
-  async getOutgoingFriendRequests() {
-    return this.http.get("/friends/requests/outgoing");
-  }
-  async acceptFriendRequest(userId) {
-    return this.http.post(
-      `/friends/requests/${userId}/accept`,
-      {}
-    );
-  }
-  async declineFriendRequest(userId) {
-    return this.http.post(
-      `/friends/requests/${userId}/decline`,
-      {}
-    );
-  }
-  async cancelFriendRequest(userId) {
-    return this.http.delete(`/friends/requests/${userId}`);
-  }
-  async updateProfile(data) {
-    return this.http.patch("/users/me/profile", data);
-  }
-  async uploadAvatar(file) {
-    const formData = new FormData();
-    formData.append("file", file);
-    return this.http.upload("/users/me/profile/avatar", formData);
-  }
-  async uploadCoverImage(file) {
-    const formData = new FormData();
-    formData.append("file", file);
-    return this.http.upload("/users/me/profile/cover", formData);
-  }
-  async removeAvatar() {
-    return this.http.delete("/users/me/profile/avatar");
-  }
-  async removeCoverImage() {
-    return this.http.delete("/users/me/profile/cover");
-  }
-  // Admin file management methods
-  async getAllFiles() {
-    return this.http.get("/files");
-  }
-  async deleteFile(fileId) {
-    return this.http.delete(`/files/${fileId}`);
-  }
-  async getGameHistory(userId) {
-    return this.http.get(`/users/${userId}/game-history`);
-  }
-  /**
-   * Get user activity for spectate flow. Returns in_game (with gameId, gameType), in_lobby (with lobbyId, lobbyStatus), or idle.
-   */
-  async getUserActivity(userId) {
-    return this.http.get(`/users/${userId}/activity`, {
-      cache: "no-store"
-    });
-  }
-  /**
-   * Get the current active game for a user (if they are a player in one).
-   * Returns null if the user is not in an active game.
-   */
-  async getCurrentGame(userId) {
-    return this.http.get(`/users/${userId}/current-game`, {
-      cache: "no-store"
-    });
-  }
-  async getUserStats(userId) {
-    return this.http.get(`/users/${userId}/stats`);
-  }
-};
-
-// src/feature-flags.ts
-var FeatureFlags = class {
-  constructor(http2, logger2) {
-    this.http = http2;
-    this.logger = logger2;
-    this.flags = [];
-    this.loaded = false;
-  }
-  async getFeatureFlags() {
-    this.flags = await this.http.get("/feature-flags");
-    this.loaded = true;
-    return this.flags;
-  }
-  isEnabledFlag(name) {
-    const flag = this.flags.find((f) => f.name === name);
-    return flag?.enabled ?? false;
-  }
-  isLoaded() {
-    return this.loaded;
-  }
-  async updateFeatureFlag(name, enabled) {
-    const flag = await this.http.patch(`/feature-flags/${name}`, {
-      enabled
-    });
-    const index = this.flags.findIndex((f) => f.name === name);
-    if (index >= 0) {
-      this.flags[index] = flag;
-    } else {
-      this.flags.push(flag);
-    }
-    return flag;
-  }
-  async createFeatureFlag(name, enabled) {
-    const flag = await this.http.post("/feature-flags", {
-      name,
-      enabled
-    });
-    this.flags.push(flag);
-    return flag;
-  }
-};
-
-// src/lobbies.ts
-var Lobbies = class {
-  constructor(http2, logger2) {
-    this.http = http2;
-    this.logger = logger2;
-  }
-  async createLobby(gameType, betAmount) {
-    return this.http.post("/lobbies", { gameType, betAmount });
-  }
-  async getLobby(lobbyId) {
-    return this.http.get(`/lobbies/${lobbyId}`);
-  }
-  async inviteFriend(lobbyId, friendId) {
-    return this.http.post(`/lobbies/${lobbyId}/invite`, {
-      friendId
-    });
-  }
-  async acceptInvite(lobbyId) {
-    return this.http.post(`/lobbies/${lobbyId}/accept-invite`, {});
-  }
-  async joinLobby(lobbyId) {
-    return this.http.post(`/lobbies/${lobbyId}/join`, {});
-  }
-  async removePlayer(lobbyId, userId) {
-    return this.http.delete(
-      `/lobbies/${lobbyId}/players/${userId}`
-    );
-  }
-  async kickPlayer(lobbyId, userId) {
-    return this.removePlayer(lobbyId, userId);
-  }
-  async leaveLobby(lobbyId) {
-    return this.http.delete(`/lobbies/${lobbyId}`);
-  }
-  async joinQueue(lobbyId) {
-    return this.http.post(`/lobbies/${lobbyId}/join-queue`, {});
-  }
-  async cancelQueue(lobbyId) {
-    return this.http.delete(`/lobbies/${lobbyId}/queue`);
-  }
-  async updateBetAmount(lobbyId, betAmount) {
-    return this.http.patch(`/lobbies/${lobbyId}/bet-amount`, {
-      betAmount
-    });
-  }
-  async playSound(lobbyId, sound) {
-    return this.http.post(`/lobbies/${lobbyId}/sound`, {
-      sound
-    });
-  }
-  // Admin methods
-  async getActiveLobbies() {
-    return this.http.get("/lobbies/admin/active");
-  }
-  async getQueueStats() {
-    return this.http.get("/lobbies/admin/queues");
-  }
-  async deleteLobby(lobbyId) {
-    return this.http.delete(`/lobbies/admin/${lobbyId}`);
-  }
-  /**
-   * Play again: Create a new lobby, start deposits, and prepare deposit transaction
-   * Returns the lobby and unsigned transaction that needs to be signed
-   * @param gameType - The game type to play again
-   * @param betAmount - The bet amount (same as previous game)
-   * @param escrow - The escrow service instance (from sdk.escrow)
-   */
-  async playAgain(gameType, betAmount, escrow) {
-    const lobby = await this.createLobby(gameType, betAmount);
-    await escrow.startDeposits(lobby.id);
-    const prepareResponse = await escrow.prepareDepositTransaction(lobby.id);
-    return {
-      lobby,
-      unsignedTransaction: prepareResponse.transaction
-    };
-  }
-};
-
 // ../../node_modules/@solana/web3.js/lib/index.esm.js
 import { Buffer as Buffer2 } from "buffer";
 
@@ -21072,626 +20423,1086 @@ var LogsNotificationResult = type({
   result: notificationResultAndContext(LogsResult),
   subscription: number()
 });
-var Keypair = class _Keypair {
+var Keypair = class _Keypair {
+  /**
+   * Create a new keypair instance.
+   * Generate random keypair if no {@link Ed25519Keypair} is provided.
+   *
+   * @param {Ed25519Keypair} keypair ed25519 keypair
+   */
+  constructor(keypair) {
+    this._keypair = void 0;
+    this._keypair = keypair ?? generateKeypair();
+  }
+  /**
+   * Generate a new random keypair
+   *
+   * @returns {Keypair} Keypair
+   */
+  static generate() {
+    return new _Keypair(generateKeypair());
+  }
+  /**
+   * Create a keypair from a raw secret key byte array.
+   *
+   * This method should only be used to recreate a keypair from a previously
+   * generated secret key. Generating keypairs from a random seed should be done
+   * with the {@link Keypair.fromSeed} method.
+   *
+   * @throws error if the provided secret key is invalid and validation is not skipped.
+   *
+   * @param secretKey secret key byte array
+   * @param options skip secret key validation
+   *
+   * @returns {Keypair} Keypair
+   */
+  static fromSecretKey(secretKey, options) {
+    if (secretKey.byteLength !== 64) {
+      throw new Error("bad secret key size");
+    }
+    const publicKey2 = secretKey.slice(32, 64);
+    if (!options || !options.skipValidation) {
+      const privateScalar = secretKey.slice(0, 32);
+      const computedPublicKey = getPublicKey(privateScalar);
+      for (let ii = 0; ii < 32; ii++) {
+        if (publicKey2[ii] !== computedPublicKey[ii]) {
+          throw new Error("provided secretKey is invalid");
+        }
+      }
+    }
+    return new _Keypair({
+      publicKey: publicKey2,
+      secretKey
+    });
+  }
+  /**
+   * Generate a keypair from a 32 byte seed.
+   *
+   * @param seed seed byte array
+   *
+   * @returns {Keypair} Keypair
+   */
+  static fromSeed(seed) {
+    const publicKey2 = getPublicKey(seed);
+    const secretKey = new Uint8Array(64);
+    secretKey.set(seed);
+    secretKey.set(publicKey2, 32);
+    return new _Keypair({
+      publicKey: publicKey2,
+      secretKey
+    });
+  }
+  /**
+   * The public key for this keypair
+   *
+   * @returns {PublicKey} PublicKey
+   */
+  get publicKey() {
+    return new PublicKey(this._keypair.publicKey);
+  }
+  /**
+   * The raw secret key for this keypair
+   * @returns {Uint8Array} Secret key in an array of Uint8 bytes
+   */
+  get secretKey() {
+    return new Uint8Array(this._keypair.secretKey);
+  }
+};
+var LOOKUP_TABLE_INSTRUCTION_LAYOUTS = Object.freeze({
+  CreateLookupTable: {
+    index: 0,
+    layout: BufferLayout.struct([BufferLayout.u32("instruction"), u64("recentSlot"), BufferLayout.u8("bumpSeed")])
+  },
+  FreezeLookupTable: {
+    index: 1,
+    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
+  },
+  ExtendLookupTable: {
+    index: 2,
+    layout: BufferLayout.struct([BufferLayout.u32("instruction"), u64(), BufferLayout.seq(publicKey(), BufferLayout.offset(BufferLayout.u32(), -8), "addresses")])
+  },
+  DeactivateLookupTable: {
+    index: 3,
+    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
+  },
+  CloseLookupTable: {
+    index: 4,
+    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
+  }
+});
+var AddressLookupTableProgram = class {
+  /**
+   * @internal
+   */
+  constructor() {
+  }
+  static createLookupTable(params) {
+    const [lookupTableAddress, bumpSeed] = PublicKey.findProgramAddressSync([params.authority.toBuffer(), getU64Encoder().encode(params.recentSlot)], this.programId);
+    const type2 = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CreateLookupTable;
+    const data = encodeData(type2, {
+      recentSlot: BigInt(params.recentSlot),
+      bumpSeed
+    });
+    const keys = [{
+      pubkey: lookupTableAddress,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: params.authority,
+      isSigner: true,
+      isWritable: false
+    }, {
+      pubkey: params.payer,
+      isSigner: true,
+      isWritable: true
+    }, {
+      pubkey: SystemProgram.programId,
+      isSigner: false,
+      isWritable: false
+    }];
+    return [new TransactionInstruction({
+      programId: this.programId,
+      keys,
+      data
+    }), lookupTableAddress];
+  }
+  static freezeLookupTable(params) {
+    const type2 = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.FreezeLookupTable;
+    const data = encodeData(type2);
+    const keys = [{
+      pubkey: params.lookupTable,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: params.authority,
+      isSigner: true,
+      isWritable: false
+    }];
+    return new TransactionInstruction({
+      programId: this.programId,
+      keys,
+      data
+    });
+  }
+  static extendLookupTable(params) {
+    const type2 = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.ExtendLookupTable;
+    const data = encodeData(type2, {
+      addresses: params.addresses.map((addr) => addr.toBytes())
+    });
+    const keys = [{
+      pubkey: params.lookupTable,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: params.authority,
+      isSigner: true,
+      isWritable: false
+    }];
+    if (params.payer) {
+      keys.push({
+        pubkey: params.payer,
+        isSigner: true,
+        isWritable: true
+      }, {
+        pubkey: SystemProgram.programId,
+        isSigner: false,
+        isWritable: false
+      });
+    }
+    return new TransactionInstruction({
+      programId: this.programId,
+      keys,
+      data
+    });
+  }
+  static deactivateLookupTable(params) {
+    const type2 = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.DeactivateLookupTable;
+    const data = encodeData(type2);
+    const keys = [{
+      pubkey: params.lookupTable,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: params.authority,
+      isSigner: true,
+      isWritable: false
+    }];
+    return new TransactionInstruction({
+      programId: this.programId,
+      keys,
+      data
+    });
+  }
+  static closeLookupTable(params) {
+    const type2 = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CloseLookupTable;
+    const data = encodeData(type2);
+    const keys = [{
+      pubkey: params.lookupTable,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: params.authority,
+      isSigner: true,
+      isWritable: false
+    }, {
+      pubkey: params.recipient,
+      isSigner: false,
+      isWritable: true
+    }];
+    return new TransactionInstruction({
+      programId: this.programId,
+      keys,
+      data
+    });
+  }
+};
+AddressLookupTableProgram.programId = new PublicKey("AddressLookupTab1e1111111111111111111111111");
+var COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze({
+  RequestUnits: {
+    index: 0,
+    layout: BufferLayout.struct([BufferLayout.u8("instruction"), BufferLayout.u32("units"), BufferLayout.u32("additionalFee")])
+  },
+  RequestHeapFrame: {
+    index: 1,
+    layout: BufferLayout.struct([BufferLayout.u8("instruction"), BufferLayout.u32("bytes")])
+  },
+  SetComputeUnitLimit: {
+    index: 2,
+    layout: BufferLayout.struct([BufferLayout.u8("instruction"), BufferLayout.u32("units")])
+  },
+  SetComputeUnitPrice: {
+    index: 3,
+    layout: BufferLayout.struct([BufferLayout.u8("instruction"), u64("microLamports")])
+  }
+});
+var ComputeBudgetProgram = class {
   /**
-   * Create a new keypair instance.
-   * Generate random keypair if no {@link Ed25519Keypair} is provided.
-   *
-   * @param {Ed25519Keypair} keypair ed25519 keypair
+   * @internal
    */
-  constructor(keypair) {
-    this._keypair = void 0;
-    this._keypair = keypair ?? generateKeypair();
+  constructor() {
   }
   /**
-   * Generate a new random keypair
-   *
-   * @returns {Keypair} Keypair
+   * Public key that identifies the Compute Budget program
    */
-  static generate() {
-    return new _Keypair(generateKeypair());
+  /**
+   * @deprecated Instead, call {@link setComputeUnitLimit} and/or {@link setComputeUnitPrice}
+   */
+  static requestUnits(params) {
+    const type2 = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits;
+    const data = encodeData(type2, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data
+    });
+  }
+  static requestHeapFrame(params) {
+    const type2 = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame;
+    const data = encodeData(type2, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data
+    });
+  }
+  static setComputeUnitLimit(params) {
+    const type2 = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit;
+    const data = encodeData(type2, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data
+    });
+  }
+  static setComputeUnitPrice(params) {
+    const type2 = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice;
+    const data = encodeData(type2, {
+      microLamports: BigInt(params.microLamports)
+    });
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data
+    });
   }
+};
+ComputeBudgetProgram.programId = new PublicKey("ComputeBudget111111111111111111111111111111");
+var PRIVATE_KEY_BYTES$1 = 64;
+var PUBLIC_KEY_BYTES$1 = 32;
+var SIGNATURE_BYTES = 64;
+var ED25519_INSTRUCTION_LAYOUT = BufferLayout.struct([BufferLayout.u8("numSignatures"), BufferLayout.u8("padding"), BufferLayout.u16("signatureOffset"), BufferLayout.u16("signatureInstructionIndex"), BufferLayout.u16("publicKeyOffset"), BufferLayout.u16("publicKeyInstructionIndex"), BufferLayout.u16("messageDataOffset"), BufferLayout.u16("messageDataSize"), BufferLayout.u16("messageInstructionIndex")]);
+var Ed25519Program = class _Ed25519Program {
   /**
-   * Create a keypair from a raw secret key byte array.
-   *
-   * This method should only be used to recreate a keypair from a previously
-   * generated secret key. Generating keypairs from a random seed should be done
-   * with the {@link Keypair.fromSeed} method.
-   *
-   * @throws error if the provided secret key is invalid and validation is not skipped.
-   *
-   * @param secretKey secret key byte array
-   * @param options skip secret key validation
-   *
-   * @returns {Keypair} Keypair
+   * @internal
    */
-  static fromSecretKey(secretKey, options) {
-    if (secretKey.byteLength !== 64) {
-      throw new Error("bad secret key size");
+  constructor() {
+  }
+  /**
+   * Public key that identifies the ed25519 program
+   */
+  /**
+   * Create an ed25519 instruction with a public key and signature. The
+   * public key must be a buffer that is 32 bytes long, and the signature
+   * must be a buffer of 64 bytes.
+   */
+  static createInstructionWithPublicKey(params) {
+    const {
+      publicKey: publicKey2,
+      message,
+      signature,
+      instructionIndex
+    } = params;
+    assert2(publicKey2.length === PUBLIC_KEY_BYTES$1, `Public Key must be ${PUBLIC_KEY_BYTES$1} bytes but received ${publicKey2.length} bytes`);
+    assert2(signature.length === SIGNATURE_BYTES, `Signature must be ${SIGNATURE_BYTES} bytes but received ${signature.length} bytes`);
+    const publicKeyOffset = ED25519_INSTRUCTION_LAYOUT.span;
+    const signatureOffset = publicKeyOffset + publicKey2.length;
+    const messageDataOffset = signatureOffset + signature.length;
+    const numSignatures = 1;
+    const instructionData = Buffer2.alloc(messageDataOffset + message.length);
+    const index = instructionIndex == null ? 65535 : instructionIndex;
+    ED25519_INSTRUCTION_LAYOUT.encode({
+      numSignatures,
+      padding: 0,
+      signatureOffset,
+      signatureInstructionIndex: index,
+      publicKeyOffset,
+      publicKeyInstructionIndex: index,
+      messageDataOffset,
+      messageDataSize: message.length,
+      messageInstructionIndex: index
+    }, instructionData);
+    instructionData.fill(publicKey2, publicKeyOffset);
+    instructionData.fill(signature, signatureOffset);
+    instructionData.fill(message, messageDataOffset);
+    return new TransactionInstruction({
+      keys: [],
+      programId: _Ed25519Program.programId,
+      data: instructionData
+    });
+  }
+  /**
+   * Create an ed25519 instruction with a private key. The private key
+   * must be a buffer that is 64 bytes long.
+   */
+  static createInstructionWithPrivateKey(params) {
+    const {
+      privateKey,
+      message,
+      instructionIndex
+    } = params;
+    assert2(privateKey.length === PRIVATE_KEY_BYTES$1, `Private key must be ${PRIVATE_KEY_BYTES$1} bytes but received ${privateKey.length} bytes`);
+    try {
+      const keypair = Keypair.fromSecretKey(privateKey);
+      const publicKey2 = keypair.publicKey.toBytes();
+      const signature = sign(message, keypair.secretKey);
+      return this.createInstructionWithPublicKey({
+        publicKey: publicKey2,
+        message,
+        signature,
+        instructionIndex
+      });
+    } catch (error) {
+      throw new Error(`Error creating instruction; ${error}`);
     }
-    const publicKey2 = secretKey.slice(32, 64);
-    if (!options || !options.skipValidation) {
-      const privateScalar = secretKey.slice(0, 32);
-      const computedPublicKey = getPublicKey(privateScalar);
-      for (let ii = 0; ii < 32; ii++) {
-        if (publicKey2[ii] !== computedPublicKey[ii]) {
-          throw new Error("provided secretKey is invalid");
-        }
-      }
+  }
+};
+Ed25519Program.programId = new PublicKey("Ed25519SigVerify111111111111111111111111111");
+var ecdsaSign = (msgHash, privKey) => {
+  const signature = secp256k1.sign(msgHash, privKey);
+  return [signature.toCompactRawBytes(), signature.recovery];
+};
+secp256k1.utils.isValidPrivateKey;
+var publicKeyCreate = secp256k1.getPublicKey;
+var PRIVATE_KEY_BYTES = 32;
+var ETHEREUM_ADDRESS_BYTES = 20;
+var PUBLIC_KEY_BYTES = 64;
+var SIGNATURE_OFFSETS_SERIALIZED_SIZE = 11;
+var SECP256K1_INSTRUCTION_LAYOUT = BufferLayout.struct([BufferLayout.u8("numSignatures"), BufferLayout.u16("signatureOffset"), BufferLayout.u8("signatureInstructionIndex"), BufferLayout.u16("ethAddressOffset"), BufferLayout.u8("ethAddressInstructionIndex"), BufferLayout.u16("messageDataOffset"), BufferLayout.u16("messageDataSize"), BufferLayout.u8("messageInstructionIndex"), BufferLayout.blob(20, "ethAddress"), BufferLayout.blob(64, "signature"), BufferLayout.u8("recoveryId")]);
+var Secp256k1Program = class _Secp256k1Program {
+  /**
+   * @internal
+   */
+  constructor() {
+  }
+  /**
+   * Public key that identifies the secp256k1 program
+   */
+  /**
+   * Construct an Ethereum address from a secp256k1 public key buffer.
+   * @param {Buffer} publicKey a 64 byte secp256k1 public key buffer
+   */
+  static publicKeyToEthAddress(publicKey2) {
+    assert2(publicKey2.length === PUBLIC_KEY_BYTES, `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey2.length} bytes`);
+    try {
+      return Buffer2.from(keccak_256(toBuffer(publicKey2))).slice(-ETHEREUM_ADDRESS_BYTES);
+    } catch (error) {
+      throw new Error(`Error constructing Ethereum address: ${error}`);
     }
-    return new _Keypair({
+  }
+  /**
+   * Create an secp256k1 instruction with a public key. The public key
+   * must be a buffer that is 64 bytes long.
+   */
+  static createInstructionWithPublicKey(params) {
+    const {
       publicKey: publicKey2,
-      secretKey
+      message,
+      signature,
+      recoveryId,
+      instructionIndex
+    } = params;
+    return _Secp256k1Program.createInstructionWithEthAddress({
+      ethAddress: _Secp256k1Program.publicKeyToEthAddress(publicKey2),
+      message,
+      signature,
+      recoveryId,
+      instructionIndex
+    });
+  }
+  /**
+   * Create an secp256k1 instruction with an Ethereum address. The address
+   * must be a hex string or a buffer that is 20 bytes long.
+   */
+  static createInstructionWithEthAddress(params) {
+    const {
+      ethAddress: rawAddress,
+      message,
+      signature,
+      recoveryId,
+      instructionIndex = 0
+    } = params;
+    let ethAddress;
+    if (typeof rawAddress === "string") {
+      if (rawAddress.startsWith("0x")) {
+        ethAddress = Buffer2.from(rawAddress.substr(2), "hex");
+      } else {
+        ethAddress = Buffer2.from(rawAddress, "hex");
+      }
+    } else {
+      ethAddress = rawAddress;
+    }
+    assert2(ethAddress.length === ETHEREUM_ADDRESS_BYTES, `Address must be ${ETHEREUM_ADDRESS_BYTES} bytes but received ${ethAddress.length} bytes`);
+    const dataStart = 1 + SIGNATURE_OFFSETS_SERIALIZED_SIZE;
+    const ethAddressOffset = dataStart;
+    const signatureOffset = dataStart + ethAddress.length;
+    const messageDataOffset = signatureOffset + signature.length + 1;
+    const numSignatures = 1;
+    const instructionData = Buffer2.alloc(SECP256K1_INSTRUCTION_LAYOUT.span + message.length);
+    SECP256K1_INSTRUCTION_LAYOUT.encode({
+      numSignatures,
+      signatureOffset,
+      signatureInstructionIndex: instructionIndex,
+      ethAddressOffset,
+      ethAddressInstructionIndex: instructionIndex,
+      messageDataOffset,
+      messageDataSize: message.length,
+      messageInstructionIndex: instructionIndex,
+      signature: toBuffer(signature),
+      ethAddress: toBuffer(ethAddress),
+      recoveryId
+    }, instructionData);
+    instructionData.fill(toBuffer(message), SECP256K1_INSTRUCTION_LAYOUT.span);
+    return new TransactionInstruction({
+      keys: [],
+      programId: _Secp256k1Program.programId,
+      data: instructionData
     });
   }
   /**
-   * Generate a keypair from a 32 byte seed.
-   *
-   * @param seed seed byte array
-   *
-   * @returns {Keypair} Keypair
+   * Create an secp256k1 instruction with a private key. The private key
+   * must be a buffer that is 32 bytes long.
    */
-  static fromSeed(seed) {
-    const publicKey2 = getPublicKey(seed);
-    const secretKey = new Uint8Array(64);
-    secretKey.set(seed);
-    secretKey.set(publicKey2, 32);
-    return new _Keypair({
-      publicKey: publicKey2,
-      secretKey
-    });
+  static createInstructionWithPrivateKey(params) {
+    const {
+      privateKey: pkey,
+      message,
+      instructionIndex
+    } = params;
+    assert2(pkey.length === PRIVATE_KEY_BYTES, `Private key must be ${PRIVATE_KEY_BYTES} bytes but received ${pkey.length} bytes`);
+    try {
+      const privateKey = toBuffer(pkey);
+      const publicKey2 = publicKeyCreate(
+        privateKey,
+        false
+        /* isCompressed */
+      ).slice(1);
+      const messageHash = Buffer2.from(keccak_256(toBuffer(message)));
+      const [signature, recoveryId] = ecdsaSign(messageHash, privateKey);
+      return this.createInstructionWithPublicKey({
+        publicKey: publicKey2,
+        message,
+        signature,
+        recoveryId,
+        instructionIndex
+      });
+    } catch (error) {
+      throw new Error(`Error creating instruction; ${error}`);
+    }
   }
+};
+Secp256k1Program.programId = new PublicKey("KeccakSecp256k11111111111111111111111111111");
+var _Lockup;
+var STAKE_CONFIG_ID = new PublicKey("StakeConfig11111111111111111111111111111111");
+var Lockup = class {
   /**
-   * The public key for this keypair
-   *
-   * @returns {PublicKey} PublicKey
+   * Create a new Lockup object
    */
-  get publicKey() {
-    return new PublicKey(this._keypair.publicKey);
+  constructor(unixTimestamp, epoch, custodian) {
+    this.unixTimestamp = void 0;
+    this.epoch = void 0;
+    this.custodian = void 0;
+    this.unixTimestamp = unixTimestamp;
+    this.epoch = epoch;
+    this.custodian = custodian;
   }
   /**
-   * The raw secret key for this keypair
-   * @returns {Uint8Array} Secret key in an array of Uint8 bytes
+   * Default, inactive Lockup value
    */
-  get secretKey() {
-    return new Uint8Array(this._keypair.secretKey);
-  }
 };
-var LOOKUP_TABLE_INSTRUCTION_LAYOUTS = Object.freeze({
-  CreateLookupTable: {
+_Lockup = Lockup;
+Lockup.default = new _Lockup(0, 0, PublicKey.default);
+var STAKE_INSTRUCTION_LAYOUTS = Object.freeze({
+  Initialize: {
     index: 0,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction"), u64("recentSlot"), BufferLayout.u8("bumpSeed")])
+    layout: BufferLayout.struct([BufferLayout.u32("instruction"), authorized(), lockup()])
   },
-  FreezeLookupTable: {
+  Authorize: {
     index: 1,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
+    layout: BufferLayout.struct([BufferLayout.u32("instruction"), publicKey("newAuthorized"), BufferLayout.u32("stakeAuthorizationType")])
   },
-  ExtendLookupTable: {
+  Delegate: {
     index: 2,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction"), u64(), BufferLayout.seq(publicKey(), BufferLayout.offset(BufferLayout.u32(), -8), "addresses")])
+    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
   },
-  DeactivateLookupTable: {
+  Split: {
     index: 3,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
+    layout: BufferLayout.struct([BufferLayout.u32("instruction"), BufferLayout.ns64("lamports")])
   },
-  CloseLookupTable: {
+  Withdraw: {
     index: 4,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
-  }
-});
-var AddressLookupTableProgram = class {
-  /**
-   * @internal
-   */
-  constructor() {
-  }
-  static createLookupTable(params) {
-    const [lookupTableAddress, bumpSeed] = PublicKey.findProgramAddressSync([params.authority.toBuffer(), getU64Encoder().encode(params.recentSlot)], this.programId);
-    const type2 = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CreateLookupTable;
-    const data = encodeData(type2, {
-      recentSlot: BigInt(params.recentSlot),
-      bumpSeed
-    });
-    const keys = [{
-      pubkey: lookupTableAddress,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: params.authority,
-      isSigner: true,
-      isWritable: false
-    }, {
-      pubkey: params.payer,
-      isSigner: true,
-      isWritable: true
-    }, {
-      pubkey: SystemProgram.programId,
-      isSigner: false,
-      isWritable: false
-    }];
-    return [new TransactionInstruction({
-      programId: this.programId,
-      keys,
-      data
-    }), lookupTableAddress];
-  }
-  static freezeLookupTable(params) {
-    const type2 = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.FreezeLookupTable;
-    const data = encodeData(type2);
-    const keys = [{
-      pubkey: params.lookupTable,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: params.authority,
-      isSigner: true,
-      isWritable: false
-    }];
-    return new TransactionInstruction({
-      programId: this.programId,
-      keys,
-      data
-    });
-  }
-  static extendLookupTable(params) {
-    const type2 = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.ExtendLookupTable;
-    const data = encodeData(type2, {
-      addresses: params.addresses.map((addr) => addr.toBytes())
-    });
-    const keys = [{
-      pubkey: params.lookupTable,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: params.authority,
-      isSigner: true,
-      isWritable: false
-    }];
-    if (params.payer) {
-      keys.push({
-        pubkey: params.payer,
-        isSigner: true,
-        isWritable: true
-      }, {
-        pubkey: SystemProgram.programId,
-        isSigner: false,
-        isWritable: false
-      });
-    }
-    return new TransactionInstruction({
-      programId: this.programId,
-      keys,
-      data
-    });
-  }
-  static deactivateLookupTable(params) {
-    const type2 = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.DeactivateLookupTable;
-    const data = encodeData(type2);
-    const keys = [{
-      pubkey: params.lookupTable,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: params.authority,
-      isSigner: true,
-      isWritable: false
-    }];
-    return new TransactionInstruction({
-      programId: this.programId,
-      keys,
-      data
-    });
-  }
-  static closeLookupTable(params) {
-    const type2 = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CloseLookupTable;
-    const data = encodeData(type2);
-    const keys = [{
-      pubkey: params.lookupTable,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: params.authority,
-      isSigner: true,
-      isWritable: false
-    }, {
-      pubkey: params.recipient,
-      isSigner: false,
-      isWritable: true
-    }];
-    return new TransactionInstruction({
-      programId: this.programId,
-      keys,
-      data
-    });
-  }
-};
-AddressLookupTableProgram.programId = new PublicKey("AddressLookupTab1e1111111111111111111111111");
-var COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze({
-  RequestUnits: {
-    index: 0,
-    layout: BufferLayout.struct([BufferLayout.u8("instruction"), BufferLayout.u32("units"), BufferLayout.u32("additionalFee")])
+    layout: BufferLayout.struct([BufferLayout.u32("instruction"), BufferLayout.ns64("lamports")])
   },
-  RequestHeapFrame: {
-    index: 1,
-    layout: BufferLayout.struct([BufferLayout.u8("instruction"), BufferLayout.u32("bytes")])
+  Deactivate: {
+    index: 5,
+    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
   },
-  SetComputeUnitLimit: {
-    index: 2,
-    layout: BufferLayout.struct([BufferLayout.u8("instruction"), BufferLayout.u32("units")])
+  Merge: {
+    index: 7,
+    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
   },
-  SetComputeUnitPrice: {
-    index: 3,
-    layout: BufferLayout.struct([BufferLayout.u8("instruction"), u64("microLamports")])
+  AuthorizeWithSeed: {
+    index: 8,
+    layout: BufferLayout.struct([BufferLayout.u32("instruction"), publicKey("newAuthorized"), BufferLayout.u32("stakeAuthorizationType"), rustString("authoritySeed"), publicKey("authorityOwner")])
   }
 });
-var ComputeBudgetProgram = class {
+var StakeAuthorizationLayout = Object.freeze({
+  Staker: {
+    index: 0
+  },
+  Withdrawer: {
+    index: 1
+  }
+});
+var StakeProgram = class {
   /**
    * @internal
    */
   constructor() {
   }
   /**
-   * Public key that identifies the Compute Budget program
+   * Public key that identifies the Stake program
    */
   /**
-   * @deprecated Instead, call {@link setComputeUnitLimit} and/or {@link setComputeUnitPrice}
+   * Generate an Initialize instruction to add to a Stake Create transaction
    */
-  static requestUnits(params) {
-    const type2 = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits;
-    const data = encodeData(type2, params);
-    return new TransactionInstruction({
-      keys: [],
-      programId: this.programId,
-      data
-    });
-  }
-  static requestHeapFrame(params) {
-    const type2 = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame;
-    const data = encodeData(type2, params);
-    return new TransactionInstruction({
-      keys: [],
-      programId: this.programId,
-      data
-    });
-  }
-  static setComputeUnitLimit(params) {
-    const type2 = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit;
-    const data = encodeData(type2, params);
-    return new TransactionInstruction({
-      keys: [],
-      programId: this.programId,
-      data
-    });
-  }
-  static setComputeUnitPrice(params) {
-    const type2 = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice;
+  static initialize(params) {
+    const {
+      stakePubkey,
+      authorized: authorized2,
+      lockup: maybeLockup
+    } = params;
+    const lockup2 = maybeLockup || Lockup.default;
+    const type2 = STAKE_INSTRUCTION_LAYOUTS.Initialize;
     const data = encodeData(type2, {
-      microLamports: BigInt(params.microLamports)
+      authorized: {
+        staker: toBuffer(authorized2.staker.toBuffer()),
+        withdrawer: toBuffer(authorized2.withdrawer.toBuffer())
+      },
+      lockup: {
+        unixTimestamp: lockup2.unixTimestamp,
+        epoch: lockup2.epoch,
+        custodian: toBuffer(lockup2.custodian.toBuffer())
+      }
     });
-    return new TransactionInstruction({
-      keys: [],
+    const instructionData = {
+      keys: [{
+        pubkey: stakePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: SYSVAR_RENT_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }],
       programId: this.programId,
       data
-    });
+    };
+    return new TransactionInstruction(instructionData);
   }
-};
-ComputeBudgetProgram.programId = new PublicKey("ComputeBudget111111111111111111111111111111");
-var PRIVATE_KEY_BYTES$1 = 64;
-var PUBLIC_KEY_BYTES$1 = 32;
-var SIGNATURE_BYTES = 64;
-var ED25519_INSTRUCTION_LAYOUT = BufferLayout.struct([BufferLayout.u8("numSignatures"), BufferLayout.u8("padding"), BufferLayout.u16("signatureOffset"), BufferLayout.u16("signatureInstructionIndex"), BufferLayout.u16("publicKeyOffset"), BufferLayout.u16("publicKeyInstructionIndex"), BufferLayout.u16("messageDataOffset"), BufferLayout.u16("messageDataSize"), BufferLayout.u16("messageInstructionIndex")]);
-var Ed25519Program = class _Ed25519Program {
   /**
-   * @internal
+   * Generate a Transaction that creates a new Stake account at
+   *   an address generated with `from`, a seed, and the Stake programId
    */
-  constructor() {
+  static createAccountWithSeed(params) {
+    const transaction = new Transaction();
+    transaction.add(SystemProgram.createAccountWithSeed({
+      fromPubkey: params.fromPubkey,
+      newAccountPubkey: params.stakePubkey,
+      basePubkey: params.basePubkey,
+      seed: params.seed,
+      lamports: params.lamports,
+      space: this.space,
+      programId: this.programId
+    }));
+    const {
+      stakePubkey,
+      authorized: authorized2,
+      lockup: lockup2
+    } = params;
+    return transaction.add(this.initialize({
+      stakePubkey,
+      authorized: authorized2,
+      lockup: lockup2
+    }));
   }
   /**
-   * Public key that identifies the ed25519 program
+   * Generate a Transaction that creates a new Stake account
+   */
+  static createAccount(params) {
+    const transaction = new Transaction();
+    transaction.add(SystemProgram.createAccount({
+      fromPubkey: params.fromPubkey,
+      newAccountPubkey: params.stakePubkey,
+      lamports: params.lamports,
+      space: this.space,
+      programId: this.programId
+    }));
+    const {
+      stakePubkey,
+      authorized: authorized2,
+      lockup: lockup2
+    } = params;
+    return transaction.add(this.initialize({
+      stakePubkey,
+      authorized: authorized2,
+      lockup: lockup2
+    }));
+  }
+  /**
+   * Generate a Transaction that delegates Stake tokens to a validator
+   * Vote PublicKey. This transaction can also be used to redelegate Stake
+   * to a new validator Vote PublicKey.
    */
+  static delegate(params) {
+    const {
+      stakePubkey,
+      authorizedPubkey,
+      votePubkey
+    } = params;
+    const type2 = STAKE_INSTRUCTION_LAYOUTS.Delegate;
+    const data = encodeData(type2);
+    return new Transaction().add({
+      keys: [{
+        pubkey: stakePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: votePubkey,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: SYSVAR_CLOCK_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: STAKE_CONFIG_ID,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: authorizedPubkey,
+        isSigner: true,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
+    });
+  }
   /**
-   * Create an ed25519 instruction with a public key and signature. The
-   * public key must be a buffer that is 32 bytes long, and the signature
-   * must be a buffer of 64 bytes.
+   * Generate a Transaction that authorizes a new PublicKey as Staker
+   * or Withdrawer on the Stake account.
    */
-  static createInstructionWithPublicKey(params) {
+  static authorize(params) {
     const {
-      publicKey: publicKey2,
-      message,
-      signature,
-      instructionIndex
+      stakePubkey,
+      authorizedPubkey,
+      newAuthorizedPubkey,
+      stakeAuthorizationType,
+      custodianPubkey
     } = params;
-    assert2(publicKey2.length === PUBLIC_KEY_BYTES$1, `Public Key must be ${PUBLIC_KEY_BYTES$1} bytes but received ${publicKey2.length} bytes`);
-    assert2(signature.length === SIGNATURE_BYTES, `Signature must be ${SIGNATURE_BYTES} bytes but received ${signature.length} bytes`);
-    const publicKeyOffset = ED25519_INSTRUCTION_LAYOUT.span;
-    const signatureOffset = publicKeyOffset + publicKey2.length;
-    const messageDataOffset = signatureOffset + signature.length;
-    const numSignatures = 1;
-    const instructionData = Buffer2.alloc(messageDataOffset + message.length);
-    const index = instructionIndex == null ? 65535 : instructionIndex;
-    ED25519_INSTRUCTION_LAYOUT.encode({
-      numSignatures,
-      padding: 0,
-      signatureOffset,
-      signatureInstructionIndex: index,
-      publicKeyOffset,
-      publicKeyInstructionIndex: index,
-      messageDataOffset,
-      messageDataSize: message.length,
-      messageInstructionIndex: index
-    }, instructionData);
-    instructionData.fill(publicKey2, publicKeyOffset);
-    instructionData.fill(signature, signatureOffset);
-    instructionData.fill(message, messageDataOffset);
-    return new TransactionInstruction({
-      keys: [],
-      programId: _Ed25519Program.programId,
-      data: instructionData
+    const type2 = STAKE_INSTRUCTION_LAYOUTS.Authorize;
+    const data = encodeData(type2, {
+      newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
+      stakeAuthorizationType: stakeAuthorizationType.index
+    });
+    const keys = [{
+      pubkey: stakePubkey,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: SYSVAR_CLOCK_PUBKEY,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: authorizedPubkey,
+      isSigner: true,
+      isWritable: false
+    }];
+    if (custodianPubkey) {
+      keys.push({
+        pubkey: custodianPubkey,
+        isSigner: true,
+        isWritable: false
+      });
+    }
+    return new Transaction().add({
+      keys,
+      programId: this.programId,
+      data
     });
   }
   /**
-   * Create an ed25519 instruction with a private key. The private key
-   * must be a buffer that is 64 bytes long.
+   * Generate a Transaction that authorizes a new PublicKey as Staker
+   * or Withdrawer on the Stake account.
    */
-  static createInstructionWithPrivateKey(params) {
+  static authorizeWithSeed(params) {
     const {
-      privateKey,
-      message,
-      instructionIndex
+      stakePubkey,
+      authorityBase,
+      authoritySeed,
+      authorityOwner,
+      newAuthorizedPubkey,
+      stakeAuthorizationType,
+      custodianPubkey
     } = params;
-    assert2(privateKey.length === PRIVATE_KEY_BYTES$1, `Private key must be ${PRIVATE_KEY_BYTES$1} bytes but received ${privateKey.length} bytes`);
-    try {
-      const keypair = Keypair.fromSecretKey(privateKey);
-      const publicKey2 = keypair.publicKey.toBytes();
-      const signature = sign(message, keypair.secretKey);
-      return this.createInstructionWithPublicKey({
-        publicKey: publicKey2,
-        message,
-        signature,
-        instructionIndex
+    const type2 = STAKE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed;
+    const data = encodeData(type2, {
+      newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
+      stakeAuthorizationType: stakeAuthorizationType.index,
+      authoritySeed,
+      authorityOwner: toBuffer(authorityOwner.toBuffer())
+    });
+    const keys = [{
+      pubkey: stakePubkey,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: authorityBase,
+      isSigner: true,
+      isWritable: false
+    }, {
+      pubkey: SYSVAR_CLOCK_PUBKEY,
+      isSigner: false,
+      isWritable: false
+    }];
+    if (custodianPubkey) {
+      keys.push({
+        pubkey: custodianPubkey,
+        isSigner: true,
+        isWritable: false
       });
-    } catch (error) {
-      throw new Error(`Error creating instruction; ${error}`);
     }
+    return new Transaction().add({
+      keys,
+      programId: this.programId,
+      data
+    });
   }
-};
-Ed25519Program.programId = new PublicKey("Ed25519SigVerify111111111111111111111111111");
-var ecdsaSign = (msgHash, privKey) => {
-  const signature = secp256k1.sign(msgHash, privKey);
-  return [signature.toCompactRawBytes(), signature.recovery];
-};
-secp256k1.utils.isValidPrivateKey;
-var publicKeyCreate = secp256k1.getPublicKey;
-var PRIVATE_KEY_BYTES = 32;
-var ETHEREUM_ADDRESS_BYTES = 20;
-var PUBLIC_KEY_BYTES = 64;
-var SIGNATURE_OFFSETS_SERIALIZED_SIZE = 11;
-var SECP256K1_INSTRUCTION_LAYOUT = BufferLayout.struct([BufferLayout.u8("numSignatures"), BufferLayout.u16("signatureOffset"), BufferLayout.u8("signatureInstructionIndex"), BufferLayout.u16("ethAddressOffset"), BufferLayout.u8("ethAddressInstructionIndex"), BufferLayout.u16("messageDataOffset"), BufferLayout.u16("messageDataSize"), BufferLayout.u8("messageInstructionIndex"), BufferLayout.blob(20, "ethAddress"), BufferLayout.blob(64, "signature"), BufferLayout.u8("recoveryId")]);
-var Secp256k1Program = class _Secp256k1Program {
   /**
    * @internal
    */
-  constructor() {
+  static splitInstruction(params) {
+    const {
+      stakePubkey,
+      authorizedPubkey,
+      splitStakePubkey,
+      lamports
+    } = params;
+    const type2 = STAKE_INSTRUCTION_LAYOUTS.Split;
+    const data = encodeData(type2, {
+      lamports
+    });
+    return new TransactionInstruction({
+      keys: [{
+        pubkey: stakePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: splitStakePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: authorizedPubkey,
+        isSigner: true,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
+    });
   }
   /**
-   * Public key that identifies the secp256k1 program
-   */
-  /**
-   * Construct an Ethereum address from a secp256k1 public key buffer.
-   * @param {Buffer} publicKey a 64 byte secp256k1 public key buffer
+   * Generate a Transaction that splits Stake tokens into another stake account
    */
-  static publicKeyToEthAddress(publicKey2) {
-    assert2(publicKey2.length === PUBLIC_KEY_BYTES, `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey2.length} bytes`);
-    try {
-      return Buffer2.from(keccak_256(toBuffer(publicKey2))).slice(-ETHEREUM_ADDRESS_BYTES);
-    } catch (error) {
-      throw new Error(`Error constructing Ethereum address: ${error}`);
-    }
+  static split(params, rentExemptReserve) {
+    const transaction = new Transaction();
+    transaction.add(SystemProgram.createAccount({
+      fromPubkey: params.authorizedPubkey,
+      newAccountPubkey: params.splitStakePubkey,
+      lamports: rentExemptReserve,
+      space: this.space,
+      programId: this.programId
+    }));
+    return transaction.add(this.splitInstruction(params));
   }
   /**
-   * Create an secp256k1 instruction with a public key. The public key
-   * must be a buffer that is 64 bytes long.
+   * Generate a Transaction that splits Stake tokens into another account
+   * derived from a base public key and seed
    */
-  static createInstructionWithPublicKey(params) {
+  static splitWithSeed(params, rentExemptReserve) {
     const {
-      publicKey: publicKey2,
-      message,
-      signature,
-      recoveryId,
-      instructionIndex
+      stakePubkey,
+      authorizedPubkey,
+      splitStakePubkey,
+      basePubkey,
+      seed,
+      lamports
     } = params;
-    return _Secp256k1Program.createInstructionWithEthAddress({
-      ethAddress: _Secp256k1Program.publicKeyToEthAddress(publicKey2),
-      message,
-      signature,
-      recoveryId,
-      instructionIndex
-    });
+    const transaction = new Transaction();
+    transaction.add(SystemProgram.allocate({
+      accountPubkey: splitStakePubkey,
+      basePubkey,
+      seed,
+      space: this.space,
+      programId: this.programId
+    }));
+    if (rentExemptReserve && rentExemptReserve > 0) {
+      transaction.add(SystemProgram.transfer({
+        fromPubkey: params.authorizedPubkey,
+        toPubkey: splitStakePubkey,
+        lamports: rentExemptReserve
+      }));
+    }
+    return transaction.add(this.splitInstruction({
+      stakePubkey,
+      authorizedPubkey,
+      splitStakePubkey,
+      lamports
+    }));
   }
   /**
-   * Create an secp256k1 instruction with an Ethereum address. The address
-   * must be a hex string or a buffer that is 20 bytes long.
+   * Generate a Transaction that merges Stake accounts.
    */
-  static createInstructionWithEthAddress(params) {
+  static merge(params) {
     const {
-      ethAddress: rawAddress,
-      message,
-      signature,
-      recoveryId,
-      instructionIndex = 0
+      stakePubkey,
+      sourceStakePubKey,
+      authorizedPubkey
     } = params;
-    let ethAddress;
-    if (typeof rawAddress === "string") {
-      if (rawAddress.startsWith("0x")) {
-        ethAddress = Buffer2.from(rawAddress.substr(2), "hex");
-      } else {
-        ethAddress = Buffer2.from(rawAddress, "hex");
-      }
-    } else {
-      ethAddress = rawAddress;
-    }
-    assert2(ethAddress.length === ETHEREUM_ADDRESS_BYTES, `Address must be ${ETHEREUM_ADDRESS_BYTES} bytes but received ${ethAddress.length} bytes`);
-    const dataStart = 1 + SIGNATURE_OFFSETS_SERIALIZED_SIZE;
-    const ethAddressOffset = dataStart;
-    const signatureOffset = dataStart + ethAddress.length;
-    const messageDataOffset = signatureOffset + signature.length + 1;
-    const numSignatures = 1;
-    const instructionData = Buffer2.alloc(SECP256K1_INSTRUCTION_LAYOUT.span + message.length);
-    SECP256K1_INSTRUCTION_LAYOUT.encode({
-      numSignatures,
-      signatureOffset,
-      signatureInstructionIndex: instructionIndex,
-      ethAddressOffset,
-      ethAddressInstructionIndex: instructionIndex,
-      messageDataOffset,
-      messageDataSize: message.length,
-      messageInstructionIndex: instructionIndex,
-      signature: toBuffer(signature),
-      ethAddress: toBuffer(ethAddress),
-      recoveryId
-    }, instructionData);
-    instructionData.fill(toBuffer(message), SECP256K1_INSTRUCTION_LAYOUT.span);
-    return new TransactionInstruction({
-      keys: [],
-      programId: _Secp256k1Program.programId,
-      data: instructionData
+    const type2 = STAKE_INSTRUCTION_LAYOUTS.Merge;
+    const data = encodeData(type2);
+    return new Transaction().add({
+      keys: [{
+        pubkey: stakePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: sourceStakePubKey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: SYSVAR_CLOCK_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: authorizedPubkey,
+        isSigner: true,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
     });
   }
   /**
-   * Create an secp256k1 instruction with a private key. The private key
-   * must be a buffer that is 32 bytes long.
+   * Generate a Transaction that withdraws deactivated Stake tokens.
    */
-  static createInstructionWithPrivateKey(params) {
+  static withdraw(params) {
     const {
-      privateKey: pkey,
-      message,
-      instructionIndex
+      stakePubkey,
+      authorizedPubkey,
+      toPubkey,
+      lamports,
+      custodianPubkey
     } = params;
-    assert2(pkey.length === PRIVATE_KEY_BYTES, `Private key must be ${PRIVATE_KEY_BYTES} bytes but received ${pkey.length} bytes`);
-    try {
-      const privateKey = toBuffer(pkey);
-      const publicKey2 = publicKeyCreate(
-        privateKey,
-        false
-        /* isCompressed */
-      ).slice(1);
-      const messageHash = Buffer2.from(keccak_256(toBuffer(message)));
-      const [signature, recoveryId] = ecdsaSign(messageHash, privateKey);
-      return this.createInstructionWithPublicKey({
-        publicKey: publicKey2,
-        message,
-        signature,
-        recoveryId,
-        instructionIndex
+    const type2 = STAKE_INSTRUCTION_LAYOUTS.Withdraw;
+    const data = encodeData(type2, {
+      lamports
+    });
+    const keys = [{
+      pubkey: stakePubkey,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: toPubkey,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: SYSVAR_CLOCK_PUBKEY,
+      isSigner: false,
+      isWritable: false
+    }, {
+      pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,
+      isSigner: false,
+      isWritable: false
+    }, {
+      pubkey: authorizedPubkey,
+      isSigner: true,
+      isWritable: false
+    }];
+    if (custodianPubkey) {
+      keys.push({
+        pubkey: custodianPubkey,
+        isSigner: true,
+        isWritable: false
       });
-    } catch (error) {
-      throw new Error(`Error creating instruction; ${error}`);
     }
+    return new Transaction().add({
+      keys,
+      programId: this.programId,
+      data
+    });
   }
-};
-Secp256k1Program.programId = new PublicKey("KeccakSecp256k11111111111111111111111111111");
-var _Lockup;
-var STAKE_CONFIG_ID = new PublicKey("StakeConfig11111111111111111111111111111111");
-var Lockup = class {
   /**
-   * Create a new Lockup object
+   * Generate a Transaction that deactivates Stake tokens.
    */
-  constructor(unixTimestamp, epoch, custodian) {
-    this.unixTimestamp = void 0;
-    this.epoch = void 0;
-    this.custodian = void 0;
-    this.unixTimestamp = unixTimestamp;
-    this.epoch = epoch;
-    this.custodian = custodian;
+  static deactivate(params) {
+    const {
+      stakePubkey,
+      authorizedPubkey
+    } = params;
+    const type2 = STAKE_INSTRUCTION_LAYOUTS.Deactivate;
+    const data = encodeData(type2);
+    return new Transaction().add({
+      keys: [{
+        pubkey: stakePubkey,
+        isSigner: false,
+        isWritable: true
+      }, {
+        pubkey: SYSVAR_CLOCK_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: authorizedPubkey,
+        isSigner: true,
+        isWritable: false
+      }],
+      programId: this.programId,
+      data
+    });
   }
-  /**
-   * Default, inactive Lockup value
-   */
 };
-_Lockup = Lockup;
-Lockup.default = new _Lockup(0, 0, PublicKey.default);
-var STAKE_INSTRUCTION_LAYOUTS = Object.freeze({
-  Initialize: {
+StakeProgram.programId = new PublicKey("Stake11111111111111111111111111111111111111");
+StakeProgram.space = 200;
+var VOTE_INSTRUCTION_LAYOUTS = Object.freeze({
+  InitializeAccount: {
     index: 0,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction"), authorized(), lockup()])
+    layout: BufferLayout.struct([BufferLayout.u32("instruction"), voteInit()])
   },
   Authorize: {
     index: 1,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction"), publicKey("newAuthorized"), BufferLayout.u32("stakeAuthorizationType")])
-  },
-  Delegate: {
-    index: 2,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
+    layout: BufferLayout.struct([BufferLayout.u32("instruction"), publicKey("newAuthorized"), BufferLayout.u32("voteAuthorizationType")])
   },
-  Split: {
+  Withdraw: {
     index: 3,
     layout: BufferLayout.struct([BufferLayout.u32("instruction"), BufferLayout.ns64("lamports")])
   },
-  Withdraw: {
+  UpdateValidatorIdentity: {
     index: 4,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction"), BufferLayout.ns64("lamports")])
-  },
-  Deactivate: {
-    index: 5,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
-  },
-  Merge: {
-    index: 7,
     layout: BufferLayout.struct([BufferLayout.u32("instruction")])
   },
   AuthorizeWithSeed: {
-    index: 8,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction"), publicKey("newAuthorized"), BufferLayout.u32("stakeAuthorizationType"), rustString("authoritySeed"), publicKey("authorityOwner")])
+    index: 10,
+    layout: BufferLayout.struct([BufferLayout.u32("instruction"), voteAuthorizeWithSeedArgs()])
   }
 });
-var StakeAuthorizationLayout = Object.freeze({
-  Staker: {
+var VoteAuthorizationLayout = Object.freeze({
+  Voter: {
     index: 0
   },
   Withdrawer: {
     index: 1
   }
 });
-var StakeProgram = class {
+var VoteProgram = class _VoteProgram {
   /**
    * @internal
    */
   constructor() {
   }
   /**
-   * Public key that identifies the Stake program
+   * Public key that identifies the Vote program
    */
   /**
-   * Generate an Initialize instruction to add to a Stake Create transaction
+   * Generate an Initialize instruction.
    */
-  static initialize(params) {
+  static initializeAccount(params) {
     const {
-      stakePubkey,
-      authorized: authorized2,
-      lockup: maybeLockup
+      votePubkey,
+      nodePubkey,
+      voteInit: voteInit2
     } = params;
-    const lockup2 = maybeLockup || Lockup.default;
-    const type2 = STAKE_INSTRUCTION_LAYOUTS.Initialize;
+    const type2 = VOTE_INSTRUCTION_LAYOUTS.InitializeAccount;
     const data = encodeData(type2, {
-      authorized: {
-        staker: toBuffer(authorized2.staker.toBuffer()),
-        withdrawer: toBuffer(authorized2.withdrawer.toBuffer())
-      },
-      lockup: {
-        unixTimestamp: lockup2.unixTimestamp,
-        epoch: lockup2.epoch,
-        custodian: toBuffer(lockup2.custodian.toBuffer())
+      voteInit: {
+        nodePubkey: toBuffer(voteInit2.nodePubkey.toBuffer()),
+        authorizedVoter: toBuffer(voteInit2.authorizedVoter.toBuffer()),
+        authorizedWithdrawer: toBuffer(voteInit2.authorizedWithdrawer.toBuffer()),
+        commission: voteInit2.commission
       }
     });
     const instructionData = {
       keys: [{
-        pubkey: stakePubkey,
+        pubkey: votePubkey,
         isSigner: false,
         isWritable: true
       }, {
         pubkey: SYSVAR_RENT_PUBKEY,
         isSigner: false,
         isWritable: false
+      }, {
+        pubkey: SYSVAR_CLOCK_PUBKEY,
+        isSigner: false,
+        isWritable: false
+      }, {
+        pubkey: nodePubkey,
+        isSigner: true,
+        isWritable: false
       }],
       programId: this.programId,
       data
@@ -21699,134 +21510,51 @@ var StakeProgram = class {
     return new TransactionInstruction(instructionData);
   }
   /**
-   * Generate a Transaction that creates a new Stake account at
-   *   an address generated with `from`, a seed, and the Stake programId
-   */
-  static createAccountWithSeed(params) {
-    const transaction = new Transaction();
-    transaction.add(SystemProgram.createAccountWithSeed({
-      fromPubkey: params.fromPubkey,
-      newAccountPubkey: params.stakePubkey,
-      basePubkey: params.basePubkey,
-      seed: params.seed,
-      lamports: params.lamports,
-      space: this.space,
-      programId: this.programId
-    }));
-    const {
-      stakePubkey,
-      authorized: authorized2,
-      lockup: lockup2
-    } = params;
-    return transaction.add(this.initialize({
-      stakePubkey,
-      authorized: authorized2,
-      lockup: lockup2
-    }));
-  }
-  /**
-   * Generate a Transaction that creates a new Stake account
+   * Generate a transaction that creates a new Vote account.
    */
   static createAccount(params) {
     const transaction = new Transaction();
     transaction.add(SystemProgram.createAccount({
       fromPubkey: params.fromPubkey,
-      newAccountPubkey: params.stakePubkey,
+      newAccountPubkey: params.votePubkey,
       lamports: params.lamports,
       space: this.space,
       programId: this.programId
     }));
-    const {
-      stakePubkey,
-      authorized: authorized2,
-      lockup: lockup2
-    } = params;
-    return transaction.add(this.initialize({
-      stakePubkey,
-      authorized: authorized2,
-      lockup: lockup2
-    }));
-  }
-  /**
-   * Generate a Transaction that delegates Stake tokens to a validator
-   * Vote PublicKey. This transaction can also be used to redelegate Stake
-   * to a new validator Vote PublicKey.
-   */
-  static delegate(params) {
-    const {
-      stakePubkey,
-      authorizedPubkey,
-      votePubkey
-    } = params;
-    const type2 = STAKE_INSTRUCTION_LAYOUTS.Delegate;
-    const data = encodeData(type2);
-    return new Transaction().add({
-      keys: [{
-        pubkey: stakePubkey,
-        isSigner: false,
-        isWritable: true
-      }, {
-        pubkey: votePubkey,
-        isSigner: false,
-        isWritable: false
-      }, {
-        pubkey: SYSVAR_CLOCK_PUBKEY,
-        isSigner: false,
-        isWritable: false
-      }, {
-        pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,
-        isSigner: false,
-        isWritable: false
-      }, {
-        pubkey: STAKE_CONFIG_ID,
-        isSigner: false,
-        isWritable: false
-      }, {
-        pubkey: authorizedPubkey,
-        isSigner: true,
-        isWritable: false
-      }],
-      programId: this.programId,
-      data
-    });
+    return transaction.add(this.initializeAccount({
+      votePubkey: params.votePubkey,
+      nodePubkey: params.voteInit.nodePubkey,
+      voteInit: params.voteInit
+    }));
   }
   /**
-   * Generate a Transaction that authorizes a new PublicKey as Staker
-   * or Withdrawer on the Stake account.
+   * Generate a transaction that authorizes a new Voter or Withdrawer on the Vote account.
    */
   static authorize(params) {
     const {
-      stakePubkey,
+      votePubkey,
       authorizedPubkey,
       newAuthorizedPubkey,
-      stakeAuthorizationType,
-      custodianPubkey
+      voteAuthorizationType
     } = params;
-    const type2 = STAKE_INSTRUCTION_LAYOUTS.Authorize;
+    const type2 = VOTE_INSTRUCTION_LAYOUTS.Authorize;
     const data = encodeData(type2, {
       newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
-      stakeAuthorizationType: stakeAuthorizationType.index
+      voteAuthorizationType: voteAuthorizationType.index
     });
     const keys = [{
-      pubkey: stakePubkey,
+      pubkey: votePubkey,
       isSigner: false,
       isWritable: true
     }, {
       pubkey: SYSVAR_CLOCK_PUBKEY,
       isSigner: false,
-      isWritable: true
+      isWritable: false
     }, {
       pubkey: authorizedPubkey,
       isSigner: true,
       isWritable: false
     }];
-    if (custodianPubkey) {
-      keys.push({
-        pubkey: custodianPubkey,
-        isSigner: true,
-        isWritable: false
-      });
-    }
     return new Transaction().add({
       keys,
       programId: this.programId,
@@ -21834,530 +21562,914 @@ var StakeProgram = class {
     });
   }
   /**
-   * Generate a Transaction that authorizes a new PublicKey as Staker
-   * or Withdrawer on the Stake account.
+   * Generate a transaction that authorizes a new Voter or Withdrawer on the Vote account
+   * where the current Voter or Withdrawer authority is a derived key.
    */
   static authorizeWithSeed(params) {
     const {
-      stakePubkey,
-      authorityBase,
-      authoritySeed,
-      authorityOwner,
+      currentAuthorityDerivedKeyBasePubkey,
+      currentAuthorityDerivedKeyOwnerPubkey,
+      currentAuthorityDerivedKeySeed,
       newAuthorizedPubkey,
-      stakeAuthorizationType,
-      custodianPubkey
+      voteAuthorizationType,
+      votePubkey
     } = params;
-    const type2 = STAKE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed;
+    const type2 = VOTE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed;
     const data = encodeData(type2, {
-      newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
-      stakeAuthorizationType: stakeAuthorizationType.index,
-      authoritySeed,
-      authorityOwner: toBuffer(authorityOwner.toBuffer())
+      voteAuthorizeWithSeedArgs: {
+        currentAuthorityDerivedKeyOwnerPubkey: toBuffer(currentAuthorityDerivedKeyOwnerPubkey.toBuffer()),
+        currentAuthorityDerivedKeySeed,
+        newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
+        voteAuthorizationType: voteAuthorizationType.index
+      }
     });
     const keys = [{
-      pubkey: stakePubkey,
+      pubkey: votePubkey,
       isSigner: false,
       isWritable: true
     }, {
-      pubkey: authorityBase,
+      pubkey: SYSVAR_CLOCK_PUBKEY,
+      isSigner: false,
+      isWritable: false
+    }, {
+      pubkey: currentAuthorityDerivedKeyBasePubkey,
       isSigner: true,
       isWritable: false
+    }];
+    return new Transaction().add({
+      keys,
+      programId: this.programId,
+      data
+    });
+  }
+  /**
+   * Generate a transaction to withdraw from a Vote account.
+   */
+  static withdraw(params) {
+    const {
+      votePubkey,
+      authorizedWithdrawerPubkey,
+      lamports,
+      toPubkey
+    } = params;
+    const type2 = VOTE_INSTRUCTION_LAYOUTS.Withdraw;
+    const data = encodeData(type2, {
+      lamports
+    });
+    const keys = [{
+      pubkey: votePubkey,
+      isSigner: false,
+      isWritable: true
     }, {
-      pubkey: SYSVAR_CLOCK_PUBKEY,
+      pubkey: toPubkey,
       isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: authorizedWithdrawerPubkey,
+      isSigner: true,
       isWritable: false
     }];
-    if (custodianPubkey) {
-      keys.push({
-        pubkey: custodianPubkey,
-        isSigner: true,
-        isWritable: false
+    return new Transaction().add({
+      keys,
+      programId: this.programId,
+      data
+    });
+  }
+  /**
+   * Generate a transaction to withdraw safely from a Vote account.
+   *
+   * This function was created as a safeguard for vote accounts running validators, `safeWithdraw`
+   * checks that the withdraw amount will not exceed the specified balance while leaving enough left
+   * to cover rent. If you wish to close the vote account by withdrawing the full amount, call the
+   * `withdraw` method directly.
+   */
+  static safeWithdraw(params, currentVoteAccountBalance, rentExemptMinimum) {
+    if (params.lamports > currentVoteAccountBalance - rentExemptMinimum) {
+      throw new Error("Withdraw will leave vote account with insufficient funds.");
+    }
+    return _VoteProgram.withdraw(params);
+  }
+  /**
+   * Generate a transaction to update the validator identity (node pubkey) of a Vote account.
+   */
+  static updateValidatorIdentity(params) {
+    const {
+      votePubkey,
+      authorizedWithdrawerPubkey,
+      nodePubkey
+    } = params;
+    const type2 = VOTE_INSTRUCTION_LAYOUTS.UpdateValidatorIdentity;
+    const data = encodeData(type2);
+    const keys = [{
+      pubkey: votePubkey,
+      isSigner: false,
+      isWritable: true
+    }, {
+      pubkey: nodePubkey,
+      isSigner: true,
+      isWritable: false
+    }, {
+      pubkey: authorizedWithdrawerPubkey,
+      isSigner: true,
+      isWritable: false
+    }];
+    return new Transaction().add({
+      keys,
+      programId: this.programId,
+      data
+    });
+  }
+};
+VoteProgram.programId = new PublicKey("Vote111111111111111111111111111111111111111");
+VoteProgram.space = 3762;
+var VALIDATOR_INFO_KEY = new PublicKey("Va1idator1nfo111111111111111111111111111111");
+var InfoString = type({
+  name: string(),
+  website: optional(string()),
+  details: optional(string()),
+  iconUrl: optional(string()),
+  keybaseUsername: optional(string())
+});
+var VOTE_PROGRAM_ID = new PublicKey("Vote111111111111111111111111111111111111111");
+var VoteAccountLayout = BufferLayout.struct([
+  publicKey("nodePubkey"),
+  publicKey("authorizedWithdrawer"),
+  BufferLayout.u8("commission"),
+  BufferLayout.nu64(),
+  // votes.length
+  BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64("slot"), BufferLayout.u32("confirmationCount")]), BufferLayout.offset(BufferLayout.u32(), -8), "votes"),
+  BufferLayout.u8("rootSlotValid"),
+  BufferLayout.nu64("rootSlot"),
+  BufferLayout.nu64(),
+  // authorizedVoters.length
+  BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64("epoch"), publicKey("authorizedVoter")]), BufferLayout.offset(BufferLayout.u32(), -8), "authorizedVoters"),
+  BufferLayout.struct([BufferLayout.seq(BufferLayout.struct([publicKey("authorizedPubkey"), BufferLayout.nu64("epochOfLastAuthorizedSwitch"), BufferLayout.nu64("targetEpoch")]), 32, "buf"), BufferLayout.nu64("idx"), BufferLayout.u8("isEmpty")], "priorVoters"),
+  BufferLayout.nu64(),
+  // epochCredits.length
+  BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64("epoch"), BufferLayout.nu64("credits"), BufferLayout.nu64("prevCredits")]), BufferLayout.offset(BufferLayout.u32(), -8), "epochCredits"),
+  BufferLayout.struct([BufferLayout.nu64("slot"), BufferLayout.nu64("timestamp")], "lastTimestamp")
+]);
+
+// src/http-client.ts
+var HttpClient = class {
+  constructor(baseUrl, storage, logger2, appId, autoPayConfig) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.storage = storage;
+    this.logger = logger2 || logger;
+    this.appId = appId;
+    this.autoPayConfig = {
+      enabled: autoPayConfig?.enabled ?? false,
+      maxAmountMinor: autoPayConfig?.maxAmountMinor ?? 1e5,
+      maxRetries: autoPayConfig?.maxRetries ?? 1
+    };
+  }
+  setAutoPayHandlers(input) {
+    this.signerAddressProvider = input.signerAddressProvider;
+    this.signTransactionHandler = input.signTransactionHandler;
+  }
+  async request(endpoint, options = {}) {
+    return this.requestInternal(endpoint, options, 0);
+  }
+  async requestInternal(endpoint, options, attempt) {
+    const url2 = `${this.baseUrl}${endpoint}`;
+    const token = this.storage.get(TOKEN_KEY);
+    this.logger.debug("HTTP request", {
+      method: options.method || "GET",
+      endpoint,
+      url: url2,
+      hasToken: !!token
+    });
+    const headers = {
+      "Content-Type": "application/json",
+      "X-SDK-Version": SDK_VERSION,
+      ...options.headers
+    };
+    if (this.appId) {
+      headers["X-App-Id"] = this.appId;
+      if (this.appId === "dim-agents") {
+        headers["X-Dim-Agent"] = "1";
+      }
+    }
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const response = await fetch(url2, {
+      ...options,
+      headers
+    });
+    this.logger.debug("HTTP response", {
+      method: options.method || "GET",
+      endpoint,
+      status: response.status,
+      ok: response.ok
+    });
+    if (!response.ok) {
+      if (response.status === 402 && this.autoPayConfig.enabled && !endpoint.startsWith("/payments/") && attempt < this.autoPayConfig.maxRetries) {
+        const challenge = await this.extractPaymentChallenge(response);
+        if (challenge && this.canAutoPayChallenge(challenge)) {
+          const paymentProof = await this.payChallenge(challenge);
+          const retryHeaders = {
+            ...options.headers,
+            "PAYMENT-SIGNATURE": paymentProof
+          };
+          return this.requestInternal(
+            endpoint,
+            { ...options, headers: retryHeaders },
+            attempt + 1
+          );
+        }
+      }
+      if (response.status === 426) {
+        let upgradeMessage = "SDK version outdated. Run: npm install @dimcool/sdk@latest";
+        try {
+          const errorData = await response.json();
+          if (typeof errorData.message === "string") {
+            upgradeMessage = errorData.message;
+          }
+        } catch {
+        }
+        this.logger.error("SDK upgrade required", {
+          endpoint,
+          sdkVersion: SDK_VERSION,
+          message: upgradeMessage
+        });
+        const error2 = new Error(upgradeMessage);
+        error2.code = "SDK_UPGRADE_REQUIRED";
+        error2.statusCode = 426;
+        throw error2;
+      }
+      if (response.status === 401) {
+        this.logger.warn("Unauthorized response, clearing token", { endpoint });
+        this.storage.delete(TOKEN_KEY);
+        throw new Error("Unauthorized - please login again");
+      }
+      let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+      let errorCode;
+      try {
+        const errorData = await response.json();
+        errorCode = errorData.code;
+        if (typeof errorData.message === "string" && errorData.message.trim()) {
+          errorMessage = errorData.message;
+        } else if (Array.isArray(errorData.message) && errorData.message.length) {
+          errorMessage = errorData.message.join(", ");
+        } else if (typeof errorData.error === "string" && errorData.error.trim()) {
+          errorMessage = errorData.error;
+        }
+      } catch {
+      }
+      this.logger.error("HTTP request failed", {
+        endpoint,
+        status: response.status,
+        error: errorMessage,
+        code: errorCode
       });
+      const error = new Error(errorMessage);
+      error.code = errorCode;
+      error.statusCode = response.status;
+      throw error;
     }
-    return new Transaction().add({
-      keys,
-      programId: this.programId,
-      data
+    const contentType = response.headers.get("content-type");
+    if (contentType && contentType.includes("application/json")) {
+      const data = await response.json();
+      this.logger.debug("HTTP response parsed", { endpoint, hasData: !!data });
+      return data;
+    }
+    this.logger.debug("HTTP response empty", { endpoint });
+    return {};
+  }
+  get(endpoint, options) {
+    return this.request(endpoint, { ...options, method: "GET" });
+  }
+  post(endpoint, data, options) {
+    return this.request(endpoint, {
+      ...options,
+      method: "POST",
+      body: data ? JSON.stringify(data) : void 0
     });
   }
-  /**
-   * @internal
-   */
-  static splitInstruction(params) {
-    const {
-      stakePubkey,
-      authorizedPubkey,
-      splitStakePubkey,
-      lamports
-    } = params;
-    const type2 = STAKE_INSTRUCTION_LAYOUTS.Split;
-    const data = encodeData(type2, {
-      lamports
+  patch(endpoint, data, options) {
+    return this.request(endpoint, {
+      ...options,
+      method: "PATCH",
+      body: data ? JSON.stringify(data) : void 0
     });
-    return new TransactionInstruction({
-      keys: [{
-        pubkey: stakePubkey,
-        isSigner: false,
-        isWritable: true
-      }, {
-        pubkey: splitStakePubkey,
-        isSigner: false,
-        isWritable: true
-      }, {
-        pubkey: authorizedPubkey,
-        isSigner: true,
-        isWritable: false
-      }],
-      programId: this.programId,
-      data
+  }
+  delete(endpoint, options) {
+    return this.request(endpoint, { ...options, method: "DELETE" });
+  }
+  async upload(endpoint, formData) {
+    const url2 = `${this.baseUrl}${endpoint}`;
+    const token = this.storage.get(TOKEN_KEY);
+    this.logger.debug("HTTP upload request", {
+      method: "POST",
+      endpoint,
+      url: url2,
+      hasToken: !!token
+    });
+    const headers = {
+      "X-SDK-Version": SDK_VERSION
+    };
+    if (this.appId) {
+      headers["X-App-Id"] = this.appId;
+    }
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const response = await fetch(url2, {
+      method: "POST",
+      headers,
+      body: formData
+    });
+    this.logger.debug("HTTP upload response", {
+      method: "POST",
+      endpoint,
+      status: response.status,
+      ok: response.ok
     });
+    if (!response.ok) {
+      if (response.status === 426) {
+        let upgradeMessage = "SDK version outdated. Run: npm install @dimcool/sdk@latest";
+        try {
+          const errorData = await response.json();
+          if (typeof errorData.message === "string") {
+            upgradeMessage = errorData.message;
+          }
+        } catch {
+        }
+        this.logger.error("SDK upgrade required", {
+          endpoint,
+          sdkVersion: SDK_VERSION,
+          message: upgradeMessage
+        });
+        const error = new Error(upgradeMessage);
+        error.code = "SDK_UPGRADE_REQUIRED";
+        error.statusCode = 426;
+        throw error;
+      }
+      if (response.status === 401) {
+        this.logger.warn("Unauthorized response, clearing token", { endpoint });
+        this.storage.delete(TOKEN_KEY);
+        throw new Error("Unauthorized - please login again");
+      }
+      let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+      try {
+        const errorData = await response.json();
+        errorMessage = errorData.error || errorMessage;
+      } catch {
+      }
+      this.logger.error("HTTP upload failed", {
+        endpoint,
+        status: response.status,
+        error: errorMessage
+      });
+      throw new Error(errorMessage);
+    }
+    const contentType = response.headers.get("content-type");
+    if (contentType && contentType.includes("application/json")) {
+      const data = await response.json();
+      this.logger.debug("HTTP upload response parsed", {
+        endpoint,
+        hasData: !!data
+      });
+      return data;
+    }
+    this.logger.debug("HTTP upload response empty", { endpoint });
+    return {};
   }
-  /**
-   * Generate a Transaction that splits Stake tokens into another stake account
-   */
-  static split(params, rentExemptReserve) {
-    const transaction = new Transaction();
-    transaction.add(SystemProgram.createAccount({
-      fromPubkey: params.authorizedPubkey,
-      newAccountPubkey: params.splitStakePubkey,
-      lamports: rentExemptReserve,
-      space: this.space,
-      programId: this.programId
-    }));
-    return transaction.add(this.splitInstruction(params));
+  async extractPaymentChallenge(response) {
+    const encoded = response.headers.get("payment-required");
+    if (encoded) {
+      try {
+        const decodedText = typeof Buffer !== "undefined" ? Buffer.from(encoded, "base64").toString("utf-8") : atob(encoded);
+        const decoded = JSON.parse(decodedText);
+        return decoded;
+      } catch {
+      }
+    }
+    try {
+      const body = await response.json();
+      return body.paymentRequired || null;
+    } catch {
+      return null;
+    }
   }
-  /**
-   * Generate a Transaction that splits Stake tokens into another account
-   * derived from a base public key and seed
-   */
-  static splitWithSeed(params, rentExemptReserve) {
-    const {
-      stakePubkey,
-      authorizedPubkey,
-      splitStakePubkey,
-      basePubkey,
-      seed,
-      lamports
-    } = params;
-    const transaction = new Transaction();
-    transaction.add(SystemProgram.allocate({
-      accountPubkey: splitStakePubkey,
-      basePubkey,
-      seed,
-      space: this.space,
-      programId: this.programId
-    }));
-    if (rentExemptReserve && rentExemptReserve > 0) {
-      transaction.add(SystemProgram.transfer({
-        fromPubkey: params.authorizedPubkey,
-        toPubkey: splitStakePubkey,
-        lamports: rentExemptReserve
-      }));
+  canAutoPayChallenge(challenge) {
+    if (!this.signerAddressProvider || !this.signTransactionHandler) {
+      return false;
+    }
+    if (challenge.amountMinor > this.autoPayConfig.maxAmountMinor) {
+      return false;
+    }
+    return true;
+  }
+  async payChallenge(challenge) {
+    if (!this.signerAddressProvider || !this.signTransactionHandler) {
+      throw new Error("Auto-pay signer is not configured.");
+    }
+    const payerAddress = this.signerAddressProvider();
+    if (!payerAddress) {
+      throw new Error("Wallet signer address is required for auto-payment.");
+    }
+    const prepare = await this.post(
+      "/payments/prepare",
+      {
+        paymentIntentId: challenge.paymentIntentId,
+        payerAddress
+      },
+      {
+        headers: {
+          "X-Auto-Pay": "1"
+        }
+      }
+    );
+    const unsignedTx = Transaction.from(
+      Buffer.from(prepare.transaction, "base64")
+    );
+    const signedTx = await this.signTransactionHandler(unsignedTx);
+    const signedTransaction = signedTx.serialize({ requireAllSignatures: false }).toString("base64");
+    const submitted = await this.post(
+      "/payments/submit",
+      {
+        paymentIntentId: challenge.paymentIntentId,
+        signedTransaction
+      }
+    );
+    if (!submitted.paymentProof) {
+      throw new Error("Payment proof missing from /payments/submit response.");
+    }
+    return submitted.paymentProof;
+  }
+};
+
+// src/auth.ts
+function toBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  if (typeof btoa === "undefined") {
+    throw new Error("Base64 encoding is not available in this environment");
+  }
+  return btoa(binary);
+}
+var Auth = class {
+  constructor(http2, storage, wallet, logger2) {
+    this.http = http2;
+    this.storage = storage;
+    this.wallet = wallet;
+    this.logger = logger2 || logger;
+  }
+  async login(email, password) {
+    this.logger.debug("Auth.login called", { email });
+    const response = await this.http.post("/auth/login", {
+      email,
+      password
+    });
+    this.logger.debug("Login response received", {
+      userId: response.user.id,
+      hasToken: !!response.access_token,
+      tokenLength: response.access_token?.length
+    });
+    if (!response.access_token) {
+      throw new Error("Login response missing access_token");
     }
-    return transaction.add(this.splitInstruction({
-      stakePubkey,
-      authorizedPubkey,
-      splitStakePubkey,
-      lamports
-    }));
-  }
-  /**
-   * Generate a Transaction that merges Stake accounts.
-   */
-  static merge(params) {
-    const {
-      stakePubkey,
-      sourceStakePubKey,
-      authorizedPubkey
-    } = params;
-    const type2 = STAKE_INSTRUCTION_LAYOUTS.Merge;
-    const data = encodeData(type2);
-    return new Transaction().add({
-      keys: [{
-        pubkey: stakePubkey,
-        isSigner: false,
-        isWritable: true
-      }, {
-        pubkey: sourceStakePubKey,
-        isSigner: false,
-        isWritable: true
-      }, {
-        pubkey: SYSVAR_CLOCK_PUBKEY,
-        isSigner: false,
-        isWritable: false
-      }, {
-        pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,
-        isSigner: false,
-        isWritable: false
-      }, {
-        pubkey: authorizedPubkey,
-        isSigner: true,
-        isWritable: false
-      }],
-      programId: this.programId,
-      data
+    this.storage.set(TOKEN_KEY, response.access_token);
+    const storedToken = this.storage.get(TOKEN_KEY);
+    if (!storedToken || storedToken !== response.access_token) {
+      throw new Error(
+        `Token storage failed! Expected: ${response.access_token.substring(0, 20)}..., Got: ${storedToken?.substring(0, 20)}...`
+      );
+    }
+    this.logger.debug("Token stored in storage", {
+      tokenKey: TOKEN_KEY,
+      stored: !!storedToken,
+      storedTokenLength: storedToken?.length,
+      storageType: this.storage.constructor.name
     });
+    return response;
   }
-  /**
-   * Generate a Transaction that withdraws deactivated Stake tokens.
-   */
-  static withdraw(params) {
-    const {
-      stakePubkey,
-      authorizedPubkey,
-      toPubkey,
-      lamports,
-      custodianPubkey
-    } = params;
-    const type2 = STAKE_INSTRUCTION_LAYOUTS.Withdraw;
-    const data = encodeData(type2, {
-      lamports
+  async generateHandshake(walletAddress) {
+    this.logger.debug("Auth.generateHandshake called", { walletAddress });
+    const response = await this.http.post(
+      "/auth/handshake",
+      {
+        walletAddress
+      }
+    );
+    this.logger.debug("Handshake generated", {
+      hasMessage: !!response.message,
+      hasNonce: !!response.nonce
     });
-    const keys = [{
-      pubkey: stakePubkey,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: toPubkey,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: SYSVAR_CLOCK_PUBKEY,
-      isSigner: false,
-      isWritable: false
-    }, {
-      pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,
-      isSigner: false,
-      isWritable: false
-    }, {
-      pubkey: authorizedPubkey,
-      isSigner: true,
-      isWritable: false
-    }];
-    if (custodianPubkey) {
-      keys.push({
-        pubkey: custodianPubkey,
-        isSigner: true,
-        isWritable: false
-      });
+    return response;
+  }
+  async loginWithWallet(options) {
+    const address = this.wallet.getSignerAddress();
+    if (!address) {
+      throw new Error(
+        "Wallet signer address is required for wallet login. Set sdk.wallet.setSigner({ address, signMessage, signTransaction })."
+      );
     }
-    return new Transaction().add({
-      keys,
-      programId: this.programId,
-      data
+    if (!this.wallet.hasSigner()) {
+      throw new Error(
+        "No signer configured. Call sdk.wallet.setSigner(...) before wallet login."
+      );
+    }
+    const { message } = await this.generateHandshake(address);
+    const signatureResult = await this.wallet.signMessage(message);
+    const signedMessage = typeof signatureResult === "string" ? signatureResult : toBase64(signatureResult);
+    this.logger.debug("Auth.loginWithWallet called", {
+      address,
+      walletMeta: options?.walletMeta
+    });
+    const response = await this.http.post("/auth/login-wallet", {
+      signedMessage,
+      address,
+      referralCode: options?.referralCode,
+      walletMeta: options?.walletMeta
+    });
+    this.logger.debug("Wallet login response received", {
+      userId: response.user.id,
+      hasToken: !!response.access_token
     });
+    this.storage.set(TOKEN_KEY, response.access_token);
+    this.logger.debug("Token stored in storage", { tokenKey: TOKEN_KEY });
+    return response;
   }
-  /**
-   * Generate a Transaction that deactivates Stake tokens.
-   */
-  static deactivate(params) {
-    const {
-      stakePubkey,
-      authorizedPubkey
-    } = params;
-    const type2 = STAKE_INSTRUCTION_LAYOUTS.Deactivate;
-    const data = encodeData(type2);
-    return new Transaction().add({
-      keys: [{
-        pubkey: stakePubkey,
-        isSigner: false,
-        isWritable: true
-      }, {
-        pubkey: SYSVAR_CLOCK_PUBKEY,
-        isSigner: false,
-        isWritable: false
-      }, {
-        pubkey: authorizedPubkey,
-        isSigner: true,
-        isWritable: false
-      }],
-      programId: this.programId,
-      data
+  logout() {
+    this.logger.debug("Auth.logout called");
+    const hadToken = this.storage.get(TOKEN_KEY) !== null;
+    this.storage.delete(TOKEN_KEY);
+    this.logger.debug("Token removed from storage", { hadToken });
+  }
+  isAuthenticated() {
+    const isAuth = this.storage.get(TOKEN_KEY) !== null;
+    this.logger.debug("Auth.isAuthenticated called", {
+      isAuthenticated: isAuth
+    });
+    return isAuth;
+  }
+  async getLatestSessions(limit) {
+    this.logger.debug("Auth.getLatestSessions called", { limit });
+    const params = new URLSearchParams();
+    if (limit !== void 0) {
+      params.append("limit", limit.toString());
+    }
+    const queryString = params.toString();
+    const endpoint = queryString ? `/auth/sessions?${queryString}` : "/auth/sessions";
+    const response = await this.http.get(endpoint);
+    this.logger.debug("Latest sessions retrieved", { total: response.total });
+    return response;
+  }
+};
+
+// src/admin.ts
+var Admin = class {
+  constructor(http2, logger2) {
+    this.http = http2;
+    this.logger = logger2;
+  }
+  async getUserById(id) {
+    return this.http.get(`/admin/users/${id}`);
+  }
+  async getStats() {
+    return this.http.get("/admin/stats");
+  }
+  // Backward-compatible alias used in some consumers.
+  async getAdminStats() {
+    return this.getStats();
+  }
+  async getDailyStats(days) {
+    const params = new URLSearchParams();
+    if (days != null) params.append("days", String(days));
+    const queryString = params.toString();
+    const endpoint = queryString ? `/admin/stats/daily?${queryString}` : "/admin/stats/daily";
+    return this.http.get(endpoint);
+  }
+  // Backward-compatible alias used in some consumers.
+  async getAdminDailyStats(days) {
+    return this.getDailyStats(days);
+  }
+  async getEscrowSweepPreview() {
+    return this.http.post("/admin/escrow/sweep-preview");
+  }
+  async getEscrowSweeps(limit = 20) {
+    return this.http.get(
+      `/admin/escrow/sweeps?limit=${limit}`
+    );
+  }
+  async executeEscrowSweep(amountUsdcMinor, idempotencyKey) {
+    return this.http.post("/admin/escrow/sweep", {
+      amountUsdcMinor,
+      idempotencyKey
     });
   }
+  async banUser(userId, reason) {
+    return this.http.post(`/admin/users/${userId}/ban`, { reason });
+  }
+  async unbanUser(userId) {
+    return this.http.post(`/admin/users/${userId}/unban`, {});
+  }
+  async getCriticalIncidentSummary(hours = 24) {
+    return this.http.get(
+      `/admin/critical-incidents/summary?hours=${hours}`
+    );
+  }
+  async getCriticalIncidents(input) {
+    const params = new URLSearchParams();
+    if (input.page != null) params.append("page", String(input.page));
+    if (input.limit != null) params.append("limit", String(input.limit));
+    if (input.status) params.append("status", input.status);
+    if (input.severity) params.append("severity", input.severity);
+    if (input.category) params.append("category", input.category);
+    const query = params.toString();
+    return this.http.get(
+      `/admin/critical-incidents${query ? `?${query}` : ""}`
+    );
+  }
+  async resolveCriticalIncident(id, resolutionNote) {
+    return this.http.patch(
+      `/admin/critical-incidents/${id}/resolve`,
+      { resolutionNote }
+    );
+  }
+  async getPlatformFees(input) {
+    const params = new URLSearchParams();
+    if (input?.page != null) params.append("page", String(input.page));
+    if (input?.limit != null) params.append("limit", String(input.limit));
+    if (input?.from) params.append("from", input.from);
+    if (input?.to) params.append("to", input.to);
+    if (input?.purpose) params.append("purpose", input.purpose);
+    if (input?.appId) params.append("appId", input.appId);
+    if (input?.payerUserId) params.append("payerUserId", input.payerUserId);
+    if (input?.payerAddress) params.append("payerAddress", input.payerAddress);
+    if (input?.minAmount != null)
+      params.append("minAmount", String(input.minAmount));
+    if (input?.maxAmount != null)
+      params.append("maxAmount", String(input.maxAmount));
+    const query = params.toString();
+    return this.http.get(
+      `/admin/platform-fees${query ? `?${query}` : ""}`
+    );
+  }
 };
-StakeProgram.programId = new PublicKey("Stake11111111111111111111111111111111111111");
-StakeProgram.space = 200;
-var VOTE_INSTRUCTION_LAYOUTS = Object.freeze({
-  InitializeAccount: {
-    index: 0,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction"), voteInit()])
-  },
-  Authorize: {
-    index: 1,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction"), publicKey("newAuthorized"), BufferLayout.u32("voteAuthorizationType")])
-  },
-  Withdraw: {
-    index: 3,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction"), BufferLayout.ns64("lamports")])
-  },
-  UpdateValidatorIdentity: {
-    index: 4,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction")])
-  },
-  AuthorizeWithSeed: {
-    index: 10,
-    layout: BufferLayout.struct([BufferLayout.u32("instruction"), voteAuthorizeWithSeedArgs()])
+
+// src/users.ts
+var Users = class {
+  constructor(http2, logger2) {
+    this.http = http2;
+    this.logger = logger2;
   }
-});
-var VoteAuthorizationLayout = Object.freeze({
-  Voter: {
-    index: 0
-  },
-  Withdrawer: {
-    index: 1
+  async getUsers(page, limit, username, address) {
+    const params = new URLSearchParams();
+    if (page !== void 0) params.append("page", page.toString());
+    if (limit !== void 0) params.append("limit", limit.toString());
+    if (username !== void 0) params.append("username", username);
+    if (address !== void 0) params.append("address", address);
+    const queryString = params.toString();
+    const endpoint = queryString ? `/users?${queryString}` : "/users";
+    return this.http.get(endpoint);
   }
-});
-var VoteProgram = class _VoteProgram {
-  /**
-   * @internal
-   */
-  constructor() {
+  async getUserById(id) {
+    return this.http.get(`/users/${id}`);
   }
-  /**
-   * Public key that identifies the Vote program
-   */
-  /**
-   * Generate an Initialize instruction.
-   */
-  static initializeAccount(params) {
-    const {
-      votePubkey,
-      nodePubkey,
-      voteInit: voteInit2
-    } = params;
-    const type2 = VOTE_INSTRUCTION_LAYOUTS.InitializeAccount;
-    const data = encodeData(type2, {
-      voteInit: {
-        nodePubkey: toBuffer(voteInit2.nodePubkey.toBuffer()),
-        authorizedVoter: toBuffer(voteInit2.authorizedVoter.toBuffer()),
-        authorizedWithdrawer: toBuffer(voteInit2.authorizedWithdrawer.toBuffer()),
-        commission: voteInit2.commission
-      }
-    });
-    const instructionData = {
-      keys: [{
-        pubkey: votePubkey,
-        isSigner: false,
-        isWritable: true
-      }, {
-        pubkey: SYSVAR_RENT_PUBKEY,
-        isSigner: false,
-        isWritable: false
-      }, {
-        pubkey: SYSVAR_CLOCK_PUBKEY,
-        isSigner: false,
-        isWritable: false
-      }, {
-        pubkey: nodePubkey,
-        isSigner: true,
-        isWritable: false
-      }],
-      programId: this.programId,
-      data
-    };
-    return new TransactionInstruction(instructionData);
+  async isUsernameAvailable(username) {
+    const params = new URLSearchParams();
+    params.append("username", username);
+    return this.http.get(
+      `/users/username/availability?${params.toString()}`
+    );
   }
-  /**
-   * Generate a transaction that creates a new Vote account.
-   */
-  static createAccount(params) {
-    const transaction = new Transaction();
-    transaction.add(SystemProgram.createAccount({
-      fromPubkey: params.fromPubkey,
-      newAccountPubkey: params.votePubkey,
-      lamports: params.lamports,
-      space: this.space,
-      programId: this.programId
-    }));
-    return transaction.add(this.initializeAccount({
-      votePubkey: params.votePubkey,
-      nodePubkey: params.voteInit.nodePubkey,
-      voteInit: params.voteInit
-    }));
+  async updateUsername(username) {
+    return this.http.patch("/users/me/username", { username });
   }
-  /**
-   * Generate a transaction that authorizes a new Voter or Withdrawer on the Vote account.
-   */
-  static authorize(params) {
-    const {
-      votePubkey,
-      authorizedPubkey,
-      newAuthorizedPubkey,
-      voteAuthorizationType
-    } = params;
-    const type2 = VOTE_INSTRUCTION_LAYOUTS.Authorize;
-    const data = encodeData(type2, {
-      newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
-      voteAuthorizationType: voteAuthorizationType.index
-    });
-    const keys = [{
-      pubkey: votePubkey,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: SYSVAR_CLOCK_PUBKEY,
-      isSigner: false,
-      isWritable: false
-    }, {
-      pubkey: authorizedPubkey,
-      isSigner: true,
-      isWritable: false
-    }];
-    return new Transaction().add({
-      keys,
-      programId: this.programId,
-      data
-    });
+  async getPublicUserByUsername(username) {
+    return this.http.get(`/users/username/${username}`);
   }
   /**
-   * Generate a transaction that authorizes a new Voter or Withdrawer on the Vote account
-   * where the current Voter or Withdrawer authority is a derived key.
+   * Get a public user profile by ID.
+   * Returns PublicUser with optional spectatorCount.
    */
-  static authorizeWithSeed(params) {
-    const {
-      currentAuthorityDerivedKeyBasePubkey,
-      currentAuthorityDerivedKeyOwnerPubkey,
-      currentAuthorityDerivedKeySeed,
-      newAuthorizedPubkey,
-      voteAuthorizationType,
-      votePubkey
-    } = params;
-    const type2 = VOTE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed;
-    const data = encodeData(type2, {
-      voteAuthorizeWithSeedArgs: {
-        currentAuthorityDerivedKeyOwnerPubkey: toBuffer(currentAuthorityDerivedKeyOwnerPubkey.toBuffer()),
-        currentAuthorityDerivedKeySeed,
-        newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
-        voteAuthorizationType: voteAuthorizationType.index
-      }
-    });
-    const keys = [{
-      pubkey: votePubkey,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: SYSVAR_CLOCK_PUBKEY,
-      isSigner: false,
-      isWritable: false
-    }, {
-      pubkey: currentAuthorityDerivedKeyBasePubkey,
-      isSigner: true,
-      isWritable: false
-    }];
-    return new Transaction().add({
-      keys,
-      programId: this.programId,
-      data
-    });
+  async getPublicUserById(userId) {
+    return this.http.get(`/users/${userId}`);
+  }
+  async searchUsers(username, page, limit) {
+    const params = new URLSearchParams();
+    params.append("username", username);
+    if (page !== void 0) params.append("page", page.toString());
+    if (limit !== void 0) params.append("limit", limit.toString());
+    return this.http.get(
+      `/users/search?${params.toString()}`
+    );
+  }
+  async getFriends(userId, page, limit, search) {
+    const params = new URLSearchParams();
+    if (page !== void 0) params.append("page", page.toString());
+    if (limit !== void 0) params.append("limit", limit.toString());
+    if (search !== void 0) params.append("search", search);
+    const queryString = params.toString();
+    const endpoint = queryString ? `/friends/${userId}?${queryString}` : `/friends/${userId}`;
+    return this.http.get(endpoint);
+  }
+  async addFriend(userId) {
+    return this.http.post(`/friends/${userId}`, {});
+  }
+  async removeFriend(userId) {
+    return this.http.delete(`/friends/${userId}`);
+  }
+  async getIncomingFriendRequests() {
+    return this.http.get("/friends/requests/incoming");
+  }
+  async getOutgoingFriendRequests() {
+    return this.http.get("/friends/requests/outgoing");
+  }
+  async acceptFriendRequest(userId) {
+    return this.http.post(
+      `/friends/requests/${userId}/accept`,
+      {}
+    );
+  }
+  async declineFriendRequest(userId) {
+    return this.http.post(
+      `/friends/requests/${userId}/decline`,
+      {}
+    );
+  }
+  async cancelFriendRequest(userId) {
+    return this.http.delete(`/friends/requests/${userId}`);
+  }
+  async updateProfile(data) {
+    return this.http.patch("/users/me/profile", data);
+  }
+  async uploadAvatar(file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    return this.http.upload("/users/me/profile/avatar", formData);
+  }
+  async uploadCoverImage(file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    return this.http.upload("/users/me/profile/cover", formData);
+  }
+  async removeAvatar() {
+    return this.http.delete("/users/me/profile/avatar");
+  }
+  async removeCoverImage() {
+    return this.http.delete("/users/me/profile/cover");
+  }
+  // Admin file management methods
+  async getAllFiles() {
+    return this.http.get("/files");
+  }
+  async deleteFile(fileId) {
+    return this.http.delete(`/files/${fileId}`);
+  }
+  async getGameHistory(userId) {
+    return this.http.get(`/users/${userId}/game-history`);
   }
   /**
-   * Generate a transaction to withdraw from a Vote account.
+   * Get user activity for spectate flow. Returns in_game (with gameId, gameType), in_lobby (with lobbyId, lobbyStatus), or idle.
    */
-  static withdraw(params) {
-    const {
-      votePubkey,
-      authorizedWithdrawerPubkey,
-      lamports,
-      toPubkey
-    } = params;
-    const type2 = VOTE_INSTRUCTION_LAYOUTS.Withdraw;
-    const data = encodeData(type2, {
-      lamports
-    });
-    const keys = [{
-      pubkey: votePubkey,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: toPubkey,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: authorizedWithdrawerPubkey,
-      isSigner: true,
-      isWritable: false
-    }];
-    return new Transaction().add({
-      keys,
-      programId: this.programId,
-      data
+  async getUserActivity(userId) {
+    return this.http.get(`/users/${userId}/activity`, {
+      cache: "no-store"
     });
   }
   /**
-   * Generate a transaction to withdraw safely from a Vote account.
-   *
-   * This function was created as a safeguard for vote accounts running validators, `safeWithdraw`
-   * checks that the withdraw amount will not exceed the specified balance while leaving enough left
-   * to cover rent. If you wish to close the vote account by withdrawing the full amount, call the
-   * `withdraw` method directly.
+   * Get the current active game for a user (if they are a player in one).
+   * Returns null if the user is not in an active game.
    */
-  static safeWithdraw(params, currentVoteAccountBalance, rentExemptMinimum) {
-    if (params.lamports > currentVoteAccountBalance - rentExemptMinimum) {
-      throw new Error("Withdraw will leave vote account with insufficient funds.");
+  async getCurrentGame(userId) {
+    return this.http.get(`/users/${userId}/current-game`, {
+      cache: "no-store"
+    });
+  }
+  async getUserStats(userId) {
+    return this.http.get(`/users/${userId}/stats`);
+  }
+};
+
+// src/feature-flags.ts
+var FeatureFlags = class {
+  constructor(http2, logger2) {
+    this.http = http2;
+    this.logger = logger2;
+    this.flags = [];
+    this.loaded = false;
+  }
+  async getFeatureFlags() {
+    this.flags = await this.http.get("/feature-flags");
+    this.loaded = true;
+    return this.flags;
+  }
+  isEnabledFlag(name) {
+    const flag = this.flags.find((f) => f.name === name);
+    return flag?.enabled ?? false;
+  }
+  isLoaded() {
+    return this.loaded;
+  }
+  async updateFeatureFlag(name, enabled) {
+    const flag = await this.http.patch(`/feature-flags/${name}`, {
+      enabled
+    });
+    const index = this.flags.findIndex((f) => f.name === name);
+    if (index >= 0) {
+      this.flags[index] = flag;
+    } else {
+      this.flags.push(flag);
     }
-    return _VoteProgram.withdraw(params);
+    return flag;
+  }
+  async createFeatureFlag(name, enabled) {
+    const flag = await this.http.post("/feature-flags", {
+      name,
+      enabled
+    });
+    this.flags.push(flag);
+    return flag;
+  }
+};
+
+// src/lobbies.ts
+var Lobbies = class {
+  constructor(http2, logger2) {
+    this.http = http2;
+    this.logger = logger2;
+  }
+  async createLobby(gameType, betAmount) {
+    return this.http.post("/lobbies", { gameType, betAmount });
+  }
+  async getLobby(lobbyId) {
+    return this.http.get(`/lobbies/${lobbyId}`);
+  }
+  async inviteFriend(lobbyId, friendId) {
+    return this.http.post(`/lobbies/${lobbyId}/invite`, {
+      friendId
+    });
+  }
+  async acceptInvite(lobbyId) {
+    return this.http.post(`/lobbies/${lobbyId}/accept-invite`, {});
+  }
+  async joinLobby(lobbyId) {
+    return this.http.post(`/lobbies/${lobbyId}/join`, {});
+  }
+  async removePlayer(lobbyId, userId) {
+    return this.http.delete(
+      `/lobbies/${lobbyId}/players/${userId}`
+    );
+  }
+  async kickPlayer(lobbyId, userId) {
+    return this.removePlayer(lobbyId, userId);
+  }
+  async leaveLobby(lobbyId) {
+    return this.http.delete(`/lobbies/${lobbyId}`);
+  }
+  async joinQueue(lobbyId) {
+    return this.http.post(`/lobbies/${lobbyId}/join-queue`, {});
+  }
+  async cancelQueue(lobbyId) {
+    return this.http.delete(`/lobbies/${lobbyId}/queue`);
+  }
+  async updateBetAmount(lobbyId, betAmount) {
+    return this.http.patch(`/lobbies/${lobbyId}/bet-amount`, {
+      betAmount
+    });
+  }
+  async playSound(lobbyId, sound) {
+    return this.http.post(`/lobbies/${lobbyId}/sound`, {
+      sound
+    });
+  }
+  // Admin methods
+  async getActiveLobbies() {
+    return this.http.get("/lobbies/admin/active");
+  }
+  async getQueueStats() {
+    return this.http.get("/lobbies/admin/queues");
+  }
+  async deleteLobby(lobbyId) {
+    return this.http.delete(`/lobbies/admin/${lobbyId}`);
   }
   /**
-   * Generate a transaction to update the validator identity (node pubkey) of a Vote account.
+   * Play again: Create a new lobby, start deposits, and prepare deposit transaction
+   * Returns the lobby and unsigned transaction that needs to be signed
+   * @param gameType - The game type to play again
+   * @param betAmount - The bet amount (same as previous game)
+   * @param escrow - The escrow service instance (from sdk.escrow)
    */
-  static updateValidatorIdentity(params) {
-    const {
-      votePubkey,
-      authorizedWithdrawerPubkey,
-      nodePubkey
-    } = params;
-    const type2 = VOTE_INSTRUCTION_LAYOUTS.UpdateValidatorIdentity;
-    const data = encodeData(type2);
-    const keys = [{
-      pubkey: votePubkey,
-      isSigner: false,
-      isWritable: true
-    }, {
-      pubkey: nodePubkey,
-      isSigner: true,
-      isWritable: false
-    }, {
-      pubkey: authorizedWithdrawerPubkey,
-      isSigner: true,
-      isWritable: false
-    }];
-    return new Transaction().add({
-      keys,
-      programId: this.programId,
-      data
-    });
+  async playAgain(gameType, betAmount, escrow) {
+    const lobby = await this.createLobby(gameType, betAmount);
+    await escrow.startDeposits(lobby.id);
+    const prepareResponse = await escrow.prepareDepositTransaction(lobby.id);
+    return {
+      lobby,
+      unsignedTransaction: prepareResponse.transaction
+    };
   }
 };
-VoteProgram.programId = new PublicKey("Vote111111111111111111111111111111111111111");
-VoteProgram.space = 3762;
-var VALIDATOR_INFO_KEY = new PublicKey("Va1idator1nfo111111111111111111111111111111");
-var InfoString = type({
-  name: string(),
-  website: optional(string()),
-  details: optional(string()),
-  iconUrl: optional(string()),
-  keybaseUsername: optional(string())
-});
-var VOTE_PROGRAM_ID = new PublicKey("Vote111111111111111111111111111111111111111");
-var VoteAccountLayout = BufferLayout.struct([
-  publicKey("nodePubkey"),
-  publicKey("authorizedWithdrawer"),
-  BufferLayout.u8("commission"),
-  BufferLayout.nu64(),
-  // votes.length
-  BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64("slot"), BufferLayout.u32("confirmationCount")]), BufferLayout.offset(BufferLayout.u32(), -8), "votes"),
-  BufferLayout.u8("rootSlotValid"),
-  BufferLayout.nu64("rootSlot"),
-  BufferLayout.nu64(),
-  // authorizedVoters.length
-  BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64("epoch"), publicKey("authorizedVoter")]), BufferLayout.offset(BufferLayout.u32(), -8), "authorizedVoters"),
-  BufferLayout.struct([BufferLayout.seq(BufferLayout.struct([publicKey("authorizedPubkey"), BufferLayout.nu64("epochOfLastAuthorizedSwitch"), BufferLayout.nu64("targetEpoch")]), 32, "buf"), BufferLayout.nu64("idx"), BufferLayout.u8("isEmpty")], "priorVoters"),
-  BufferLayout.nu64(),
-  // epochCredits.length
-  BufferLayout.seq(BufferLayout.struct([BufferLayout.nu64("epoch"), BufferLayout.nu64("credits"), BufferLayout.nu64("prevCredits")]), BufferLayout.offset(BufferLayout.u32(), -8), "epochCredits"),
-  BufferLayout.struct([BufferLayout.nu64("slot"), BufferLayout.nu64("timestamp")], "lastTimestamp")
-]);
 
 // src/games.ts
 var Games = class {
@@ -25192,8 +25304,20 @@ var SDK = class {
   constructor(config) {
     const baseUrl = config.baseUrl || "http://localhost:3000";
     const logger2 = config.logger || logger;
-    this.http = config.httpClient || new HttpClient(baseUrl, config.storage, logger2, config.appId);
+    this.http = config.httpClient || new HttpClient(
+      baseUrl,
+      config.storage,
+      logger2,
+      config.appId,
+      config.autoPay
+    );
     this.wallet = new Wallet(this.http, logger2);
+    if (this.http instanceof HttpClient) {
+      this.http.setAutoPayHandlers({
+        signerAddressProvider: () => this.wallet.getSignerAddress(),
+        signTransactionHandler: (transaction) => this.wallet.signTransaction(transaction)
+      });
+    }
     this.auth = new Auth(this.http, config.storage, this.wallet, logger2);
     this.admin = new Admin(this.http, logger2);
     this.users = new Users(this.http, logger2);