@gmsol-labs/gmsol-sdk 0.5.0 → 0.7.0-beta.2

package/README.md

@@ -4,19 +4,23 @@
 [![Docs.rs](https://docs.rs/gmsol-sdk/badge.svg)](https://docs.rs/gmsol-sdk)
 [![npm](https://img.shields.io/npm/v/@gmsol-labs/gmsol-sdk.svg)](https://www.npmjs.com/package/@gmsol-labs/gmsol-sdk)
 
+[Examples](https://github.com/gmsol-labs/gmx-solana/tree/main/examples)
+
 ## Audits
 
-| Program          | Last Audit Date | Version   |
-| ---------------- | --------------- | --------- |
-| [gmsol-store]    | [2025-03-07]    | [2a66761] |
-| [gmsol-treasury] | [2025-03-07]    | [2a66761] |
-| [gmsol-timelock] | [2025-03-07]    | [2a66761] |
+| Program             | Last Audit Date | Version   |
+| ------------------- | --------------- | --------- |
+| [gmsol-store]       | [2025-07-28]    | [3202f7c] |
+| [gmsol-treasury]    | [2025-07-28]    | [3202f7c] |
+| [gmsol-timelock]    | [2025-07-28]    | [3202f7c] |
+| [gmsol-competition] | [2025-07-28]    | [3202f7c] |
 
-[gmsol-store]: https://github.com/gmsol-labs/gmx-solana/tree/main/programs/gmsol-store
-[gmsol-treasury]: https://github.com/gmsol-labs/gmx-solana/tree/main/programs/gmsol-treasury
-[gmsol-timelock]: https://github.com/gmsol-labs/gmx-solana/tree/main/programs/gmsol-timelock
-[2025-03-07]: https://github.com/gmsol-labs/gmx-solana-audits/blob/main/GMX_Solana_Audit_Report_Mar_7_2025_Zenith.pdf
-[2a66761]: https://github.com/gmsol-labs/gmx-solana/commit/2a66761d6573a6db6160a19fc3057e2091aebbfe
+[gmsol-store]: https://github.com/gmsol-labs/gmx-solana/tree/main/programs/store
+[gmsol-treasury]: https://github.com/gmsol-labs/gmx-solana/tree/main/programs/treasury
+[gmsol-timelock]: https://github.com/gmsol-labs/gmx-solana/tree/main/programs/timelock
+[gmsol-competition]: https://github.com/gmsol-labs/gmx-solana/tree/main/programs/competition
+[2025-07-28]: https://github.com/gmsol-labs/gmx-solana-audits/blob/main/GMX_Solana_Audit_Report_July_28_2025_Zenith.pdf
+[3202f7c]: https://github.com/gmsol-labs/gmx-solana/commit/3202f7ca1a01a076425af59d2bca7369fe9c156c
 
 ## Integration
 
@@ -26,7 +30,7 @@ Add the following to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-gmsol-sdk = { version = "0.5.0", features = ["client"] }
+gmsol-sdk = { version = "0.7.0", features = ["client"] }
 ```
 
 Create a `Client` and start using the core APIs:
@@ -71,8 +75,8 @@ Create a new Rust project and include `anchor_lang` and `bytemuck` as dependenci
 
 ```toml
 [dependencies]
-anchor-lang = "0.30.1"
-bytemuck = { version = "1.19.0", features = ["min_const_generics"] }
+anchor-lang = "0.31.1"
+bytemuck = { version = "1.19.0", features = ["min_const_generics", "derive"] }
 ```
 
 #### 2. Download and Store IDLs in `{PROJECT_ROOT}/idls/`
@@ -124,13 +128,55 @@ For a working implementation, check out the [gmx-solana-programs][gmx-solana-pro
 [treasury-program-link]: https://explorer.solana.com/address/GTuvYD5SxkTq4FLG6JV1FQ5dkczr1AfgDcBHaFsBdtBg/anchor-program
 [gmx-solana-programs-link]: https://github.com/gmsol-labs/gmx-solana-programs
 
+## Known Issues
+
+### Keepers
+
+- Order keepers can use prices from different timestamps for limit orders with a swap, which would lead to different output amounts.
+
+- Order Keepers are expected to select an execution fee that does not exceed the actual network fee incurred. In addition, the execution fee that the Order Keeper can specify is capped by the program. Even if the actual network fee incurred exceeds this cap, it will not affect the executability of the request.
+
+- A malicious Order Keeper could potentially profit consistently by manipulating the execution order of orders, but this risk can be mitigated by deploying a sufficient number of high-frequency and trusted Order Keepers, since a successful attack would require the malicious Order Keeper to ensure that the orders it creates are not executed within the valid price time window, which is typically 30 seconds.
+
+- A malicious Order Keeper could potentially extract rent paid by other Order Keepers by closing claimable accounts created by them. However, since claimable accounts are typically created and closed within the same transaction that executes the order, such situations are extremely rare.
+
+- Orders may be prevented from execution by a malicious user intentionally causing a market to be unbalanced resulting in a high price impact, this should be costly and difficult to benefit from.
+
+### Price Impact
+
+- Price impact can be reduced by using positions and swaps and trading across markets, chains, forks, other protocols, this is partially mitigated with virtual inventory tracking.
+
+- A user can reduce price impact by using high leverage positions, this is partially mitigated with the MIN_COLLATERAL_FACTOR_FOR_OPEN_INTEREST_MULTIPLIER value.
+
+- Calculation of price impact values do not account for fees and the effects resulting from the price impact itself, for most cases the effect on the price impact calculation should be small.
+
+### Market Token Price
+
+- It is rare but possible for a pool's value to become negative, this can happen since the impactPoolAmount and pending PnL is subtracted from the worth of the tokens in the pool.
+
+- Due to the difference in positive and negative position price impact, there can be a build up of virtual token amounts in the position impact pool which would affect the pricing of market tokens, the position impact pool should be gradually distributed if needed.
+
+### Virtual Inventory
+
+- Virtual inventory (for swap) tracks the amount of tokens in pools, it must be ensured that the tokens in each grouping are the same type and have the same decimals, i.e. the long tokens across pools in the group should have the same decimals, the short tokens across pools in the group should have the same decimals, assuming USDC has 6 decimals and WBTC has 8 decimals, markets like WSOL-USDC, WSOL-WBTC should not be grouped.
+
+### GLV
+
+- The GLV shift feature can be exploited by temporarily increasing the utilization in a market that typically has low utilization. Once the keeper executes the shift, the attacker can lower the utilization back to its normal levels. Position fees and price impact should be configured in a way that makes this attack expensive enough to cover the GLV loss.
+
+- In GLV there may be GM markets which are above their maximum pnl_to_pool_factor_for_traders. If this GM market's max_pnl_factor_for_deposits is higher than max_pnl_factor_for_traders then the GM market is valued lower during deposits than it will be once traders have realized their capped profits. Malicious user may observe a GM market in such a condition and deposit into the GLV containing it in order to gain from ADLs which will soon follow. To avoid this max_pnl_factor_for_deposits should be less than or equal to max_pnl_factor_for_traders.
+
+- It's technically possible for market value to become negative. In this case the GLV would be unusable until the market value becomes positive.
+
+- GM tokens could become illiquid due to high pnl factor or high reserved usd. Users can deposit illiquid GM tokens into GLV and withdraw liquidity from a different market, leaving the GLV with illiquid tokens. The glv_max_market_token_value and glv_max_market_token_amount parameters should account for the riskiness of a market to avoid having too many GM tokens from a risky market.
+
 ## Development
 
 ### Prerequisites
 
 - [Rust](https://www.rust-lang.org/tools/install)
-- [Solana v1.18.26](https://docs.anza.xyz/cli/install)
-- [Anchor v0.30.1](https://www.anchor-lang.com/docs/installation)
+- [Solana v2.1.21](https://docs.anza.xyz/cli/install)
+- [Anchor v0.31.1](https://www.anchor-lang.com/docs/installation)
 - [Node](https://nodejs.org/en/download)
 - [Just](https://github.com/casey/just?tab=readme-ov-file#installation)
 
@@ -142,16 +188,22 @@ To run all tests:
 just
 ```
 
+To use the `gmsol` CLI in development mode:
+
+```bash
+just cli
+```
+
 To install the `gmsol` CLI:
 
 ```bash
-cargo install-gmsol
+just install-cli
 ```
 
 Use the following command to verify the CLI is installed properly:
 
 ```bash
-gmsol --version
+gmsol -V
 ```
 
 ### Troubleshooting

package/index.d.ts

@@ -79,6 +79,8 @@ export interface BestSwapPath {
  */
 export interface CreateOrderOptions {
     recent_blockhash: string;
+    compute_unit_price_micro_lamports?: number | undefined;
+    compute_unit_min_priority_lamports?: number | undefined;
     payer: StringPubkey;
     collateral_or_swap_out_token: StringPubkey;
     hints: Map<StringPubkey, CreateOrderHint>;
@@ -88,6 +90,7 @@ export interface CreateOrderOptions {
     swap_path?: StringPubkey[] | undefined;
     skip_wrap_native_on_pay?: boolean | undefined;
     skip_unwrap_native_on_receive?: boolean | undefined;
+    callback?: Callback | undefined;
     transaction_group?: TransactionGroupOptions;
 }
 
@@ -96,6 +99,8 @@ export interface CreateOrderOptions {
  */
 export interface CloseOrderArgs {
     recent_blockhash: string;
+    compute_unit_price_micro_lamports?: number | undefined;
+    compute_unit_min_priority_lamports?: number | undefined;
     payer: StringPubkey;
     orders: Map<StringPubkey, CloseOrderHint>;
     program?: StoreProgram | undefined;
@@ -112,6 +117,8 @@ export interface UpdateParams {
  */
 export interface UpdateOrderArgs {
     recent_blockhash: string;
+    compute_unit_price_micro_lamports?: number | undefined;
+    compute_unit_min_priority_lamports?: number | undefined;
     payer: StringPubkey;
     orders: Map<StringPubkey, UpdateParams>;
     program?: StoreProgram | undefined;
@@ -124,7 +131,6 @@ export interface UpdateOrderArgs {
 export interface TransactionGroupOptions {
     max_transaction_size?: number | undefined;
     max_instructions_per_tx?: number | undefined;
-    compute_unit_price_micro_lamports?: number | undefined;
     luts?: Map<StringPubkey, StringPubkey[]>;
     memo?: string | undefined;
 }
@@ -286,7 +292,7 @@ export interface MarketStatus {
      */
     pool_value_without_pnl_for_long: Value;
     /**
-     * Pool avlue without pnl for short.
+     * Pool value without pnl for short.
      */
     pool_value_without_pnl_for_short: Value;
     /**
@@ -359,6 +365,28 @@ export interface Value {
     max: bigint;
 }
 
+/**
+ * Callback.
+ */
+export interface Callback {
+    /**
+     * Callback version.
+     */
+    version: number;
+    /**
+     * Callback program ID.
+     */
+    program: StringPubkey;
+    /**
+     * The address of shared data account.
+     */
+    shared_data: StringPubkey;
+    /**
+     * The address of partitioned data account.
+     */
+    partitioned_data: StringPubkey;
+}
+
 /**
  * Hint for [`UpdateOrder`].
  */
@@ -367,6 +395,10 @@ export interface UpdateOrderHint {
      * Market token.
      */
     market_token: StringPubkey;
+    /**
+     * Callback.
+     */
+    callback: Callback | undefined;
 }
 
 /**
@@ -457,6 +489,10 @@ export interface CloseOrderHint {
      * `should_unwrap_native_token` flag.
      */
     should_unwrap_native_token: boolean;
+    /**
+     * Callback.
+     */
+    callback: Callback | undefined;
 }
 
 /**
@@ -551,6 +587,7 @@ export interface CreateOrder {
      * Whether to unwrap the native token when receiving (e.g., convert WSOL to SOL).
      */
     unwrap_native_on_receive?: boolean;
+    callback?: Callback | undefined;
 }
 
 /**
@@ -630,17 +667,37 @@ export interface StoreProgram {
  */
 export type PnlFactorKind = "max_after_deposit" | "max_after_withdrawal" | "max_for_trader" | "for_adl" | "min_after_adl";
 
+/**
+ * A (twisted) ElGamal encryption keypair.
+ *
+ * The instances of the secret key are zeroized on drop.
+ */
+export class ElGamalKeypair {
+  private constructor();
+  free(): void;
+  /**
+   * Generates the public and secret keys for ElGamal encryption.
+   *
+   * This function is randomized. It internally samples a scalar element using `OsRng`.
+   */
+  static new_rand(): ElGamalKeypair;
+  pubkey_owned(): ElGamalPubkey;
+}
+/**
+ * Public key for the ElGamal encryption scheme.
+ */
+export class ElGamalPubkey {
+  private constructor();
+  free(): void;
+}
 /**
  * A hash; the 32-byte output of a hashing algorithm.
  *
  * This struct is used most often in `solana-sdk` and related crates to contain
- * a [SHA-256] hash, but may instead contain a [blake3] hash, as created by the
- * [`blake3`] module (and used in [`Message::hash`]).
+ * a [SHA-256] hash, but may instead contain a [blake3] hash.
  *
  * [SHA-256]: https://en.wikipedia.org/wiki/SHA-2
  * [blake3]: https://github.com/BLAKE3-team/BLAKE3
- * [`blake3`]: crate::blake3
- * [`Message::hash`]: crate::message::Message::hash
  */
 export class Hash {
   free(): void;
@@ -664,65 +721,9 @@ export class Hash {
   toBytes(): Uint8Array;
 }
 /**
- * A directive for a single invocation of a Solana program.
- *
- * An instruction specifies which program it is calling, which accounts it may
- * read or modify, and additional data that serves as input to the program. One
- * or more instructions are included in transactions submitted by Solana
- * clients. Instructions are also used to describe [cross-program
- * invocations][cpi].
- *
- * [cpi]: https://solana.com/docs/core/cpi
- *
- * During execution, a program will receive a list of account data as one of
- * its arguments, in the same order as specified during `Instruction`
- * construction.
- *
- * While Solana is agnostic to the format of the instruction data, it has
- * built-in support for serialization via [`borsh`] and [`bincode`].
- *
- * [`borsh`]: https://docs.rs/borsh/latest/borsh/
- * [`bincode`]: https://docs.rs/bincode/latest/bincode/
- *
- * # Specifying account metadata
- *
- * When constructing an [`Instruction`], a list of all accounts that may be
- * read or written during the execution of that instruction must be supplied as
- * [`AccountMeta`] values.
- *
- * Any account whose data may be mutated by the program during execution must
- * be specified as writable. During execution, writing to an account that was
- * not specified as writable will cause the transaction to fail. Writing to an
- * account that is not owned by the program will cause the transaction to fail.
- *
- * Any account whose lamport balance may be mutated by the program during
- * execution must be specified as writable. During execution, mutating the
- * lamports of an account that was not specified as writable will cause the
- * transaction to fail. While _subtracting_ lamports from an account not owned
- * by the program will cause the transaction to fail, _adding_ lamports to any
- * account is allowed, as long is it is mutable.
- *
- * Accounts that are not read or written by the program may still be specified
- * in an `Instruction`'s account list. These will affect scheduling of program
- * execution by the runtime, but will otherwise be ignored.
- *
- * When building a transaction, the Solana runtime coalesces all accounts used
- * by all instructions in that transaction, along with accounts and permissions
- * required by the runtime, into a single account list. Some accounts and
- * account permissions required by the runtime to process a transaction are
- * _not_ required to be included in an `Instruction`s account list. These
- * include:
- *
- * - The program ID &mdash; it is a separate field of `Instruction`
- * - The transaction's fee-paying account &mdash; it is added during [`Message`]
- *   construction. A program may still require the fee payer as part of the
- *   account list if it directly references it.
- *
- * [`Message`]: crate::message::Message
- *
- * Programs may require signatures from some accounts, in which case they
- * should be specified as signers during `Instruction` construction. The
- * program must still validate during execution that the account is a signer.
+ * wasm-bindgen version of the Instruction struct.
+ * This duplication is required until https://github.com/rustwasm/wasm-bindgen/issues/3671
+ * is fixed. This must not diverge from the regular non-wasm Instruction struct.
  */
 export class Instruction {
   private constructor();
@@ -791,7 +792,7 @@ export class Market {
   short_token_address(): string;
 }
 /**
- * A JS binding for [`MarkegGraph`].
+ * A JS binding for [`MarketGraph`].
  */
 export class MarketGraph {
   free(): void;
@@ -852,20 +853,9 @@ export class MarketModel {
   status(params: MarketStatusParams): MarketStatus;
 }
 /**
- * A Solana transaction message (legacy).
- *
- * See the [`message`] module documentation for further description.
- *
- * [`message`]: crate::message
- *
- * Some constructors accept an optional `payer`, the account responsible for
- * paying the cost of executing a transaction. In most cases, callers should
- * specify the payer explicitly in these constructors. In some cases though,
- * the caller is not _required_ to specify the payer, but is still allowed to:
- * in the `Message` structure, the first account is always the fee-payer, so if
- * the caller has knowledge that the first account of the constructed
- * transaction's `Message` is both a signer and the expected fee-payer, then
- * redundantly specifying the fee-payer is not strictly required.
+ * wasm-bindgen version of the Message struct.
+ * This duplication is required until https://github.com/rustwasm/wasm-bindgen/issues/3671
+ * is fixed. This must not diverge from the regular non-wasm Message struct.
  */
 export class Message {
   private constructor();
@@ -875,6 +865,32 @@ export class Message {
    */
   recent_blockhash: Hash;
 }
+/**
+ * The `ElGamalPubkey` type as a `Pod`.
+ */
+export class PodElGamalPubkey {
+  free(): void;
+  /**
+   * Create a new `PodElGamalPubkey` object
+   *
+   * * `value` - optional public key as a base64 encoded string, `Uint8Array`, `[number]`
+   */
+  constructor(value: any);
+  /**
+   * Return the base64 string representation of the public key
+   */
+  toString(): string;
+  /**
+   * Checks if two `ElGamalPubkey`s are equal
+   */
+  equals(other: PodElGamalPubkey): boolean;
+  /**
+   * Return the `Uint8Array` representation of the public key
+   */
+  toBytes(): Uint8Array;
+  static compressed(decoded: ElGamalPubkey): PodElGamalPubkey;
+  decompressed(): ElGamalPubkey;
+}
 /**
  * JS version of [`Position`].
  */
@@ -970,26 +986,9 @@ export class Pubkey {
   static findProgramAddress(seeds: any[], program_id: Pubkey): any;
 }
 /**
- * An atomically-committed sequence of instructions.
- *
- * While [`Instruction`]s are the basic unit of computation in Solana,
- * they are submitted by clients in [`Transaction`]s containing one or
- * more instructions, and signed by one or more [`Signer`]s.
- *
- * [`Signer`]: crate::signer::Signer
- *
- * See the [module documentation] for more details about transactions.
- *
- * [module documentation]: self
- *
- * Some constructors accept an optional `payer`, the account responsible for
- * paying the cost of executing a transaction. In most cases, callers should
- * specify the payer explicitly in these constructors. In some cases though,
- * the caller is not _required_ to specify the payer, but is still allowed to:
- * in the [`Message`] structure, the first account is always the fee-payer, so
- * if the caller has knowledge that the first account of the constructed
- * transaction's `Message` is both a signer and the expected fee-payer, then
- * redundantly specifying the fee-payer is not strictly required.
+ * wasm-bindgen version of the Transaction struct.
+ * This duplication is required until https://github.com/rustwasm/wasm-bindgen/issues/3671
+ * is fixed. This must not diverge from the regular non-wasm Transaction struct.
  */
 export class Transaction {
   free(): void;

package/index_bg.js

@@ -287,6 +287,83 @@ export function solana_program_init() {
     wasm.solana_program_init();
 }
 
+const ElGamalKeypairFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_elgamalkeypair_free(ptr >>> 0, 1));
+/**
+ * A (twisted) ElGamal encryption keypair.
+ *
+ * The instances of the secret key are zeroized on drop.
+ */
+export class ElGamalKeypair {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ElGamalKeypair.prototype);
+        obj.__wbg_ptr = ptr;
+        ElGamalKeypairFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ElGamalKeypairFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_elgamalkeypair_free(ptr, 0);
+    }
+    /**
+     * Generates the public and secret keys for ElGamal encryption.
+     *
+     * This function is randomized. It internally samples a scalar element using `OsRng`.
+     * @returns {ElGamalKeypair}
+     */
+    static new_rand() {
+        const ret = wasm.elgamalkeypair_new_rand();
+        return ElGamalKeypair.__wrap(ret);
+    }
+    /**
+     * @returns {ElGamalPubkey}
+     */
+    pubkey_owned() {
+        const ret = wasm.elgamalkeypair_pubkey_owned(this.__wbg_ptr);
+        return ElGamalPubkey.__wrap(ret);
+    }
+}
+
+const ElGamalPubkeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_elgamalpubkey_free(ptr >>> 0, 1));
+/**
+ * Public key for the ElGamal encryption scheme.
+ */
+export class ElGamalPubkey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ElGamalPubkey.prototype);
+        obj.__wbg_ptr = ptr;
+        ElGamalPubkeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ElGamalPubkeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_elgamalpubkey_free(ptr, 0);
+    }
+}
+
 const HashFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_hash_free(ptr >>> 0, 1));
@@ -294,13 +371,10 @@ const HashFinalization = (typeof FinalizationRegistry === 'undefined')
  * A hash; the 32-byte output of a hashing algorithm.
  *
  * This struct is used most often in `solana-sdk` and related crates to contain
- * a [SHA-256] hash, but may instead contain a [blake3] hash, as created by the
- * [`blake3`] module (and used in [`Message::hash`]).
+ * a [SHA-256] hash, but may instead contain a [blake3] hash.
  *
  * [SHA-256]: https://en.wikipedia.org/wiki/SHA-2
  * [blake3]: https://github.com/BLAKE3-team/BLAKE3
- * [`blake3`]: crate::blake3
- * [`Message::hash`]: crate::message::Message::hash
  */
 export class Hash {
 
@@ -380,65 +454,9 @@ const InstructionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_instruction_free(ptr >>> 0, 1));
 /**
- * A directive for a single invocation of a Solana program.
- *
- * An instruction specifies which program it is calling, which accounts it may
- * read or modify, and additional data that serves as input to the program. One
- * or more instructions are included in transactions submitted by Solana
- * clients. Instructions are also used to describe [cross-program
- * invocations][cpi].
- *
- * [cpi]: https://solana.com/docs/core/cpi
- *
- * During execution, a program will receive a list of account data as one of
- * its arguments, in the same order as specified during `Instruction`
- * construction.
- *
- * While Solana is agnostic to the format of the instruction data, it has
- * built-in support for serialization via [`borsh`] and [`bincode`].
- *
- * [`borsh`]: https://docs.rs/borsh/latest/borsh/
- * [`bincode`]: https://docs.rs/bincode/latest/bincode/
- *
- * # Specifying account metadata
- *
- * When constructing an [`Instruction`], a list of all accounts that may be
- * read or written during the execution of that instruction must be supplied as
- * [`AccountMeta`] values.
- *
- * Any account whose data may be mutated by the program during execution must
- * be specified as writable. During execution, writing to an account that was
- * not specified as writable will cause the transaction to fail. Writing to an
- * account that is not owned by the program will cause the transaction to fail.
- *
- * Any account whose lamport balance may be mutated by the program during
- * execution must be specified as writable. During execution, mutating the
- * lamports of an account that was not specified as writable will cause the
- * transaction to fail. While _subtracting_ lamports from an account not owned
- * by the program will cause the transaction to fail, _adding_ lamports to any
- * account is allowed, as long is it is mutable.
- *
- * Accounts that are not read or written by the program may still be specified
- * in an `Instruction`'s account list. These will affect scheduling of program
- * execution by the runtime, but will otherwise be ignored.
- *
- * When building a transaction, the Solana runtime coalesces all accounts used
- * by all instructions in that transaction, along with accounts and permissions
- * required by the runtime, into a single account list. Some accounts and
- * account permissions required by the runtime to process a transaction are
- * _not_ required to be included in an `Instruction`s account list. These
- * include:
- *
- * - The program ID — it is a separate field of `Instruction`
- * - The transaction's fee-paying account — it is added during [`Message`]
- *   construction. A program may still require the fee payer as part of the
- *   account list if it directly references it.
- *
- * [`Message`]: crate::message::Message
- *
- * Programs may require signatures from some accounts, in which case they
- * should be specified as signers during `Instruction` construction. The
- * program must still validate during execution that the account is a signer.
+ * wasm-bindgen version of the Instruction struct.
+ * This duplication is required until https://github.com/rustwasm/wasm-bindgen/issues/3671
+ * is fixed. This must not diverge from the regular non-wasm Instruction struct.
  */
 export class Instruction {
 
@@ -700,7 +718,7 @@ const MarketGraphFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_marketgraph_free(ptr >>> 0, 1));
 /**
- * A JS binding for [`MarkegGraph`].
+ * A JS binding for [`MarketGraph`].
  */
 export class MarketGraph {
 
@@ -885,20 +903,9 @@ const MessageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_message_free(ptr >>> 0, 1));
 /**
- * A Solana transaction message (legacy).
- *
- * See the [`message`] module documentation for further description.
- *
- * [`message`]: crate::message
- *
- * Some constructors accept an optional `payer`, the account responsible for
- * paying the cost of executing a transaction. In most cases, callers should
- * specify the payer explicitly in these constructors. In some cases though,
- * the caller is not _required_ to specify the payer, but is still allowed to:
- * in the `Message` structure, the first account is always the fee-payer, so if
- * the caller has knowledge that the first account of the constructed
- * transaction's `Message` is both a signer and the expected fee-payer, then
- * redundantly specifying the fee-payer is not strictly required.
+ * wasm-bindgen version of the Message struct.
+ * This duplication is required until https://github.com/rustwasm/wasm-bindgen/issues/3671
+ * is fixed. This must not diverge from the regular non-wasm Message struct.
  */
 export class Message {
 
@@ -940,6 +947,105 @@ export class Message {
     }
 }
 
+const PodElGamalPubkeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_podelgamalpubkey_free(ptr >>> 0, 1));
+/**
+ * The `ElGamalPubkey` type as a `Pod`.
+ */
+export class PodElGamalPubkey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PodElGamalPubkey.prototype);
+        obj.__wbg_ptr = ptr;
+        PodElGamalPubkeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PodElGamalPubkeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_podelgamalpubkey_free(ptr, 0);
+    }
+    /**
+     * Create a new `PodElGamalPubkey` object
+     *
+     * * `value` - optional public key as a base64 encoded string, `Uint8Array`, `[number]`
+     * @param {any} value
+     */
+    constructor(value) {
+        const ret = wasm.podelgamalpubkey_constructor(value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        PodElGamalPubkeyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Return the base64 string representation of the public key
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.podelgamalpubkey_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Checks if two `ElGamalPubkey`s are equal
+     * @param {PodElGamalPubkey} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        _assertClass(other, PodElGamalPubkey);
+        const ret = wasm.podelgamalpubkey_equals(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Return the `Uint8Array` representation of the public key
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.podelgamalpubkey_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @param {ElGamalPubkey} decoded
+     * @returns {PodElGamalPubkey}
+     */
+    static compressed(decoded) {
+        _assertClass(decoded, ElGamalPubkey);
+        const ret = wasm.podelgamalpubkey_compressed(decoded.__wbg_ptr);
+        return PodElGamalPubkey.__wrap(ret);
+    }
+    /**
+     * @returns {ElGamalPubkey}
+     */
+    decompressed() {
+        const ret = wasm.podelgamalpubkey_decompressed(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ElGamalPubkey.__wrap(ret[0]);
+    }
+}
+
 const PositionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_position_free(ptr >>> 0, 1));
@@ -1147,7 +1253,7 @@ export class Pubkey {
      */
     equals(other) {
         _assertClass(other, Pubkey);
-        const ret = wasm.hash_equals(this.__wbg_ptr, other.__wbg_ptr);
+        const ret = wasm.pubkey_equals(this.__wbg_ptr, other.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -1410,26 +1516,9 @@ const TransactionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_transaction_free(ptr >>> 0, 1));
 /**
- * An atomically-committed sequence of instructions.
- *
- * While [`Instruction`]s are the basic unit of computation in Solana,
- * they are submitted by clients in [`Transaction`]s containing one or
- * more instructions, and signed by one or more [`Signer`]s.
- *
- * [`Signer`]: crate::signer::Signer
- *
- * See the [module documentation] for more details about transactions.
- *
- * [module documentation]: self
- *
- * Some constructors accept an optional `payer`, the account responsible for
- * paying the cost of executing a transaction. In most cases, callers should
- * specify the payer explicitly in these constructors. In some cases though,
- * the caller is not _required_ to specify the payer, but is still allowed to:
- * in the [`Message`] structure, the first account is always the fee-payer, so
- * if the caller has knowledge that the first account of the constructed
- * transaction's `Message` is both a signer and the expected fee-payer, then
- * redundantly specifying the fee-payer is not strictly required.
+ * wasm-bindgen version of the Transaction struct.
+ * This duplication is required until https://github.com/rustwasm/wasm-bindgen/issues/3671
+ * is fixed. This must not diverge from the regular non-wasm Transaction struct.
  */
 export class Transaction {
 
@@ -1744,11 +1833,21 @@ export function __wbg_call_672a4d21634d4a24() { return handleError(function (arg
     return ret;
 }, arguments) };
 
+export function __wbg_call_7cccdd69e0791ae2() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+}, arguments) };
+
 export function __wbg_crypto_038798f665f985e2(arg0) {
     const ret = arg0.crypto;
     return ret;
 };
 
+export function __wbg_crypto_574e78ad8b13b65f(arg0) {
+    const ret = arg0.crypto;
+    return ret;
+};
+
 export function __wbg_debug_3cb59063b29f58c1(arg0) {
     console.debug(arg0);
 };
@@ -1788,6 +1887,10 @@ export function __wbg_getRandomValues_7dfe5bd1b67c9ca1(arg0) {
     return ret;
 };
 
+export function __wbg_getRandomValues_b8f5dbd5f3995a9e() { return handleError(function (arg0, arg1) {
+    arg0.getRandomValues(arg1);
+}, arguments) };
+
 export function __wbg_getTime_46267b1c24877e30(arg0) {
     const ret = arg0.getTime();
     return ret;
@@ -1868,6 +1971,11 @@ export function __wbg_log_c222819a41e063d3(arg0) {
     console.log(arg0);
 };
 
+export function __wbg_msCrypto_a61aeb35a24c1329(arg0) {
+    const ret = arg0.msCrypto;
+    return ret;
+};
+
 export function __wbg_msCrypto_ff35fce085fab2a3(arg0) {
     const ret = arg0.msCrypto;
     return ret;
@@ -1898,6 +2006,16 @@ export function __wbg_new_a12002a7f91c75be(arg0) {
     return ret;
 };
 
+export function __wbg_newnoargs_105ed471475aaf50(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+export function __wbg_newwithbyteoffsetandlength_d97e637ebe145a9a(arg0, arg1, arg2) {
+    const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+    return ret;
+};
+
 export function __wbg_newwithlength_a381634e90c276d4(arg0) {
     const ret = new Uint8Array(arg0 >>> 0);
     return ret;
@@ -1918,6 +2036,16 @@ export function __wbg_next_6574e1a8a62d1055() { return handleError(function (arg
     return ret;
 }, arguments) };
 
+export function __wbg_node_905d3e251edff8a2(arg0) {
+    const ret = arg0.node;
+    return ret;
+};
+
+export function __wbg_process_dc0fbacc7c1c06f7(arg0) {
+    const ret = arg0.process;
+    return ret;
+};
+
 export function __wbg_pubkey_new(arg0) {
     const ret = Pubkey.__wrap(arg0);
     return ret;
@@ -1932,11 +2060,20 @@ export function __wbg_randomFillSync_994ac6d9ade7a695(arg0, arg1, arg2) {
     arg0.randomFillSync(getArrayU8FromWasm0(arg1, arg2));
 };
 
+export function __wbg_randomFillSync_ac0988aba3254290() { return handleError(function (arg0, arg1) {
+    arg0.randomFillSync(arg1);
+}, arguments) };
+
 export function __wbg_require_0d6aeaec3c042c88(arg0, arg1, arg2) {
     const ret = arg0.require(getStringFromWasm0(arg1, arg2));
     return ret;
 };
 
+export function __wbg_require_60cc747a6bc5215a() { return handleError(function () {
+    const ret = module.require;
+    return ret;
+}, arguments) };
+
 export function __wbg_self_25aabeb5a7b41685() { return handleError(function () {
     const ret = self.self;
     return ret;
@@ -1962,11 +2099,31 @@ export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
+export function __wbg_static_accessor_GLOBAL_88a902d13a557d07() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+export function __wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
 export function __wbg_static_accessor_MODULE_ef3aa2eb251158a5() {
     const ret = module;
     return ret;
 };
 
+export function __wbg_static_accessor_SELF_37c5d418e4bf5819() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+export function __wbg_static_accessor_WINDOW_5de37043a91a9c40() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
 export function __wbg_subarray_aa9065fa9dc5df96(arg0, arg1, arg2) {
     const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
     return ret;
@@ -1982,6 +2139,11 @@ export function __wbg_values_99f7a68c7f313d66(arg0) {
     return ret;
 };
 
+export function __wbg_versions_c01dfd4722a88165(arg0) {
+    const ret = arg0.versions;
+    return ret;
+};
+
 export function __wbg_warn_4ca3906c248c47c4(arg0) {
     console.warn(arg0);
 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@gmsol-labs/gmsol-sdk",
   "type": "module",
   "description": "GMX-Solana is an extension of GMX on the Solana blockchain.",
-  "version": "0.5.0",
+  "version": "0.7.0-beta.2",
   "license": "SEE LICENSE IN ../../LICENSE",
   "repository": {
     "type": "git",