@typus/typus-sdk 1.4.3-f → 1.4.3-g

package/{src/utils/pyth/constant.ts → dist/utils/pyth/constant.js}

@@ -1,5 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpoint = exports.pythStateId = exports.wormholeStateId = exports.priceInfoObjectIds = exports.priceIDs = void 0;
 // You can find the IDs of prices at https://pyth.network/developers/price-feed-ids
-export const priceIDs = {
+exports.priceIDs = {
     MAINNET: {
         // Pyth EVM Stable
         SUI: "0x23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744", // SUI/USD price ID
@@ -25,8 +28,7 @@ export const priceIDs = {
         SCA: "0xeacabc6304d11fc10a757f63286ef44415d8e91b7a1a525ae94a7ec9398b73f3", // SCA/USD price ID
     },
 };
-
-export const priceInfoObjectIds = {
+exports.priceInfoObjectIds = {
     // MAINNET: {
     //     // Pyth EVM Stable
     //     SUI: "0x23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744", // SUI/USD price ID
@@ -51,21 +53,18 @@ export const priceInfoObjectIds = {
         SCA: "0xf96e3c4b7d74efbde9df5b669188421196e6164adf6fbaaa92903c42569807c8",
     },
 };
-
 // Get the state IDs of the Pyth and Wormhole contracts from
 // https://docs.pyth.network/price-feeds/contract-addresses/sui
-export const wormholeStateId = {
+exports.wormholeStateId = {
     MAINNET: "0x5306f64e312b581766351c07af79c72fcb1cd25147157fdc2f8ad76de9a3fb6a",
     TESTNET: "0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790",
 };
-export const pythStateId = {
+exports.pythStateId = {
     MAINNET: "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8",
     TESTNET: "0x243759059f4c3111179da5878c12f68d612c21a8d54d85edc86164bb18be1c7c",
 };
-
 // Get the Stable Hermes service URL from https://docs.pyth.network/price-feeds/api-instances-and-providers/hermes
-
-export const endpoint = {
+exports.endpoint = {
     MAINNET: "https://hermes.pyth.network",
     TESTNET: "https://hermes-beta.pyth.network",
 };

package/dist/utils/pyth/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constant"), exports);
+__exportStar(require("./pythClient"), exports);

package/dist/utils/pyth/pythClient.d.ts

@@ -0,0 +1,12 @@
+import { SuiPriceServiceConnection, SuiPythClient } from "@pythnetwork/pyth-sui-js";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+import { TOKEN } from "../../constants/token";
+import { ObjectId } from "@pythnetwork/pyth-sui-js/lib/client";
+export declare class PythClient {
+    network: "MAINNET" | "TESTNET";
+    client: SuiPythClient;
+    connection: SuiPriceServiceConnection;
+}
+export declare function createPythClient(provider: any, network: "MAINNET" | "TESTNET"): PythClient;
+export declare function updatePyth(pythClient: PythClient, tx: TransactionBlock, tokens: string[]): Promise<ObjectId[]>;
+export declare function updateOracleWithPyth(pythClient: PythClient, tx: TransactionBlock, oraclePackage: string, typusOracle: string, baseToken: TOKEN, quoteToken: TOKEN): void;

package/dist/utils/pyth/pythClient.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPythClient = createPythClient;
+exports.updatePyth = updatePyth;
+exports.updateOracleWithPyth = updateOracleWithPyth;
+var pyth_sui_js_1 = require("@pythnetwork/pyth-sui-js");
+var constant_1 = require("./constant");
+function createPythClient(provider, network) {
+    var client = new pyth_sui_js_1.SuiPythClient(provider, constant_1.pythStateId[network], constant_1.wormholeStateId[network]);
+    var connection = new pyth_sui_js_1.SuiPriceServiceConnection("https://hermes-beta.pyth.network");
+    var pythClient = { network: network, client: client, connection: connection };
+    return pythClient;
+}
+function updatePyth(pythClient, tx, tokens) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _priceIDs, priceFeedUpdateData, priceInfoObjectIds;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _priceIDs = tokens.map(function (token) { return constant_1.priceIDs[pythClient.network][token]; });
+                    return [4 /*yield*/, pythClient.connection.getPriceFeedsUpdateData(_priceIDs)];
+                case 1:
+                    priceFeedUpdateData = _a.sent();
+                    return [4 /*yield*/, pythClient.client.updatePriceFeeds(tx, priceFeedUpdateData, _priceIDs)];
+                case 2:
+                    priceInfoObjectIds = _a.sent();
+                    return [2 /*return*/, priceInfoObjectIds];
+            }
+        });
+    });
+}
+function updateOracleWithPyth(pythClient, tx, oraclePackage, typusOracle, baseToken, quoteToken) {
+    tx.moveCall({
+        target: "".concat(oraclePackage, "::oracle::update_with_pyth"),
+        typeArguments: [],
+        arguments: [
+            tx.object(typusOracle),
+            tx.object(constant_1.pythStateId[pythClient.network]),
+            tx.object(constant_1.priceInfoObjectIds[pythClient.network][baseToken]),
+            tx.object(constant_1.priceInfoObjectIds[pythClient.network][quoteToken]),
+            tx.object("0x6"),
+        ],
+    });
+}

