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

package/src/_dependencies/source/0x2/sui/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";
+
+/* ============================== SUI =============================== */
+
+export function isSUI(type: string): boolean { type = compressSuiType(type); return type === "0x2::sui::SUI"; }
+
+export interface SUIFields { dummyField: ToField<"bool"> }
+
+export type SUIReified = Reified< SUI, SUIFields >;
+
+export class SUI implements StructClass { static readonly $typeName = "0x2::sui::SUI"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = SUI.$typeName;
+
+ readonly $fullTypeName: "0x2::sui::SUI";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: SUIFields, ) { this.$fullTypeName = composeSuiType( SUI.$typeName, ...typeArgs ) as "0x2::sui::SUI"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): SUIReified { return { typeName: SUI.$typeName, fullTypeName: composeSuiType( SUI.$typeName, ...[] ) as "0x2::sui::SUI", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => SUI.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => SUI.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => SUI.fromBcs( data, ), bcs: SUI.bcs, fromJSONField: (field: any) => SUI.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => SUI.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => SUI.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => SUI.fetch( client, id, ), new: ( fields: SUIFields, ) => { return new SUI( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return SUI.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<SUI>> { return phantom(SUI.reified( )); } static get p() { return SUI.phantom() }
+
+ static get bcs() { return bcs.struct("SUI", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): SUI { return SUI.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): SUI { if (!isSUI(item.type)) { throw new Error("not a SUI type");
+
+ }
+
+ return SUI.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): SUI { return SUI.fromFields( SUI.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): SUI { return SUI.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): SUI { if (json.$typeName !== SUI.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return SUI.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): SUI { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isSUI(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a SUI object`); } return SUI.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<SUI> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching SUI object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isSUI(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a SUI object`); }
+ return SUI.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0x2/table/structs.ts

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

package/src/_dependencies/source/0x2/table-vec/structs.ts

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