@typus/typus-sdk 1.4.3-c → 1.4.3-e

package/package.json

@@ -2,7 +2,7 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.4.3-c",
+    "version": "1.4.3-e",
     "dependencies": {
         "@mysten/bcs": "^0.11.1",
         "@mysten/kiosk": "0.8.10",
@@ -77,8 +77,16 @@
     },
     "main": "dist/src/index.js",
     "files": [
-        "dist"
+        "dist",
+        "src"
     ],
+    "exports": {
+        ".": {
+            "source": "./src/index.d.ts",
+            "require": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
     "types": "dist/src/index.d.ts",
     "scripts": {
         "ts-node": "ts-node -r tsconfig-paths/register",

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

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,69 @@
+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

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

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,74 @@
+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) ); }
+
+ }

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

@@ -0,0 +1,70 @@
+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";
+
+/* ============================== String =============================== */
+
+export function isString(type: string): boolean { type = compressSuiType(type); return type === "0x1::string::String"; }
+
+export interface StringFields { bytes: ToField<Vector<"u8">> }
+
+export type StringReified = Reified< String, StringFields >;
+
+export class String implements StructClass { static readonly $typeName = "0x1::string::String"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = String.$typeName;
+
+ readonly $fullTypeName: "0x1::string::String";
+
+ readonly $typeArgs: [];
+
+ readonly bytes: ToField<Vector<"u8">>
+
+ private constructor(typeArgs: [], fields: StringFields, ) { this.$fullTypeName = composeSuiType( String.$typeName, ...typeArgs ) as "0x1::string::String"; this.$typeArgs = typeArgs;
+
+ this.bytes = fields.bytes; }
+
+ static reified( ): StringReified { return { typeName: String.$typeName, fullTypeName: composeSuiType( String.$typeName, ...[] ) as "0x1::string::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/type-name/structs.ts

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

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

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

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

@@ -0,0 +1,14 @@
+import * as oracle from "./oracle/structs";
+import * as pythParser from "./pyth-parser/structs";
+import * as supra from "./supra/structs";
+import * as switchboardFeedParser from "./switchboard-feed-parser/structs";
+import {StructClassLoader} from "../../../_framework/loader";
+
+export function registerClasses(loader: StructClassLoader) { loader.register(switchboardFeedParser.AggregatorInfo);
+loader.register(supra.SupraPrice);
+loader.register(pythParser.PythPrice);
+loader.register(pythParser.PythPriceInfoObject);
+loader.register(oracle.ManagerCap);
+loader.register(oracle.Oracle);
+loader.register(oracle.PriceEvent);
+ }