package/dist/utils/tools.d.ts

@@ -0,0 +1,6 @@
+import BigNumber from "bignumber.js";
+export declare function U64FromBytes(x: any): bigint;
+export declare function AddressFromBytes(x: any): string;
+export declare const insertAt: (str: string, sub: string, pos: number) => string;
+export declare const checkNumber: (str: any) => boolean;
+export declare const countFloating: (value: number | BigNumber) => number;

package/dist/utils/tools.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countFloating = exports.checkNumber = exports.insertAt = void 0;
+exports.U64FromBytes = U64FromBytes;
+exports.AddressFromBytes = AddressFromBytes;
+var bignumber_js_1 = __importDefault(require("bignumber.js"));
+function U64FromBytes(x) {
+    var u64 = BigInt(0);
+    for (var i = 0; i < x.length; i++) {
+        u64 = u64 << BigInt(8);
+        u64 += BigInt(x[i]);
+    }
+    return u64;
+}
+function AddressFromBytes(x) {
+    var address = "0x";
+    for (var i = 0; i < x.length; i++) {
+        address = address.concat(x[i].toString(16).padStart(2, "0"));
+    }
+    return address;
+}
+var insertAt = function (str, sub, pos) { return "".concat(str.slice(0, pos)).concat(sub).concat(str.slice(pos)); };
+exports.insertAt = insertAt;
+var checkNumber = function (str) {
+    if (typeof str != "string")
+        return false; // we only process strings!
+    return (
+    // @ts-ignore
+    !isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+        !isNaN(parseFloat(str))); // ...and ensure strings of whitespace fail
+};
+exports.checkNumber = checkNumber;
+var countFloating = function (value) {
+    var num = (0, bignumber_js_1.default)(value).toFixed().replace(/,/g, "");
+    if (value instanceof bignumber_js_1.default) {
+        num = value.toFixed().replace(/,/g, "");
+    }
+    if (!num.includes("."))
+        return 0;
+    return num.split(".")[1].length;
+};
+exports.countFloating = countFloating;

package/package.json

@@ -2,7 +2,7 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.4.3-f",
+    "version": "1.4.3-g",
     "dependencies": {
         "@mysten/bcs": "^0.11.1",
         "@mysten/kiosk": "0.8.10",
@@ -75,10 +75,10 @@
         "tslint-config-prettier": "^1.18.0",
         "typescript": "^5.1.6"
     },
