@typus/typus-sdk 1.4.84 → 1.5.0

package/dist/src/{_framework → typus-perp/_framework}/reified.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Vector = void 0;
+exports.vector = void 0;
 exports.phantom = phantom;
-exports.vector = vector;
 exports.toBcs = toBcs;
 exports.extractType = extractType;
 exports.decodeFromFields = decodeFromFields;
@@ -11,20 +10,12 @@ exports.assertReifiedTypeArgsMatch = assertReifiedTypeArgsMatch;
 exports.assertFieldsWithTypesArgsMatch = assertFieldsWithTypesArgsMatch;
 exports.fieldToJSON = fieldToJSON;
 exports.decodeFromJSONField = decodeFromJSONField;
-var bcs_1 = require("@mysten/bcs");
+var bcs_1 = require("@mysten/sui/bcs");
+var utils_1 = require("@mysten/sui/utils");
 var util_1 = require("./util");
-var Vector = /** @class */ (function () {
-    function Vector(fullTypeName, vec) {
-        this.kind = "VectorClass";
-        this.$fullTypeName = fullTypeName;
-        this.vec = vec;
-    }
-    Vector.prototype.toJSONField = function () {
-        return null;
-    };
-    return Vector;
-}());
-exports.Vector = Vector;
+// for backwards compatibility
+var vector_1 = require("./vector");
+Object.defineProperty(exports, "vector", { enumerable: true, get: function () { return vector_1.vector; } });
 function phantom(type) {
     if (typeof type === "string") {
         return {
@@ -39,26 +30,9 @@ function phantom(type) {
         };
     }
 }
-function vector(T) {
-    var fullTypeName = "vector<".concat(extractType(T), ">");
-    return {
-        fullTypeName: fullTypeName,
-        bcs: bcs_1.bcs.vector(toBcs(T)),
-        fromFieldsWithTypes: function (item) {
-            return new Vector(fullTypeName, item.map(function (field) { return decodeFromFieldsWithTypes(T, field); }));
-        },
-        fromFields: function (fields) {
-            return new Vector(fullTypeName, fields.map(function (field) { return decodeFromFields(T, field); }));
-        },
-        fromJSONField: function (field) {
-            return new Vector(fullTypeName, field.map(function (field) { return decodeFromJSONField(T, field); }));
-        },
-        kind: "VectorClassReified",
-    };
-}
 var Address = bcs_1.bcs.bytes(32).transform({
-    input: function (val) { return (0, bcs_1.fromHEX)(val); },
-    output: function (val) { return (0, bcs_1.toHEX)(val); },
+    input: function (val) { return (0, utils_1.fromHEX)(val); },
+    output: function (val) { return (0, utils_1.toHEX)(val); },
 });
 function toBcs(arg) {
     switch (arg) {
@@ -119,7 +93,7 @@ function decodeFromFields(reified, field) {
             return "0x".concat(field);
     }
     if (reified.kind === "VectorClassReified") {
-        return reified.fromFields(field).vec;
+        return reified.fromFields(field).elements;
     }
     switch (reified.typeName) {
         case "0x1::string::String":
@@ -156,7 +130,7 @@ function decodeFromFieldsWithTypes(reified, item) {
             return item;
     }
     if (reified.kind === "VectorClassReified") {
-        return reified.fromFieldsWithTypes(item).vec;
+        return reified.fromFieldsWithTypes(item).elements;
     }
     switch (reified.typeName) {
         case "0x1::string::String":
@@ -242,7 +216,7 @@ function decodeFromJSONField(typeArg, field) {
             return field;
     }
     if (typeArg.kind === "VectorClassReified") {
-        return typeArg.fromJSONField(field).vec;
+        return typeArg.fromJSONField(field).elements;
     }
     switch (typeArg.typeName) {
         case "0x1::string::String":

package/dist/src/typus-perp/_framework/util.d.ts

@@ -0,0 +1,35 @@
+import { Transaction, TransactionArgument, TransactionObjectInput } from "@mysten/sui/transactions";
+export interface FieldsWithTypes {
+    fields: Record<string, any>;
+    type: string;
+}
+export type ObjectId = string;
+export type PureArg = bigint | string | number | boolean | null | TransactionArgument | Array<PureArg>;
+export type GenericArg = TransactionObjectInput | PureArg | Array<TransactionObjectInput> | Array<PureArg> | Array<GenericArg>;
+export declare function splitGenericParameters(str: string, genericSeparators?: [string, string]): string[];
+export declare function parseTypeName(name: string): {
+    typeName: string;
+    typeArgs: string[];
+};
+export declare function isTransactionArgument(arg: GenericArg): arg is TransactionArgument;
+export declare function obj(tx: Transaction, arg: TransactionObjectInput): {
+    GasCoin: true;
+} | {
+    Input: number;
+    type?: "pure" | "object";
+} | {
+    Result: number;
+} | {
+    NestedResult: [number, number];
+} | ((tx: Transaction) => Exclude<import("valibot").InferInput<typeof import("@mysten/sui/transactions").Argument>, {
+    Input: unknown;
+    type?: "pure";
+}>);
+export declare function pure(tx: Transaction, arg: PureArg, type: string): TransactionArgument;
+export declare function option(tx: Transaction, type: string, arg: GenericArg | null): TransactionArgument;
+export declare function generic(tx: Transaction, type: string, arg: GenericArg): TransactionArgument;
+export declare function vector(tx: Transaction, itemType: string, items: Array<GenericArg> | TransactionArgument): TransactionArgument;
+export declare function typeArgIsPure(type: string): boolean;
+export declare function compressSuiAddress(addr: string): string;
+export declare function compressSuiType(type: string): string;
+export declare function composeSuiType(typeName: string, ...typeArgs: string[]): string;

package/dist/src/typus-perp/_framework/util.js

@@ -0,0 +1,396 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitGenericParameters = splitGenericParameters;
+exports.parseTypeName = parseTypeName;
+exports.isTransactionArgument = isTransactionArgument;
+exports.obj = obj;
+exports.pure = pure;
+exports.option = option;
+exports.generic = generic;
+exports.vector = vector;
+exports.typeArgIsPure = typeArgIsPure;
+exports.compressSuiAddress = compressSuiAddress;
+exports.compressSuiType = compressSuiType;
+exports.composeSuiType = composeSuiType;
+var bcs_1 = require("@mysten/sui/bcs");
+function splitGenericParameters(str, genericSeparators) {
+    if (genericSeparators === void 0) { genericSeparators = ["<", ">"]; }
+    var _a = __read(genericSeparators, 2), left = _a[0], right = _a[1];
+    var tok = [];
+    var word = "";
+    var nestedAngleBrackets = 0;
+    for (var i = 0; i < str.length; i++) {
+        var char = str[i];
+        if (char === left) {
+            nestedAngleBrackets++;
+        }
+        if (char === right) {
+            nestedAngleBrackets--;
+        }
+        if (nestedAngleBrackets === 0 && char === ",") {
+            tok.push(word.trim());
+            word = "";
+            continue;
+        }
+        word += char;
+    }
+    tok.push(word.trim());
+    return tok;
+}
+function parseTypeName(name) {
+    if (typeof name !== "string") {
+        throw new Error("Illegal type passed as a name of the type: ".concat(name));
+    }
+    var _a = __read(["<", ">"], 2), left = _a[0], right = _a[1];
+    var l_bound = name.indexOf(left);
+    var r_bound = Array.from(name).reverse().indexOf(right);
+    // if there are no generics - exit gracefully.
+    if (l_bound === -1 && r_bound === -1) {
+        return { typeName: name, typeArgs: [] };
+    }
+    // if one of the bounds is not defined - throw an Error.
+    if (l_bound === -1 || r_bound === -1) {
+        throw new Error("Unclosed generic in name '".concat(name, "'"));
+    }
+    var typeName = name.slice(0, l_bound);
+    var typeArgs = splitGenericParameters(name.slice(l_bound + 1, name.length - r_bound - 1), [left, right]);
+    return { typeName: typeName, typeArgs: typeArgs };
+}
+function isTransactionArgument(arg) {
+    if (!arg || typeof arg !== "object" || Array.isArray(arg)) {
+        return false;
+    }
+    return "GasCoin" in arg || "Input" in arg || "Result" in arg || "NestedResult" in arg;
+}
+function obj(tx, arg) {
+    return isTransactionArgument(arg) ? arg : tx.object(arg);
+}
+function pure(tx, arg, type) {
+    if (isTransactionArgument(arg)) {
+        return obj(tx, arg);
+    }
+    function getBcsForType(type) {
+        var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
+        switch (typeName) {
+            case "bool":
+                return bcs_1.bcs.Bool;
+            case "u8":
+                return bcs_1.bcs.U8;
+            case "u16":
+                return bcs_1.bcs.U16;
+            case "u32":
+                return bcs_1.bcs.U32;
+            case "u64":
+                return bcs_1.bcs.U64;
+            case "u128":
+                return bcs_1.bcs.U128;
+            case "u256":
+                return bcs_1.bcs.U256;
+            case "address":
+                return bcs_1.bcs.Address;
+            case "0x1::string::String":
+            case "0x1::ascii::String":
+                return bcs_1.bcs.String;
+            case "0x2::object::ID":
+                return bcs_1.bcs.Address;
+            case "0x1::option::Option":
+                return bcs_1.bcs.option(getBcsForType(typeArgs[0]));
+            case "vector":
+                return bcs_1.bcs.vector(getBcsForType(typeArgs[0]));
+            default:
+                throw new Error("invalid primitive type ".concat(type));
+        }
+    }
+    function hasUndefinedOrNull(items) {
+        var e_1, _a;
+        try {
+            for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
+                var item = items_1_1.value;
+                if (typeof item === "undefined" || item === null) {
+                    return true;
+                }
+                if (Array.isArray(item)) {
+                    return hasUndefinedOrNull(item);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return false;
+    }
+    function consistsOnlyOfPrimitiveValues(items) {
+        var e_2, _a;
+        try {
+            for (var items_2 = __values(items), items_2_1 = items_2.next(); !items_2_1.done; items_2_1 = items_2.next()) {
+                var item = items_2_1.value;
+                if (!Array.isArray(item)) {
+                    if (item === null) {
+                        continue;
+                    }
+                    switch (typeof item) {
+                        case "string":
+                        case "number":
+                        case "bigint":
+                        case "boolean":
+                            continue;
+                        default:
+                            return false;
+                    }
+                }
+                return consistsOnlyOfPrimitiveValues(item);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (items_2_1 && !items_2_1.done && (_a = items_2.return)) _a.call(items_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return true;
+    }
+    function hasPrimitiveValues(items) {
+        var e_3, _a;
+        try {
+            for (var items_3 = __values(items), items_3_1 = items_3.next(); !items_3_1.done; items_3_1 = items_3.next()) {
+                var item = items_3_1.value;
+                if (!Array.isArray(item)) {
+                    switch (typeof item) {
+                        case "string":
+                        case "number":
+                        case "bigint":
+                        case "boolean":
+                            return true;
+                        default:
+                            continue;
+                    }
+                }
+                return hasPrimitiveValues(item);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (items_3_1 && !items_3_1.done && (_a = items_3.return)) _a.call(items_3);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return false;
+    }
+    // handle some cases when TransactionArgument is nested within a vector or option
+    var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
+    switch (typeName) {
+        case "0x1::option::Option":
+            if (arg === null) {
+                return tx.pure.option("bool", null); // 'bool' is arbitrary
+            }
+            if (consistsOnlyOfPrimitiveValues([arg])) {
+                return tx.pure(getBcsForType(type).serialize(arg));
+            }
+            if (hasPrimitiveValues([arg])) {
+                throw new Error("mixing primitive and TransactionArgument values is not supported");
+            }
+            // wrap it with some
+            return tx.moveCall({
+                target: "0x1::option::some",
+                typeArguments: [typeArgs[0]],
+                arguments: [pure(tx, arg, typeArgs[0])],
+            });
+        case "vector":
+            if (!Array.isArray(arg)) {
+                throw new Error("expected an array for vector type");
+            }
+            if (arg.length === 0) {
+                return tx.pure(bcs_1.bcs.vector(bcs_1.bcs.Bool).serialize([])); // bcs.Bool is arbitrary
+            }
+            if (hasUndefinedOrNull(arg)) {
+                throw new Error("the provided array contains undefined or null values");
+            }
+            if (consistsOnlyOfPrimitiveValues(arg)) {
+                return tx.pure(getBcsForType(type).serialize(arg));
+            }
+            if (hasPrimitiveValues(arg)) {
+                throw new Error("mixing primitive and TransactionArgument values is not supported");
+            }
+            return tx.makeMoveVec({
+                type: typeArgs[0],
+                elements: arg,
+            });
+        default:
+            return tx.pure(getBcsForType(type).serialize(arg));
+    }
+}
+function option(tx, type, arg) {
+    if (isTransactionArgument(arg)) {
+        return arg;
+    }
+    if (typeArgIsPure(type)) {
+        return pure(tx, arg, "0x1::option::Option<".concat(type, ">"));
+    }
+    if (arg === null) {
+        return tx.moveCall({
+            target: "0x1::option::none",
+            typeArguments: [type],
+            arguments: [],
+        });
+    }
+    // wrap it with some
+    var val = generic(tx, type, arg);
+    return tx.moveCall({
+        target: "0x1::option::some",
+        typeArguments: [type],
+        arguments: [val],
+    });
+}
+function generic(tx, type, arg) {
+    if (typeArgIsPure(type)) {
+        return pure(tx, arg, type);
+    }
+    else {
+        var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
+        if (typeName === "vector" && Array.isArray(arg)) {
+            var itemType = typeArgs[0];
+            return tx.makeMoveVec({
+                type: itemType,
+                elements: arg.map(function (item) { return obj(tx, item); }),
+            });
+        }
+        else {
+            return obj(tx, arg);
+        }
+    }
+}
+function vector(tx, itemType, items) {
+    if (typeof items === "function") {
+        throw new Error("Transaction plugins are not supported");
+    }
+    if (typeArgIsPure(itemType)) {
+        return pure(tx, items, "vector<".concat(itemType, ">"));
+    }
+    else if (isTransactionArgument(items)) {
+        return items;
+    }
+    else {
+        var _a = parseTypeName(itemType), itemTypeName = _a.typeName, itemTypeArgs_1 = _a.typeArgs;
+        if (itemTypeName === "0x1::option::Option") {
+            var elements = items.map(function (item) { return option(tx, itemTypeArgs_1[0], item); });
+            return tx.makeMoveVec({
+                type: itemType,
+                elements: elements,
+            });
+        }
+        return tx.makeMoveVec({
+            type: itemType,
+            elements: items,
+        });
+    }
+}
+function typeArgIsPure(type) {
+    var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
+    switch (typeName) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+        case "u64":
+        case "u128":
+        case "u256":
+        case "address":
+        case "signer":
+            return true;
+        case "vector":
+            return typeArgIsPure(typeArgs[0]);
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+        case "0x2::object::ID":
+            return true;
+        case "0x1::option::Option":
+            return typeArgIsPure(typeArgs[0]);
+        default:
+            return false;
+    }
+}
+function compressSuiAddress(addr) {
+    // remove leading zeros
+    var stripped = addr.split("0x").join("");
+    for (var i = 0; i < stripped.length; i++) {
+        if (stripped[i] !== "0") {
+            return "0x".concat(stripped.substring(i));
+        }
+    }
+    return "0x0";
+}
+// Recursively removes leading zeros from a type.
+// e.g. `0x00000002::module::Name<0x00001::a::C>` -> `0x2::module::Name<0x1::a::C>`
+function compressSuiType(type) {
+    var _a = parseTypeName(type), typeName = _a.typeName, typeArgs = _a.typeArgs;
+    switch (typeName) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+        case "u64":
+        case "u128":
+        case "u256":
+        case "address":
+        case "signer":
+            return typeName;
+        case "vector":
+            return "vector<".concat(compressSuiType(typeArgs[0]), ">");
+        default: {
+            var tok = typeName.split("::");
+            tok[0] = compressSuiAddress(tok[0]);
+            var compressedName = tok.join("::");
+            if (typeArgs.length > 0) {
+                return "".concat(compressedName, "<").concat(typeArgs.map(function (typeArg) { return compressSuiType(typeArg); }).join(","), ">");
+            }
+            else {
+                return compressedName;
+            }
+        }
+    }
+}
+function composeSuiType(typeName) {
+    var typeArgs = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        typeArgs[_i - 1] = arguments[_i];
+    }
+    if (typeArgs.length > 0) {
+        return "".concat(typeName, "<").concat(typeArgs.join(", "), ">");
+    }
+    else {
+        return typeName;
+    }
+}

package/dist/src/typus-perp/_framework/vector.d.ts

@@ -0,0 +1,35 @@
+import { Reified, ToField, ToTypeArgument, ToTypeStr, TypeArgument, VectorClass, VectorClassReified } from "./reified";
+import { FieldsWithTypes } from "./util";
+export type VectorElements<T extends TypeArgument> = Array<ToField<T>>;
+export type VectorReified<T extends TypeArgument> = VectorClassReified<Vector<T>, VectorElements<T>>;
+export declare class Vector<T extends TypeArgument> implements VectorClass {
+    __VectorClass: true;
+    static readonly $typeName = "vector";
+    static readonly $numTypeParams = 1;
+    static readonly $isPhantom: readonly [false];
+    readonly $typeName = "vector";
+    readonly $fullTypeName: `vector<${ToTypeStr<T>}>`;
+    readonly $typeArgs: [ToTypeStr<T>];
+    readonly $isPhantom: readonly [false];
+    readonly elements: Array<ToField<T>>;
+    constructor(typeArgs: [ToTypeStr<T>], elements: VectorElements<T>);
+    static reified<T extends Reified<TypeArgument, any>>(T: T): VectorReified<ToTypeArgument<T>>;
+    static get r(): typeof Vector.reified;
+    static get bcs(): <T, Input>(type: import("@mysten/sui/bcs").BcsType<T, Input>, options?: import("@mysten/sui/bcs").BcsTypeOptions<T[], Iterable<Input> & {
+        length: number;
+    }>) => import("@mysten/sui/bcs").BcsType<T[], Iterable<Input> & {
+        length: number;
+    }>;
+    static fromFields<T extends Reified<TypeArgument, any>>(typeArg: T, elements: any[]): Vector<ToTypeArgument<T>>;
+    static fromFieldsWithTypes<T extends Reified<TypeArgument, any>>(typeArg: T, item: FieldsWithTypes): Vector<ToTypeArgument<T>>;
+    static fromBcs<T extends Reified<TypeArgument, any>>(typeArg: T, data: Uint8Array): Vector<ToTypeArgument<T>>;
+    toJSONField(): import("./reified").ToJSON<T>[];
+    toJSON(): {
+        $typeName: string;
+        $typeArgs: [ToTypeStr<T>];
+        elements: import("./reified").ToJSON<T>[];
+    };
+    static fromJSONField<T extends Reified<TypeArgument, any>>(typeArg: T, field: any[]): Vector<ToTypeArgument<T>>;
+    static fromJSON<T extends Reified<TypeArgument, any>>(typeArg: T, json: any): Vector<ToTypeArgument<T>>;
+}
+export declare function vector<T extends Reified<TypeArgument, any>>(T: T): VectorClassReified<Vector<ToTypeArgument<T>>, VectorElements<ToTypeArgument<T>>>;

package/dist/src/typus-perp/_framework/vector.js

@@ -0,0 +1,112 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector = void 0;
+exports.vector = vector;
+var bcs_1 = require("@mysten/sui/bcs");
+var reified_1 = require("./reified");
+var util_1 = require("./util");
+var Vector = /** @class */ (function () {
+    function Vector(typeArgs, elements) {
+        this.__VectorClass = true;
+        this.$typeName = "vector";
+        this.$isPhantom = [false];
+        this.$fullTypeName = util_1.composeSuiType.apply(void 0, __spreadArray([this.$typeName], __read(typeArgs), false));
+        this.$typeArgs = typeArgs;
+        this.elements = elements;
+    }
+    Vector.reified = function (T) {
+        return {
+            typeName: Vector.$typeName,
+            fullTypeName: util_1.composeSuiType.apply(void 0, __spreadArray([Vector.$typeName], [(0, reified_1.extractType)(T)], false)),
+            typeArgs: [(0, reified_1.extractType)(T)],
+            isPhantom: Vector.$isPhantom,
+            reifiedTypeArgs: [T],
+            fromFields: function (elements) { return Vector.fromFields(T, elements); },
+            fromFieldsWithTypes: function (item) { return Vector.fromFieldsWithTypes(T, item); },
+            fromBcs: function (data) { return Vector.fromBcs(T, data); },
+            bcs: Vector.bcs((0, reified_1.toBcs)(T)),
+            fromJSONField: function (field) { return Vector.fromJSONField(T, field); },
+            fromJSON: function (json) { return Vector.fromJSON(T, json); },
+            new: function (elements) {
+                return new Vector([(0, reified_1.extractType)(T)], elements);
+            },
+            kind: "VectorClassReified",
+        };
+    };
+    Object.defineProperty(Vector, "r", {
+        get: function () {
+            return Vector.reified;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Vector, "bcs", {
+        get: function () {
+            return bcs_1.bcs.vector;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Vector.fromFields = function (typeArg, elements) {
+        return Vector.reified(typeArg).new(elements.map(function (element) { return (0, reified_1.decodeFromFields)(typeArg, element); }));
+    };
+    Vector.fromFieldsWithTypes = function (typeArg, item) {
+        return Vector.reified(typeArg).new(item.map(function (field) { return (0, reified_1.decodeFromFieldsWithTypes)(typeArg, field); }));
+    };
+    Vector.fromBcs = function (typeArg, data) {
+        return Vector.fromFields(typeArg, Vector.bcs((0, reified_1.toBcs)(typeArg)).parse(data));
+    };
+    Vector.prototype.toJSONField = function () {
+        var _this = this;
+        return this.elements.map(function (element) { return (0, reified_1.fieldToJSON)(_this.$typeArgs[0], element); });
+    };
+    Vector.prototype.toJSON = function () {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            elements: this.toJSONField(),
+        };
+    };
+    Vector.fromJSONField = function (typeArg, field) {
+        return Vector.reified(typeArg).new(field.map(function (field) { return (0, reified_1.decodeFromJSONField)(typeArg, field); }));
+    };
+    Vector.fromJSON = function (typeArg, json) {
+        if (json.$typeName !== Vector.$typeName) {
+            throw new Error("not a vector json object");
+        }
+        return Vector.fromJSONField(typeArg, json.elements);
+    };
+    Vector.$typeName = "vector";
+    Vector.$numTypeParams = 1;
+    Vector.$isPhantom = [false];
+    return Vector;
+}());
+exports.Vector = Vector;
+function vector(T) {
+    return Vector.r(T);
+}

package/dist/src/typus-perp/fetch.d.ts

@@ -1,8 +1,8 @@
-import { SuiClient } from "@mysten/sui.js/client";
-import { LiquidityPool } from "./lp-pool/structs";
-import { Markets, SymbolMarket } from "./trading/structs";
-import { TradingOrder, Position } from "./position/structs";
-import { LpUserShare, StakePool } from "./stake-pool/structs";
+import { SuiClient } from "@mysten/sui/client";
+import { LiquidityPool } from "./typus_perp/lp-pool/structs";
+import { Markets, SymbolMarket } from "./typus_perp/trading/structs";
+import { TradingOrder, Position } from "./typus_perp/position/structs";
+import { LpUserShare, StakePool } from "./typus_stake_pool/stake-pool/structs";
 import { PythClient, TypusConfig } from "../../src/utils";
 export declare function getLpPools(config: TypusConfig): Promise<LiquidityPool[]>;
 export declare function getStakePools(config: TypusConfig): Promise<StakePool[]>;