@gmsol-labs/gmsol-sdk 0.5.0 → 0.6.0

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-06-19]    | [a5b38f3] |
+| [gmsol-treasury]    | [2025-06-19]    | [a5b38f3] |
+| [gmsol-timelock]    | [2025-06-19]    | [a5b38f3] |
+| [gmsol-competition] | [2025-06-19]    | [a5b38f3] |
 
-[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-06-19]: https://github.com/gmsol-labs/gmx-solana-audits/blob/main/GMX_Solana_Audit_Report_June_19_2025_Zenith.pdf
+[a5b38f3]: https://github.com/gmsol-labs/gmx-solana/commit/a5b38f3be9cc1acfe810bb9072e98c5ba8a12fbb
 
 ## 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.6.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/`
@@ -129,8 +133,8 @@ For a working implementation, check out the [gmx-solana-programs][gmx-solana-pro
 ### 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 +146,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

@@ -286,7 +286,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 +359,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 +389,10 @@ export interface UpdateOrderHint {
      * Market token.
      */
     market_token: StringPubkey;
+    /**
+     * Callback.
+     */
+    callback: Callback | undefined;
 }
 
 /**
@@ -457,6 +483,10 @@ export interface CloseOrderHint {
      * `should_unwrap_native_token` flag.
      */
     should_unwrap_native_token: boolean;
+    /**
+     * Callback.
+     */
+    callback: Callback | undefined;
 }
 
 /**
@@ -551,6 +581,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 +661,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 +715,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 — 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 {
   private constructor();
@@ -791,7 +786,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 +847,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 +859,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 +980,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.6.0",
   "license": "SEE LICENSE IN ../../LICENSE",
   "repository": {
     "type": "git",