-    "main": "src/index.ts",
-    "types": "src/index.ts",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
     "files": [
-        "src"
+        "dist"
     ],
     "scripts": {
         "ts-node": "ts-node -r tsconfig-paths/register",

package/src/_dependencies/source/0x1/ascii/structs.ts

@@ -1,135 +0,0 @@
-import * as reified from "../../../../_framework/reified";
-import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, Vector, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, fieldToJSON, phantom} from "../../../../_framework/reified";
-import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
-import {bcs, fromB64} from "@mysten/bcs";
-import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
-
-/* ============================== Char =============================== */
-
-export function isChar(type: string): boolean { type = compressSuiType(type); return type === "0x1::ascii::Char"; }
-
-export interface CharFields { byte: ToField<"u8"> }
-
-export type CharReified = Reified< Char, CharFields >;
-
-export class Char implements StructClass { static readonly $typeName = "0x1::ascii::Char"; static readonly $numTypeParams = 0;
-
- readonly $typeName = Char.$typeName;
-
- readonly $fullTypeName: "0x1::ascii::Char";
-
- readonly $typeArgs: [];
-
- readonly byte: ToField<"u8">
-
- private constructor(typeArgs: [], fields: CharFields, ) { this.$fullTypeName = composeSuiType( Char.$typeName, ...typeArgs ) as "0x1::ascii::Char"; this.$typeArgs = typeArgs;
-
- this.byte = fields.byte; }
-
- static reified( ): CharReified { return { typeName: Char.$typeName, fullTypeName: composeSuiType( Char.$typeName, ...[] ) as "0x1::ascii::Char", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Char.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Char.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Char.fromBcs( data, ), bcs: Char.bcs, fromJSONField: (field: any) => Char.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Char.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Char.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Char.fetch( client, id, ), new: ( fields: CharFields, ) => { return new Char( [], fields ) }, kind: "StructClassReified", } }
-
- static get r() { return Char.reified() }
-
- static phantom( ): PhantomReified<ToTypeStr<Char>> { return phantom(Char.reified( )); } static get p() { return Char.phantom() }
-
- static get bcs() { return bcs.struct("Char", {
-
- byte: bcs.u8()
-
-}) };
-
- static fromFields( fields: Record<string, any> ): Char { return Char.reified( ).new( { byte: decodeFromFields("u8", fields.byte) } ) }
-
- static fromFieldsWithTypes( item: FieldsWithTypes ): Char { if (!isChar(item.type)) { throw new Error("not a Char type");
-
- }
-
- return Char.reified( ).new( { byte: decodeFromFieldsWithTypes("u8", item.fields.byte) } ) }
-
- static fromBcs( data: Uint8Array ): Char { return Char.fromFields( Char.bcs.parse(data) ) }
-
- toJSONField() { return {
-
- byte: this.byte,
-
-} }
-
- toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
-
- static fromJSONField( field: any ): Char { return Char.reified( ).new( { byte: decodeFromJSONField("u8", field.byte) } ) }
-
- static fromJSON( json: Record<string, any> ): Char { if (json.$typeName !== Char.$typeName) { throw new Error("not a WithTwoGenerics json object") };
-
- return Char.fromJSONField( json, ) }
-
- static fromSuiParsedData( content: SuiParsedData ): Char { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isChar(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Char object`); } return Char.fromFieldsWithTypes( content ); }
-
- static async fetch( client: SuiClient, id: string ): Promise<Char> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Char object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isChar(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Char object`); }
- return Char.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
-
- }
-
-/* ============================== String =============================== */
-
-export function isString(type: string): boolean { type = compressSuiType(type); return type === "0x1::ascii::String"; }
-
-export interface StringFields { bytes: ToField<Vector<"u8">> }
-
-export type StringReified = Reified< String, StringFields >;
-
-export class String implements StructClass { static readonly $typeName = "0x1::ascii::String"; static readonly $numTypeParams = 0;
-
- readonly $typeName = String.$typeName;
-
- readonly $fullTypeName: "0x1::ascii::String";
-
- readonly $typeArgs: [];
-
- readonly bytes: ToField<Vector<"u8">>
-
- private constructor(typeArgs: [], fields: StringFields, ) { this.$fullTypeName = composeSuiType( String.$typeName, ...typeArgs ) as "0x1::ascii::String"; this.$typeArgs = typeArgs;
-
- this.bytes = fields.bytes; }
-
- static reified( ): StringReified { return { typeName: String.$typeName, fullTypeName: composeSuiType( String.$typeName, ...[] ) as "0x1::ascii::String", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => String.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => String.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => String.fromBcs( data, ), bcs: String.bcs, fromJSONField: (field: any) => String.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => String.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => String.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => String.fetch( client, id, ), new: ( fields: StringFields, ) => { return new String( [], fields ) }, kind: "StructClassReified", } }
-
- static get r() { return String.reified() }
-
- static phantom( ): PhantomReified<ToTypeStr<String>> { return phantom(String.reified( )); } static get p() { return String.phantom() }
-
- static get bcs() { return bcs.struct("String", {
-
- bytes: bcs.vector(bcs.u8())
-
-}) };
-
- static fromFields( fields: Record<string, any> ): String { return String.reified( ).new( { bytes: decodeFromFields(reified.vector("u8"), fields.bytes) } ) }
-
- static fromFieldsWithTypes( item: FieldsWithTypes ): String { if (!isString(item.type)) { throw new Error("not a String type");
-
- }
-
- return String.reified( ).new( { bytes: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.bytes) } ) }
-
- static fromBcs( data: Uint8Array ): String { return String.fromFields( String.bcs.parse(data) ) }
-
- toJSONField() { return {
-
- bytes: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.bytes),
-
-} }
-
- toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
-
- static fromJSONField( field: any ): String { return String.reified( ).new( { bytes: decodeFromJSONField(reified.vector("u8"), field.bytes) } ) }
-
- static fromJSON( json: Record<string, any> ): String { if (json.$typeName !== String.$typeName) { throw new Error("not a WithTwoGenerics json object") };
-
- return String.fromJSONField( json, ) }
-
- static fromSuiParsedData( content: SuiParsedData ): String { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isString(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a String object`); } return String.fromFieldsWithTypes( content ); }
-
- static async fetch( client: SuiClient, id: string ): Promise<String> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching String object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isString(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a String object`); }
- return String.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
-
- }

