@gmsol-labs/gmsol-sdk 0.8.0 → 0.9.0-alpha.0

package/index_bg.js

@@ -287,6 +287,156 @@ export function update_orders(args) {
     return TransactionGroup.__wrap(ret[0]);
 }
 
+/**
+ * @param {CreateDepositParamsJs[]} deposits
+ * @param {CreateDepositOptions} options
+ * @returns {CreateDepositsBuilder}
+ */
+export function create_deposits_builder(deposits, options) {
+    const ptr0 = passArrayJsValueToWasm0(deposits, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_deposits_builder(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return CreateDepositsBuilder.__wrap(ret[0]);
+}
+
+/**
+ * @param {CreateDepositParamsJs[]} deposits
+ * @param {CreateDepositOptions} options
+ * @returns {TransactionGroup}
+ */
+export function create_deposits(deposits, options) {
+    const ptr0 = passArrayJsValueToWasm0(deposits, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_deposits(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return TransactionGroup.__wrap(ret[0]);
+}
+
+/**
+ * @param {CreateWithdrawalParamsJs[]} withdrawals
+ * @param {CreateWithdrawalOptions} options
+ * @returns {CreateWithdrawalsBuilder}
+ */
+export function create_withdrawals_builder(withdrawals, options) {
+    const ptr0 = passArrayJsValueToWasm0(withdrawals, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_withdrawals_builder(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return CreateWithdrawalsBuilder.__wrap(ret[0]);
+}
+
+/**
+ * @param {CreateWithdrawalParamsJs[]} withdrawals
+ * @param {CreateWithdrawalOptions} options
+ * @returns {TransactionGroup}
+ */
+export function create_withdrawals(withdrawals, options) {
+    const ptr0 = passArrayJsValueToWasm0(withdrawals, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_withdrawals(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return TransactionGroup.__wrap(ret[0]);
+}
+
+/**
+ * @param {CreateShiftParamsJs[]} shifts
+ * @param {CreateShiftOptions} options
+ * @returns {CreateShiftsBuilder}
+ */
+export function create_shifts_builder(shifts, options) {
+    const ptr0 = passArrayJsValueToWasm0(shifts, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_shifts_builder(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return CreateShiftsBuilder.__wrap(ret[0]);
+}
+
+/**
+ * @param {CreateShiftParamsJs[]} shifts
+ * @param {CreateShiftOptions} options
+ * @returns {TransactionGroup}
+ */
+export function create_shifts(shifts, options) {
+    const ptr0 = passArrayJsValueToWasm0(shifts, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_shifts(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return TransactionGroup.__wrap(ret[0]);
+}
+
+/**
+ * @param {CreateGlvDepositParamsJs[]} deposits
+ * @param {CreateGlvDepositOptions} options
+ * @returns {CreateGlvDepositsBuilder}
+ */
+export function create_glv_deposits_builder(deposits, options) {
+    const ptr0 = passArrayJsValueToWasm0(deposits, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_glv_deposits_builder(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return CreateGlvDepositsBuilder.__wrap(ret[0]);
+}
+
+/**
+ * @param {CreateGlvDepositParamsJs[]} deposits
+ * @param {CreateGlvDepositOptions} options
+ * @returns {TransactionGroup}
+ */
+export function create_glv_deposits(deposits, options) {
+    const ptr0 = passArrayJsValueToWasm0(deposits, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_glv_deposits(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return TransactionGroup.__wrap(ret[0]);
+}
+
+/**
+ * @param {CreateGlvWithdrawalParamsJs[]} withdrawals
+ * @param {CreateGlvWithdrawalOptions} options
+ * @returns {CreateGlvWithdrawalsBuilder}
+ */
+export function create_glv_withdrawals_builder(withdrawals, options) {
+    const ptr0 = passArrayJsValueToWasm0(withdrawals, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_glv_withdrawals_builder(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return CreateGlvWithdrawalsBuilder.__wrap(ret[0]);
+}
+
+/**
+ * @param {CreateGlvWithdrawalParamsJs[]} withdrawals
+ * @param {CreateGlvWithdrawalOptions} options
+ * @returns {TransactionGroup}
+ */
+export function create_glv_withdrawals(withdrawals, options) {
+    const ptr0 = passArrayJsValueToWasm0(withdrawals, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_glv_withdrawals(ptr0, len0, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return TransactionGroup.__wrap(ret[0]);
+}
+
 /**
  * Apply `factor` to the `value`.
  * @param {bigint} value
@@ -305,6 +455,126 @@ export function solana_program_init() {
     wasm.solana_program_init();
 }
 
+const CreateDepositsBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_createdepositsbuilder_free(ptr >>> 0, 1));
+
+export class CreateDepositsBuilder {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CreateDepositsBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        CreateDepositsBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CreateDepositsBuilderFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_createdepositsbuilder_free(ptr, 0);
+    }
+    /**
+     * @param {TransactionGroupOptions | null} [transaction_group]
+     * @param {BuildTransactionOptions | null} [build]
+     * @returns {TransactionGroup}
+     */
+    build_with_options(transaction_group, build) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.createdepositsbuilder_build_with_options(ptr, isLikeNone(transaction_group) ? 0 : addToExternrefTable0(transaction_group), isLikeNone(build) ? 0 : addToExternrefTable0(build));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TransactionGroup.__wrap(ret[0]);
+    }
+}
+
+const CreateGlvDepositsBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_createglvdepositsbuilder_free(ptr >>> 0, 1));
+
+export class CreateGlvDepositsBuilder {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CreateGlvDepositsBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        CreateGlvDepositsBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CreateGlvDepositsBuilderFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_createglvdepositsbuilder_free(ptr, 0);
+    }
+    /**
+     * @param {TransactionGroupOptions | null} [transaction_group]
+     * @param {BuildTransactionOptions | null} [build]
+     * @returns {TransactionGroup}
+     */
+    build_with_options(transaction_group, build) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.createglvdepositsbuilder_build_with_options(ptr, isLikeNone(transaction_group) ? 0 : addToExternrefTable0(transaction_group), isLikeNone(build) ? 0 : addToExternrefTable0(build));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TransactionGroup.__wrap(ret[0]);
+    }
+}
+
+const CreateGlvWithdrawalsBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_createglvwithdrawalsbuilder_free(ptr >>> 0, 1));
+
+export class CreateGlvWithdrawalsBuilder {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CreateGlvWithdrawalsBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        CreateGlvWithdrawalsBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CreateGlvWithdrawalsBuilderFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_createglvwithdrawalsbuilder_free(ptr, 0);
+    }
+    /**
+     * @param {TransactionGroupOptions | null} [transaction_group]
+     * @param {BuildTransactionOptions | null} [build]
+     * @returns {TransactionGroup}
+     */
+    build_with_options(transaction_group, build) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.createglvwithdrawalsbuilder_build_with_options(ptr, isLikeNone(transaction_group) ? 0 : addToExternrefTable0(transaction_group), isLikeNone(build) ? 0 : addToExternrefTable0(build));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TransactionGroup.__wrap(ret[0]);
+    }
+}
+
 const CreateOrdersBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_createordersbuilder_free(ptr >>> 0, 1));
@@ -359,80 +629,629 @@ export class CreateOrdersBuilder {
     }
 }
 
-const ElGamalKeypairFinalization = (typeof FinalizationRegistry === 'undefined')
+const CreateShiftsBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_createshiftsbuilder_free(ptr >>> 0, 1));
+
+export class CreateShiftsBuilder {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CreateShiftsBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        CreateShiftsBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CreateShiftsBuilderFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_createshiftsbuilder_free(ptr, 0);
+    }
+    /**
+     * @param {TransactionGroupOptions | null} [transaction_group]
+     * @param {BuildTransactionOptions | null} [build]
+     * @returns {TransactionGroup}
+     */
+    build_with_options(transaction_group, build) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.createshiftsbuilder_build_with_options(ptr, isLikeNone(transaction_group) ? 0 : addToExternrefTable0(transaction_group), isLikeNone(build) ? 0 : addToExternrefTable0(build));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TransactionGroup.__wrap(ret[0]);
+    }
+}
+
+const CreateWithdrawalsBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_createwithdrawalsbuilder_free(ptr >>> 0, 1));
+
+export class CreateWithdrawalsBuilder {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CreateWithdrawalsBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        CreateWithdrawalsBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CreateWithdrawalsBuilderFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_createwithdrawalsbuilder_free(ptr, 0);
+    }
+    /**
+     * @param {TransactionGroupOptions | null} [transaction_group]
+     * @param {BuildTransactionOptions | null} [build]
+     * @returns {TransactionGroup}
+     */
+    build_with_options(transaction_group, build) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.createwithdrawalsbuilder_build_with_options(ptr, isLikeNone(transaction_group) ? 0 : addToExternrefTable0(transaction_group), isLikeNone(build) ? 0 : addToExternrefTable0(build));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TransactionGroup.__wrap(ret[0]);
+    }
+}
+
+const DepositSimulationOutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_depositsimulationoutput_free(ptr >>> 0, 1));
+/**
+ * Simulation output for deposit.
+ */
+export class DepositSimulationOutput {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DepositSimulationOutput.prototype);
+        obj.__wbg_ptr = ptr;
+        DepositSimulationOutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DepositSimulationOutputFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_depositsimulationoutput_free(ptr, 0);
+    }
+    /**
+     * Returns the deposit report.
+     * @returns {string}
+     */
+    report() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.depositsimulationoutput_report(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Returns swap reports for the long token path.
+     * @returns {string[]}
+     */
+    long_swaps() {
+        const ret = wasm.depositsimulationoutput_long_swaps(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Returns swap reports for the short token path.
+     * @returns {string[]}
+     */
+    short_swaps() {
+        const ret = wasm.depositsimulationoutput_short_swaps(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+
+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 GlvFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_glv_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`Glv`].
+ */
+export class Glv {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Glv.prototype);
+        obj.__wbg_ptr = ptr;
+        GlvFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GlvFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_glv_free(ptr, 0);
+    }
+    /**
+     * Create from base64 encoded account data with options.
+     * @param {string} data
+     * @param {boolean | null} [no_discriminator]
+     * @returns {Glv}
+     */
+    static decode_from_base64_with_options(data, no_discriminator) {
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.glv_decode_from_base64_with_options(ptr0, len0, isLikeNone(no_discriminator) ? 0xFFFFFF : no_discriminator ? 1 : 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Glv.__wrap(ret[0]);
+    }
+    /**
+     * Create from base64 encoded account data with options.
+     * @param {Uint8Array} data
+     * @param {boolean | null} [no_discriminator]
+     * @returns {Glv}
+     */
+    static decode_with_options(data, no_discriminator) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.glv_decode_with_options(ptr0, len0, isLikeNone(no_discriminator) ? 0xFFFFFF : no_discriminator ? 1 : 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Glv.__wrap(ret[0]);
+    }
+    /**
+     * Convert into [`JsGlvModel`].
+     * @param {bigint} supply
+     * @returns {GlvModel}
+     */
+    to_model(supply) {
+        const ret = wasm.glv_to_model(this.__wbg_ptr, supply, supply >> BigInt(64));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GlvModel.__wrap(ret[0]);
+    }
+    /**
+     * Returns GLV token address.
+     * @returns {string}
+     */
+    glv_token_address() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.glv_glv_token_address(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);
+        }
+    }
+    /**
+     * Returns long token address.
+     * @returns {string}
+     */
+    long_token_address() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.glv_long_token_address(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);
+        }
+    }
+    /**
+     * Returns short token address.
+     * @returns {string}
+     */
+    short_token_address() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.glv_short_token_address(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);
+        }
+    }
+    /**
+     * Create a clone of this market.
+     * @returns {Glv}
+     */
+    clone() {
+        const ret = wasm.glv_clone(this.__wbg_ptr);
+        return Glv.__wrap(ret);
+    }
+}
+
+const GlvDepositSimulationOutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_glvdepositsimulationoutput_free(ptr >>> 0, 1));
+/**
+ * Simulation output for GLV deposit.
+ */
+export class GlvDepositSimulationOutput {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GlvDepositSimulationOutput.prototype);
+        obj.__wbg_ptr = ptr;
+        GlvDepositSimulationOutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GlvDepositSimulationOutputFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_glvdepositsimulationoutput_free(ptr, 0);
+    }
+    /**
+     * Returns the deposit report.
+     * @returns {string | undefined}
+     */
+    deposit_report() {
+        const ret = wasm.glvdepositsimulationoutput_deposit_report(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Returns swap reports for the long token path.
+     * @returns {string[]}
+     */
+    long_swaps() {
+        const ret = wasm.glvdepositsimulationoutput_long_swaps(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Returns swap reports for the short token path.
+     * @returns {string[]}
+     */
+    short_swaps() {
+        const ret = wasm.glvdepositsimulationoutput_short_swaps(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Returns the output GLV token amount.
+     * @returns {bigint}
+     */
+    output_amount() {
+        const ret = wasm.glvdepositsimulationoutput_output_amount(this.__wbg_ptr);
+        return (BigInt.asUintN(64, ret[0]) | (BigInt.asUintN(64, ret[1]) << BigInt(64)));
+    }
+}
+
+const GlvModelFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_elgamalkeypair_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_glvmodel_free(ptr >>> 0, 1));
 /**
- * A (twisted) ElGamal encryption keypair.
- *
- * The instances of the secret key are zeroized on drop.
+ * Wrapper of [`GlvModel`].
  */
-export class ElGamalKeypair {
+export class GlvModel {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(ElGamalKeypair.prototype);
+        const obj = Object.create(GlvModel.prototype);
         obj.__wbg_ptr = ptr;
-        ElGamalKeypairFinalization.register(obj, obj.__wbg_ptr, obj);
+        GlvModelFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ElGamalKeypairFinalization.unregister(this);
+        GlvModelFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_elgamalkeypair_free(ptr, 0);
+        wasm.__wbg_glvmodel_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}
+     * Returns current supply.
+     * @returns {bigint}
      */
-    static new_rand() {
-        const ret = wasm.elgamalkeypair_new_rand();
-        return ElGamalKeypair.__wrap(ret);
+    supply() {
+        const ret = wasm.glvmodel_supply(this.__wbg_ptr);
+        return (BigInt.asUintN(64, ret[0]) | (BigInt.asUintN(64, ret[1]) << BigInt(64)));
     }
     /**
-     * @returns {ElGamalPubkey}
+     * Returns GLV token address.
+     * @returns {string}
      */
-    pubkey_owned() {
-        const ret = wasm.elgamalkeypair_pubkey_owned(this.__wbg_ptr);
-        return ElGamalPubkey.__wrap(ret);
+    glv_token_address() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.glvmodel_glv_token_address(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);
+        }
+    }
+    /**
+     * Returns long token address.
+     * @returns {string}
+     */
+    long_token_address() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.glvmodel_long_token_address(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);
+        }
+    }
+    /**
+     * Returns short token address.
+     * @returns {string}
+     */
+    short_token_address() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.glvmodel_short_token_address(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);
+        }
+    }
+    /**
+     * Create a clone of this market model.
+     * @returns {GlvModel}
+     */
+    clone() {
+        const ret = wasm.glvmodel_clone(this.__wbg_ptr);
+        return GlvModel.__wrap(ret);
     }
 }
 
