@sanctumso/inf1 0.0.1-dev-1

package/README.md

@@ -0,0 +1,117 @@
+# @sanctumso/inf1
+
+Typescript + WASM SDK for Sanctum Infinity program V1.
+
+## Example Usage
+
+```ts
+import {
+  createSolanaRpc,
+  getBase64Encoder,
+  type Address,
+  type IInstruction,
+  type Rpc,
+  type SolanaRpcApi,
+} from "@solana/kit";
+import {
+  accountsToUpdateForTrade,
+  initPks,
+  quoteTradeExactIn,
+  tradeExactInIx,
+  updateForTrade,
+  type AccountMap,
+  type SplPoolAccounts,
+} from "@sanctumso/inf1";
+
+const LAINESOL = "LAinEtNLgpmCP9Rvsf5Hn8W6EhNiKLZQti1xfWMLy6X";
+const WSOL = "So11111111111111111111111111111111111111112";
+const SPL_POOL_ACCOUNTS: SplPoolAccounts = {
+  [LAINESOL]: "2qyEeSAWKfU18AFthrF7JA8z8ZCi1yt76Tqs917vwQTV",
+  // ...populate rest of `spl lst mint: stake pool addr` data
+  // for every single spl lst mint in the INF pool (all 3 spl program deploys)
+};
+
+// If out === INF mint, then below code will work the same,
+// but the quote and instruction will be for AddLiquidity instead of SwapExactIn.
+//
+// If inp === INF mint, then below code will work the same,
+// but the quote and instruction will be for RemoveLiquidity instead of SwapExactIn.
+const SWAP_MINTS = { inp: LAINESOL, out: WSOL };
+
+async function fetchAccountMap(
+  rpc: Rpc<SolanaRpcApi>,
+  accounts: string[]
+): Promise<AccountMap> {
+  const map = new Map<string, Account>();
+  await Promise.all(
+    accounts.map(async (account) => {
+      const accountInfo = await rpc
+        .getAccountInfo(account as Address, {
+          encoding: "base64",
+        })
+        .send();
+      const acc = accountInfo.value!;
+      map.set(account, {
+        data: new Uint8Array(getBase64Encoder().encode(acc.data[0])),
+        owner: acc.owner,
+      });
+    })
+  );
+  return map;
+}
+
+const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");
+
+// init
+const { poolState: poolStateAddr, lstStateList: lstStateListAddr } = initPks();
+const initAccs = await fetchAccountMap(rpc, [poolStateAddr, lstStateListAddr]);
+const inf = init(
+  {
+    poolState: initAccs.get(poolStateAddr)!,
+    lstStateList: initAccs.get(lstStateListAddr)!,
+  },
+  SPL_POOL_ACCOUNTS
+);
+
+// update
+const updateAccs = await fetchAccountMap(
+  rpc,
+  accountsToUpdateForTrade(inf, SWAP_MINTS)
+);
+updateForTrade(inf, SWAP_MINTS, updateAccs);
+
+// quote
+const amt = 1_000_000_000n;
+const quote = quoteTradeExactIn(inf, {
+  amt,
+  mints: SWAP_MINTS,
+});
+
+// create transaction instruction
+
+// user-provided pubkeys
+const signer = ...;
+const inpTokenAcc = ...;
+const outTokenAcc = ...;
+
+const ixUncasted = tradeExactInIx(inf, {
+  amt,
+  limit: quote.out,
+  mints: SWAP_MINTS,
+  signer,
+  tokenAccs: {
+    inp: inpTokenAcc,
+    out: outTokenAcc,
+  },
+});
+// return type is compatible with kit,
+// but needs to be casted explicitly
+const ix = ixUncasted as unknown as IInstruction;
+```
+
+## Build
+
+### Prerequisites
+
+- [`wasm-pack`](https://rustwasm.github.io/wasm-pack/)
+- `make` (optional, you can just run the `wasm-pack` commands manually)

package/index.d.ts

@@ -0,0 +1,124 @@
+/* tslint:disable */
+/* eslint-disable */
+export function tradeExactInIx(inf: Inf, arg1: TradeArgs): Instruction;
+export function tradeExactOutIx(inf: Inf, arg1: TradeArgs): Instruction;
+export function findPoolReservesAta(arg0: Bs58Array): FoundPda;
+export function findProtocolFeeAccumulatorAta(arg0: Bs58Array): FoundPda;
+export function initPks(): InitPks;
+export function init(arg0: InitAccounts, arg1: SplPoolAccounts): Inf;
+/**
+ * Update SPL LSTs auxiliary data to support new SPL LSTs that may have previously not been covered
+ */
+export function updateSplLsts(inf: Inf, arg1: SplPoolAccounts): void;
+export function quoteTradeExactIn(inf: Inf, arg1: QuoteArgs): Quote;
+export function quoteTradeExactOut(arg0: Inf, arg1: QuoteArgs): Quote;
+export function accountsToUpdateForTrade(inf: Inf, arg1: PkPair): Bs58Array[];
+export function updateForTrade(inf: Inf, arg1: PkPair, arg2: AccountMap): void;
+export interface TradeArgs {
+    amt: bigint;
+    limit: bigint;
+    mints: PkPair;
+    signer: B58PK;
+    tokenAccs: PkPair;
+}
+
+export interface AccountMeta {
+    address: B58PK;
+    /**
+     * Represents the role of an account in a transaction:
+     * - Readonly: 0
+     * - Writable: 1
+     * - ReadonlySigner: 2
+     * - WritableSigner: 3
+     */
+    role: 0 | 1 | 2 | 3;
+}
+
+export interface Instruction {
+    data: Uint8Array;
+    accounts: AccountMeta[];
+    programAddress: B58PK;
+}
+
+export type FoundPda = [B58PK, number];
+
+export interface Account {
+    data: Uint8Array;
+    owner: B58PK;
+}
+
+/**
+ * Map of `mint: stake pool account` for spl (all deploys) LSTs.
+ *
+ * This data is required to determine how to properly initialize the corresponding
+ * sol value calculator data since which stake pool account corresponds to which mint
+ * is not available onchain (yet)
+ */
+export type SplPoolAccounts = Map<B58PK, B58PK>;
+
+export type AccountMap = Map<B58PK, Account>;
+
+export type B58PK = Bs58Array;
+
+export interface Pair<T> {
+    inp: T;
+    out: T;
+}
+
+export type PkPair = Pair<B58PK>;
+
+export interface Init<T> {
+    poolState: T;
+    lstStateList: T;
+}
+
+export type InitPks = Init<B58PK>;
+
+export type InitAccounts = Init<Account>;
+
+export type FeeMint = "inp" | "out";
+
+export interface QuoteArgs {
+    amt: bigint;
+    mints: PkPair;
+}
+
+export interface Quote {
+    /**
+     * Amount of input tokens given by the user to the pool,
+     * after fees. This is exactly the amount of tokens that
+     * will leave the user\'s wallet.
+     */
+    inp: bigint;
+    /**
+     * Amount of output tokens returned by the pool to the user,
+     * after fees. This is exactly the amount of tokens that
+     * will enter the user\'s wallet.
+     */
+    out: bigint;
+    /**
+     * The amount of fee accrued to pool LPs,
+     * accumulated in the pool reserves.
+     *
+     * Which mint it is denoted in (whether inp_mint or out_mint)
+     * depends on value of `self.fee_mint`
+     */
+    lpFee: bigint;
+    /**
+     * The amount of fee accrued to the protocol,
+     * to be transferred to the protocol fee accumulator account.
+     *
+     * Which mint it is denoted in (whether inp_mint or out_mint)
+     * depends on value of `self.fee_mint`
+     */
+    protocolFee: bigint;
+    feeMint: FeeMint;
+    mints: PkPair;
+}
+
+export type Bs58Array = string
+
+export class Inf {
+  private constructor();
+  free(): void;
+}

package/index.js

@@ -0,0 +1,632 @@
+
+let imports = {};
+imports['__wbindgen_placeholder__'] = module.exports;
+let wasm;
+const { TextEncoder, TextDecoder } = require(`util`);
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_4.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_4.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+/**
+ * @param {Inf} inf
+ * @param {TradeArgs} arg1
+ * @returns {Instruction}
+ */
+module.exports.tradeExactInIx = function(inf, arg1) {
+    _assertClass(inf, Inf);
+    const ret = wasm.tradeExactInIx(inf.__wbg_ptr, arg1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+};
+
+/**
+ * @param {Inf} inf
+ * @param {TradeArgs} arg1
+ * @returns {Instruction}
+ */
+module.exports.tradeExactOutIx = function(inf, arg1) {
+    _assertClass(inf, Inf);
+    const ret = wasm.tradeExactOutIx(inf.__wbg_ptr, arg1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+};
+
+/**
+ * @param {Bs58Array} arg0
+ * @returns {FoundPda}
+ */
+module.exports.findPoolReservesAta = function(arg0) {
+    const ret = wasm.findPoolReservesAta(arg0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+};
+
+/**
+ * @param {Bs58Array} arg0
+ * @returns {FoundPda}
+ */
+module.exports.findProtocolFeeAccumulatorAta = function(arg0) {
+    const ret = wasm.findProtocolFeeAccumulatorAta(arg0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+};
+
+/**
+ * @returns {InitPks}
+ */
+module.exports.initPks = function() {
+    const ret = wasm.initPks();
+    return ret;
+};
+
+/**
+ * @param {InitAccounts} arg0
+ * @param {SplPoolAccounts} arg1
+ * @returns {Inf}
+ */
+module.exports.init = function(arg0, arg1) {
+    const ret = wasm.init(arg0, arg1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return Inf.__wrap(ret[0]);
+};
+
+/**
+ * Update SPL LSTs auxiliary data to support new SPL LSTs that may have previously not been covered
+ * @param {Inf} inf
+ * @param {SplPoolAccounts} arg1
+ */
+module.exports.updateSplLsts = function(inf, arg1) {
+    _assertClass(inf, Inf);
+    wasm.updateSplLsts(inf.__wbg_ptr, arg1);
+};
+
+/**
+ * @param {Inf} inf
+ * @param {QuoteArgs} arg1
+ * @returns {Quote}
+ */
+module.exports.quoteTradeExactIn = function(inf, arg1) {
+    _assertClass(inf, Inf);
+    const ret = wasm.quoteTradeExactIn(inf.__wbg_ptr, arg1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+};
+
+/**
+ * @param {Inf} arg0
+ * @param {QuoteArgs} arg1
+ * @returns {Quote}
+ */
+module.exports.quoteTradeExactOut = function(arg0, arg1) {
+    _assertClass(arg0, Inf);
+    const ret = wasm.quoteTradeExactOut(arg0.__wbg_ptr, arg1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+};
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_4.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+/**
+ * @param {Inf} inf
+ * @param {PkPair} arg1
+ * @returns {Bs58Array[]}
+ */
+module.exports.accountsToUpdateForTrade = function(inf, arg1) {
+    _assertClass(inf, Inf);
+    const ret = wasm.accountsToUpdateForTrade(inf.__wbg_ptr, arg1);
+    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;
+};
+
+/**
+ * @param {Inf} inf
+ * @param {PkPair} arg1
+ * @param {AccountMap} arg2
+ */
+module.exports.updateForTrade = function(inf, arg1, arg2) {
+    _assertClass(inf, Inf);
+    const ret = wasm.updateForTrade(inf.__wbg_ptr, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+};
+
+const InfFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_inf_free(ptr >>> 0, 1));
+
+class Inf {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Inf.prototype);
+        obj.__wbg_ptr = ptr;
+        InfFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        InfFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_inf_free(ptr, 0);
+    }
+}
+module.exports.Inf = Inf;
+
+module.exports.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+    const ret = String(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+module.exports.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
+    const ret = arg0.buffer;
+    return ret;
+};
+
+module.exports.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_done_769e5ede4b31c67b = function(arg0) {
+    const ret = arg0.done;
+    return ret;
+};
+
+module.exports.__wbg_entries_3265d4158b33e5dc = function(arg0) {
+    const ret = Object.entries(arg0);
+    return ret;
+};
+
+module.exports.__wbg_from_2a5d3e218e67aa85 = function(arg0) {
+    const ret = Array.from(arg0);
+    return ret;
+};
+
+module.exports.__wbg_get_67b2ba62fc30de12 = function() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+};
+
+module.exports.__wbg_getwithrefkey_1dc361bd10053bfe = function(arg0, arg1) {
+    const ret = arg0[arg1];
+    return ret;
+};
+
+module.exports.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof ArrayBuffer;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+module.exports.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+module.exports.__wbg_isArray_a1eab7e0d067391b = function(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+};
+
+module.exports.__wbg_isSafeInteger_343e2beeeece1bb0 = function(arg0) {
+    const ret = Number.isSafeInteger(arg0);
+    return ret;
+};
+
+module.exports.__wbg_iterator_9a24c88df860dc65 = function() {
+    const ret = Symbol.iterator;
+    return ret;
+};
+
+module.exports.__wbg_length_a446193dc22c12f8 = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+};
+
+module.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+};
+
+module.exports.__wbg_new_405e22f390576ce2 = function() {
+    const ret = new Object();
+    return ret;
+};
+
+module.exports.__wbg_new_78feb108b6472713 = function() {
+    const ret = new Array();
+    return ret;
+};
+
+module.exports.__wbg_new_a12002a7f91c75be = function(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+};
+
+module.exports.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
+    const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+    return ret;
+};
+
+module.exports.__wbg_next_25feadfc0913fea9 = function(arg0) {
+    const ret = arg0.next;
+    return ret;
+};
+
+module.exports.__wbg_next_6574e1a8a62d1055 = function() { return handleError(function (arg0) {
+    const ret = arg0.next();
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+};
+
+module.exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+};
+
+module.exports.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
+    arg0.set(arg1, arg2 >>> 0);
+};
+
+module.exports.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) {
+    const ret = arg0.value;
+    return ret;
+};
+
+module.exports.__wbindgen_as_number = function(arg0) {
+    const ret = +arg0;
+    return ret;
+};
+
+module.exports.__wbindgen_bigint_from_u64 = function(arg0) {
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
+};
+
+module.exports.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
+    const v = arg1;
+    const ret = typeof(v) === 'bigint' ? v : undefined;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+};
+
+module.exports.__wbindgen_boolean_get = function(arg0) {
+    const v = arg0;
+    const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+    return ret;
+};
+
+module.exports.__wbindgen_debug_string = function(arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+module.exports.__wbindgen_error_new = function(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+module.exports.__wbindgen_in = function(arg0, arg1) {
+    const ret = arg0 in arg1;
+    return ret;
+};
+
+module.exports.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_export_4;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+
+module.exports.__wbindgen_is_bigint = function(arg0) {
+    const ret = typeof(arg0) === 'bigint';
+    return ret;
+};
+
+module.exports.__wbindgen_is_function = function(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+};
+
+module.exports.__wbindgen_is_object = function(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+module.exports.__wbindgen_is_undefined = function(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+};
+
+module.exports.__wbindgen_jsval_eq = function(arg0, arg1) {
+    const ret = arg0 === arg1;
+    return ret;
+};
+
+module.exports.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
+    const ret = arg0 == arg1;
+    return ret;
+};
+
+module.exports.__wbindgen_memory = function() {
+    const ret = wasm.memory;
+    return ret;
+};
+
+module.exports.__wbindgen_number_get = function(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+};
+
+module.exports.__wbindgen_number_new = function(arg0) {
+    const ret = arg0;
+    return ret;
+};
+
+module.exports.__wbindgen_string_get = function(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+module.exports.__wbindgen_string_new = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+module.exports.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+const path = require('path').join(__dirname, 'index_bg.wasm');
+const bytes = require('fs').readFileSync(path);
+
+const wasmModule = new WebAssembly.Module(bytes);
+const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+wasm = wasmInstance.exports;
+module.exports.__wasm = wasm;
+
+wasm.__wbindgen_start();
+

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@sanctumso/inf1",
+  "version": "0.0.1-dev-1",
+  "license": "Apache-2.0",
+  "files": [
+    "index_bg.wasm",
+    "index.js",
+    "index.d.ts"
+  ],
+  "main": "index.js",
+  "types": "index.d.ts"
+}