package/src/_dependencies/source/0x1/bit-vector/structs.ts

@@ -1,70 +0,0 @@
-import * as reified from "../../../../_framework/reified";
-import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, Vector, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, fieldToJSON, phantom} from "../../../../_framework/reified";
-import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
-import {bcs, fromB64} from "@mysten/bcs";
-import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
-
-/* ============================== BitVector =============================== */
-
-export function isBitVector(type: string): boolean { type = compressSuiType(type); return type === "0x1::bit_vector::BitVector"; }
-
-export interface BitVectorFields { length: ToField<"u64">; bitField: ToField<Vector<"bool">> }
-
-export type BitVectorReified = Reified< BitVector, BitVectorFields >;
-
-export class BitVector implements StructClass { static readonly $typeName = "0x1::bit_vector::BitVector"; static readonly $numTypeParams = 0;
-
- readonly $typeName = BitVector.$typeName;
-
- readonly $fullTypeName: "0x1::bit_vector::BitVector";
-
- readonly $typeArgs: [];
-
- readonly length: ToField<"u64">; readonly bitField: ToField<Vector<"bool">>
-
- private constructor(typeArgs: [], fields: BitVectorFields, ) { this.$fullTypeName = composeSuiType( BitVector.$typeName, ...typeArgs ) as "0x1::bit_vector::BitVector"; this.$typeArgs = typeArgs;
-
- this.length = fields.length;; this.bitField = fields.bitField; }
-
- static reified( ): BitVectorReified { return { typeName: BitVector.$typeName, fullTypeName: composeSuiType( BitVector.$typeName, ...[] ) as "0x1::bit_vector::BitVector", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => BitVector.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => BitVector.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => BitVector.fromBcs( data, ), bcs: BitVector.bcs, fromJSONField: (field: any) => BitVector.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => BitVector.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => BitVector.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => BitVector.fetch( client, id, ), new: ( fields: BitVectorFields, ) => { return new BitVector( [], fields ) }, kind: "StructClassReified", } }
-
- static get r() { return BitVector.reified() }
-
- static phantom( ): PhantomReified<ToTypeStr<BitVector>> { return phantom(BitVector.reified( )); } static get p() { return BitVector.phantom() }
-
- static get bcs() { return bcs.struct("BitVector", {
-
- length: bcs.u64(), bit_field: bcs.vector(bcs.bool())
-
-}) };
-
- static fromFields( fields: Record<string, any> ): BitVector { return BitVector.reified( ).new( { length: decodeFromFields("u64", fields.length), bitField: decodeFromFields(reified.vector("bool"), fields.bit_field) } ) }
-
- static fromFieldsWithTypes( item: FieldsWithTypes ): BitVector { if (!isBitVector(item.type)) { throw new Error("not a BitVector type");
-
- }
-
- return BitVector.reified( ).new( { length: decodeFromFieldsWithTypes("u64", item.fields.length), bitField: decodeFromFieldsWithTypes(reified.vector("bool"), item.fields.bit_field) } ) }
-
- static fromBcs( data: Uint8Array ): BitVector { return BitVector.fromFields( BitVector.bcs.parse(data) ) }
-
- toJSONField() { return {
-
- length: this.length.toString(),bitField: fieldToJSON<Vector<"bool">>(`vector<bool>`, this.bitField),
-
-} }
-
- toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
-
- static fromJSONField( field: any ): BitVector { return BitVector.reified( ).new( { length: decodeFromJSONField("u64", field.length), bitField: decodeFromJSONField(reified.vector("bool"), field.bitField) } ) }
-
- static fromJSON( json: Record<string, any> ): BitVector { if (json.$typeName !== BitVector.$typeName) { throw new Error("not a WithTwoGenerics json object") };
-
- return BitVector.fromJSONField( json, ) }
-
- static fromSuiParsedData( content: SuiParsedData ): BitVector { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isBitVector(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a BitVector object`); } return BitVector.fromFieldsWithTypes( content ); }
-
- static async fetch( client: SuiClient, id: string ): Promise<BitVector> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching BitVector object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isBitVector(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a BitVector object`); }
- return BitVector.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
-
- }