-const ElGamalPubkeyFinalization = (typeof FinalizationRegistry === 'undefined')
+const GlvWithdrawalSimulationOutputFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_elgamalpubkey_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_glvwithdrawalsimulationoutput_free(ptr >>> 0, 1));
 /**
- * Public key for the ElGamal encryption scheme.
+ * Simulation output for withdrawal.
  */
-export class ElGamalPubkey {
+export class GlvWithdrawalSimulationOutput {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(ElGamalPubkey.prototype);
+        const obj = Object.create(GlvWithdrawalSimulationOutput.prototype);
         obj.__wbg_ptr = ptr;
-        ElGamalPubkeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        GlvWithdrawalSimulationOutputFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ElGamalPubkeyFinalization.unregister(this);
+        GlvWithdrawalSimulationOutputFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_elgamalpubkey_free(ptr, 0);
+        wasm.__wbg_glvwithdrawalsimulationoutput_free(ptr, 0);
+    }
+    /**
+     * Returns the withdraw report.
+     * @returns {string}
+     */
+    withdraw_report() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.glvwithdrawalsimulationoutput_withdraw_report(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Returns swap reports for the long token path.
+     * @returns {string[]}
+     */
+    long_swaps() {
+        const ret = wasm.glvwithdrawalsimulationoutput_long_swaps(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Returns swap reports for the short token path.
+     * @returns {string[]}
+     */
+    short_swaps() {
+        const ret = wasm.glvwithdrawalsimulationoutput_short_swaps(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Returns long token output amount.
+     * @returns {bigint}
+     */
+    long_output_amount() {
+        const ret = wasm.glvwithdrawalsimulationoutput_long_output_amount(this.__wbg_ptr);
+        return (BigInt.asUintN(64, ret[0]) | (BigInt.asUintN(64, ret[1]) << BigInt(64)));
+    }
+    /**
+     * Returns short token output amount.
+     * @returns {bigint}
+     */
+    short_output_amount() {
+        const ret = wasm.glvwithdrawalsimulationoutput_short_output_amount(this.__wbg_ptr);
+        return (BigInt.asUintN(64, ret[0]) | (BigInt.asUintN(64, ret[1]) << BigInt(64)));
     }
 }
 
@@ -1047,6 +1866,14 @@ export class MarketModel {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Returns current supply.
+     * @returns {bigint}
+     */
+    supply() {
+        const ret = wasm.marketmodel_supply(this.__wbg_ptr);
+        return (BigInt.asUintN(64, ret[0]) | (BigInt.asUintN(64, ret[1]) << BigInt(64)));
+    }
     /**
      * Create an empty position model.
      * @param {CreateEmptyPositionArgs} args
@@ -1630,6 +2457,79 @@ export class Pubkey {
     }
 }
 
+const ShiftSimulationOutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_shiftsimulationoutput_free(ptr >>> 0, 1));
+/**
+ * Simulation output for shift.
+ */
+export class ShiftSimulationOutput {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ShiftSimulationOutput.prototype);
+        obj.__wbg_ptr = ptr;
+        ShiftSimulationOutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ShiftSimulationOutputFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_shiftsimulationoutput_free(ptr, 0);
+    }
+    /**
+     * Returns the deposit report.
+     * @returns {string}
+     */
+    deposit_report() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.shiftsimulationoutput_deposit_report(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Returns the withdraw report.
+     * @returns {string}
+     */
+    withdraw_report() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.shiftsimulationoutput_withdraw_report(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+
 const SimulatorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_simulator_free(ptr >>> 0, 1));
@@ -1685,6 +2585,20 @@ export class Simulator {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Get GLV by its GLV token.
+     * @param {string} glv_token
+     * @returns {GlvModel | undefined}
+     */
+    get_glv(glv_token) {
+        const ptr0 = passStringToWasm0(glv_token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.simulator_get_glv(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : GlvModel.__wrap(ret[0]);
+    }
     /**
      * Upsert the prices for the given token.
      * @param {string} token
@@ -1699,6 +2613,18 @@ export class Simulator {
         }
     }
     /**
+     * Upsert a GLV model.
+     * @param {GlvModel} glv
+     */
+    insert_glv(glv) {
+        _assertClass(glv, GlvModel);
+        const ret = wasm.simulator_insert_glv(this.__wbg_ptr, glv.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Simulate an order execution.
      * @param {SimulateOrderArgs} args
      * @param {Position | null} [position]
      * @returns {OrderSimulationOutput}
@@ -1715,6 +2641,66 @@ export class Simulator {
         }
         return OrderSimulationOutput.__wrap(ret[0]);
     }
+    /**
+     * Simulate a deposit execution.
+     * @param {SimulateDepositArgs} args
+     * @returns {DepositSimulationOutput}
+     */
+    simulate_deposit(args) {
+        const ret = wasm.simulator_simulate_deposit(this.__wbg_ptr, args);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DepositSimulationOutput.__wrap(ret[0]);
+    }
+    /**
+     * Simulate a withdrawal execution.
+     * @param {SimulateWithdrawalArgs} args
+     * @returns {WithdrawalSimulationOutput}
+     */
+    simulate_withdrawal(args) {
+        const ret = wasm.simulator_simulate_withdrawal(this.__wbg_ptr, args);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WithdrawalSimulationOutput.__wrap(ret[0]);
+    }
+    /**
+     * Simulate a shift execution.
+     * @param {SimulateShiftArgs} args
+     * @returns {ShiftSimulationOutput}
+     */
+    simulate_shift(args) {
+        const ret = wasm.simulator_simulate_shift(this.__wbg_ptr, args);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ShiftSimulationOutput.__wrap(ret[0]);
+    }
+    /**
+     * Simulate a GLV deposit execution.
+     * @param {SimulateGlvDepositArgs} args
+     * @returns {GlvDepositSimulationOutput}
+     */
+    simulate_glv_deposit(args) {
+        const ret = wasm.simulator_simulate_glv_deposit(this.__wbg_ptr, args);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GlvDepositSimulationOutput.__wrap(ret[0]);
+    }
+    /**
+     * Simulate a GLV withdrawal execution.
+     * @param {SimulateGlvWithdrawalArgs} args
+     * @returns {GlvWithdrawalSimulationOutput}
+     */
+    simulate_glv_withdrawal(args) {
+        const ret = wasm.simulator_simulate_glv_withdrawal(this.__wbg_ptr, args);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GlvWithdrawalSimulationOutput.__wrap(ret[0]);
+    }
     /**
      * Create a clone of this simulator.
      * @returns {Simulator}
@@ -2305,6 +3291,99 @@ export class User {
     }
 }
 
+const WithdrawalSimulationOutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_withdrawalsimulationoutput_free(ptr >>> 0, 1));
+/**
+ * Simulation output for withdrawal.
+ */
+export class WithdrawalSimulationOutput {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WithdrawalSimulationOutput.prototype);
+        obj.__wbg_ptr = ptr;
+        WithdrawalSimulationOutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WithdrawalSimulationOutputFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_withdrawalsimulationoutput_free(ptr, 0);
+    }
+    /**
+     * Returns the withdraw report.
+     * @returns {string}
+     */
+    report() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.withdrawalsimulationoutput_report(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Returns swap reports for the long token path.
+     * @returns {string[]}
+     */
+    long_swaps() {
+        const ret = wasm.withdrawalsimulationoutput_long_swaps(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Returns swap reports for the short token path.
+     * @returns {string[]}
+     */
+    short_swaps() {
+        const ret = wasm.withdrawalsimulationoutput_short_swaps(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Returns long token output amount.
+     * @returns {bigint}
+     */
+    long_output_amount() {
+        const ret = wasm.withdrawalsimulationoutput_long_output_amount(this.__wbg_ptr);
+        return (BigInt.asUintN(64, ret[0]) | (BigInt.asUintN(64, ret[1]) << BigInt(64)));
+    }
+    /**
+     * Returns short token output amount.
+     * @returns {bigint}
+     */
+    short_output_amount() {
+        const ret = wasm.withdrawalsimulationoutput_short_output_amount(this.__wbg_ptr);
+        return (BigInt.asUintN(64, ret[0]) | (BigInt.asUintN(64, ret[1]) << BigInt(64)));
+    }
+}
+
 export function __wbg_String_8f0eb39a4a4c2f66(arg0, arg1) {
     const ret = String(arg1);
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);