package/src/_dependencies/source/0x1/fixed-point32/structs.ts

@@ -1,69 +0,0 @@
-import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom} from "../../../../_framework/reified";
-import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
-import {bcs, fromB64} from "@mysten/bcs";
-import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
-
-/* ============================== FixedPoint32 =============================== */
-
-export function isFixedPoint32(type: string): boolean { type = compressSuiType(type); return type === "0x1::fixed_point32::FixedPoint32"; }
-
-export interface FixedPoint32Fields { value: ToField<"u64"> }
-
-export type FixedPoint32Reified = Reified< FixedPoint32, FixedPoint32Fields >;
-
-export class FixedPoint32 implements StructClass { static readonly $typeName = "0x1::fixed_point32::FixedPoint32"; static readonly $numTypeParams = 0;
-
- readonly $typeName = FixedPoint32.$typeName;
-
- readonly $fullTypeName: "0x1::fixed_point32::FixedPoint32";
-
- readonly $typeArgs: [];
-
- readonly value: ToField<"u64">
-
- private constructor(typeArgs: [], fields: FixedPoint32Fields, ) { this.$fullTypeName = composeSuiType( FixedPoint32.$typeName, ...typeArgs ) as "0x1::fixed_point32::FixedPoint32"; this.$typeArgs = typeArgs;
-
- this.value = fields.value; }
-
- static reified( ): FixedPoint32Reified { return { typeName: FixedPoint32.$typeName, fullTypeName: composeSuiType( FixedPoint32.$typeName, ...[] ) as "0x1::fixed_point32::FixedPoint32", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => FixedPoint32.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => FixedPoint32.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => FixedPoint32.fromBcs( data, ), bcs: FixedPoint32.bcs, fromJSONField: (field: any) => FixedPoint32.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => FixedPoint32.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => FixedPoint32.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => FixedPoint32.fetch( client, id, ), new: ( fields: FixedPoint32Fields, ) => { return new FixedPoint32( [], fields ) }, kind: "StructClassReified", } }
-
- static get r() { return FixedPoint32.reified() }
-
- static phantom( ): PhantomReified<ToTypeStr<FixedPoint32>> { return phantom(FixedPoint32.reified( )); } static get p() { return FixedPoint32.phantom() }
-
- static get bcs() { return bcs.struct("FixedPoint32", {
-
- value: bcs.u64()
-
-}) };
-
- static fromFields( fields: Record<string, any> ): FixedPoint32 { return FixedPoint32.reified( ).new( { value: decodeFromFields("u64", fields.value) } ) }
-
- static fromFieldsWithTypes( item: FieldsWithTypes ): FixedPoint32 { if (!isFixedPoint32(item.type)) { throw new Error("not a FixedPoint32 type");
-
- }
-
- return FixedPoint32.reified( ).new( { value: decodeFromFieldsWithTypes("u64", item.fields.value) } ) }
-
- static fromBcs( data: Uint8Array ): FixedPoint32 { return FixedPoint32.fromFields( FixedPoint32.bcs.parse(data) ) }
-
- toJSONField() { return {
-
- value: this.value.toString(),
-
-} }
-
- toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
-
- static fromJSONField( field: any ): FixedPoint32 { return FixedPoint32.reified( ).new( { value: decodeFromJSONField("u64", field.value) } ) }
-
- static fromJSON( json: Record<string, any> ): FixedPoint32 { if (json.$typeName !== FixedPoint32.$typeName) { throw new Error("not a WithTwoGenerics json object") };
-
- return FixedPoint32.fromJSONField( json, ) }
-
- static fromSuiParsedData( content: SuiParsedData ): FixedPoint32 { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isFixedPoint32(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a FixedPoint32 object`); } return FixedPoint32.fromFieldsWithTypes( content ); }
-
- static async fetch( client: SuiClient, id: string ): Promise<FixedPoint32> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching FixedPoint32 object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isFixedPoint32(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a FixedPoint32 object`); }
- return FixedPoint32.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
-
- }

package/src/_dependencies/source/0x1/index.ts

@@ -1 +0,0 @@
-export const PACKAGE_ID = "0x1"; export const PUBLISHED_AT = "0x1";

package/src/_dependencies/source/0x1/init.ts

@@ -1,16 +0,0 @@
-import * as ascii from "./ascii/structs";
-import * as bitVector from "./bit-vector/structs";
-import * as fixedPoint32 from "./fixed-point32/structs";
-import * as option from "./option/structs";
-import * as string from "./string/structs";
-import * as typeName from "./type-name/structs";
-import {StructClassLoader} from "../../../_framework/loader";
-
-export function registerClasses(loader: StructClassLoader) { loader.register(fixedPoint32.FixedPoint32);
-loader.register(option.Option);
-loader.register(ascii.Char);
-loader.register(ascii.String);
-loader.register(bitVector.BitVector);
-loader.register(string.String);
-loader.register(typeName.TypeName);
- }

package/src/_dependencies/source/0x1/option/structs.ts

@@ -1,74 +0,0 @@
-import * as reified from "../../../../_framework/reified";
-import {PhantomReified, Reified, StructClass, ToField, ToTypeArgument, ToTypeStr, TypeArgument, Vector, assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, toBcs} from "../../../../_framework/reified";
-import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
-import {BcsType, bcs, fromB64} from "@mysten/bcs";
-import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
-
-/* ============================== Option =============================== */
-
-export function isOption(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x1::option::Option<"); }
-
-export interface OptionFields<Element extends TypeArgument> { vec: ToField<Vector<Element>> }
-
-export type OptionReified<Element extends TypeArgument> = Reified< Option<Element>, OptionFields<Element> >;
-
-export class Option<Element extends TypeArgument> implements StructClass { static readonly $typeName = "0x1::option::Option"; static readonly $numTypeParams = 1;
-
- __inner: Element = null as unknown as Element; // for type checking in reified.ts
-
-; readonly $typeName = Option.$typeName;
-
- readonly $fullTypeName: `0x1::option::Option<${ToTypeStr<Element>}>`;
-
- readonly $typeArgs: [ToTypeStr<Element>];
-
- readonly vec: ToField<Vector<Element>>
-
- private constructor(typeArgs: [ToTypeStr<Element>], fields: OptionFields<Element>, ) { this.$fullTypeName = composeSuiType( Option.$typeName, ...typeArgs ) as `0x1::option::Option<${ToTypeStr<Element>}>`; this.$typeArgs = typeArgs;
-
- this.vec = fields.vec; }
-
- static reified<Element extends Reified<TypeArgument, any>>( Element: Element ): OptionReified<ToTypeArgument<Element>> { return { typeName: Option.$typeName, fullTypeName: composeSuiType( Option.$typeName, ...[extractType(Element)] ) as `0x1::option::Option<${ToTypeStr<ToTypeArgument<Element>>}>`, typeArgs: [ extractType(Element) ] as [ToTypeStr<ToTypeArgument<Element>>], reifiedTypeArgs: [Element], fromFields: (fields: Record<string, any>) => Option.fromFields( Element, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Option.fromFieldsWithTypes( Element, item, ), fromBcs: (data: Uint8Array) => Option.fromBcs( Element, data, ), bcs: Option.bcs(toBcs(Element)), fromJSONField: (field: any) => Option.fromJSONField( Element, field, ), fromJSON: (json: Record<string, any>) => Option.fromJSON( Element, json, ), fromSuiParsedData: (content: SuiParsedData) => Option.fromSuiParsedData( Element, content, ), fetch: async (client: SuiClient, id: string) => Option.fetch( client, Element, id, ), new: ( fields: OptionFields<ToTypeArgument<Element>>, ) => { return new Option( [extractType(Element)], fields ) }, kind: "StructClassReified", } }
-
- static get r() { return Option.reified }
-
- static phantom<Element extends Reified<TypeArgument, any>>( Element: Element ): PhantomReified<ToTypeStr<Option<ToTypeArgument<Element>>>> { return phantom(Option.reified( Element )); } static get p() { return Option.phantom }
-
- static get bcs() { return <Element extends BcsType<any>>(Element: Element) => bcs.struct(`Option<${Element.name}>`, {
-
- vec: bcs.vector(Element)
-
-}) };
-
- static fromFields<Element extends Reified<TypeArgument, any>>( typeArg: Element, fields: Record<string, any> ): Option<ToTypeArgument<Element>> { return Option.reified( typeArg, ).new( { vec: decodeFromFields(reified.vector(typeArg), fields.vec) } ) }
-
- static fromFieldsWithTypes<Element extends Reified<TypeArgument, any>>( typeArg: Element, item: FieldsWithTypes ): Option<ToTypeArgument<Element>> { if (!isOption(item.type)) { throw new Error("not a Option type");
-
- } assertFieldsWithTypesArgsMatch(item, [typeArg]);
-
- return Option.reified( typeArg, ).new( { vec: decodeFromFieldsWithTypes(reified.vector(typeArg), item.fields.vec) } ) }
-
- static fromBcs<Element extends Reified<TypeArgument, any>>( typeArg: Element, data: Uint8Array ): Option<ToTypeArgument<Element>> { const typeArgs = [typeArg];
-
- return Option.fromFields( typeArg, Option.bcs( toBcs(typeArgs[0]) ).parse(data) ) }
-
- toJSONField() { return {
-
- vec: fieldToJSON<Vector<Element>>(`vector<${this.$typeArgs[0]}>`, this.vec),
-
-} }
-
- toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
-
- static fromJSONField<Element extends Reified<TypeArgument, any>>( typeArg: Element, field: any ): Option<ToTypeArgument<Element>> { return Option.reified( typeArg, ).new( { vec: decodeFromJSONField(reified.vector(typeArg), field.vec) } ) }
-
- static fromJSON<Element extends Reified<TypeArgument, any>>( typeArg: Element, json: Record<string, any> ): Option<ToTypeArgument<Element>> { if (json.$typeName !== Option.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(Option.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
-
- return Option.fromJSONField( typeArg, json, ) }
-
- static fromSuiParsedData<Element extends Reified<TypeArgument, any>>( typeArg: Element, content: SuiParsedData ): Option<ToTypeArgument<Element>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isOption(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Option object`); } return Option.fromFieldsWithTypes( typeArg, content ); }
-
- static async fetch<Element extends Reified<TypeArgument, any>>( client: SuiClient, typeArg: Element, id: string ): Promise<Option<ToTypeArgument<Element>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Option object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isOption(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Option object`); }
- return Option.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
-
- }