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

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

@@ -0,0 +1,135 @@
+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";
+
+/* ============================== Entry =============================== */
+
+export function isEntry(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x2::vec_map::Entry<"); }
+
+export interface EntryFields<K extends TypeArgument, V extends TypeArgument> { key: ToField<K>; value: ToField<V> }
+
+export type EntryReified<K extends TypeArgument, V extends TypeArgument> = Reified< Entry<K, V>, EntryFields<K, V> >;
+
+export class Entry<K extends TypeArgument, V extends TypeArgument> implements StructClass { static readonly $typeName = "0x2::vec_map::Entry"; static readonly $numTypeParams = 2;
+
+ readonly $typeName = Entry.$typeName;
+
+ readonly $fullTypeName: `0x2::vec_map::Entry<${ToTypeStr<K>}, ${ToTypeStr<V>}>`;
+
+ readonly $typeArgs: [ToTypeStr<K>, ToTypeStr<V>];
+
+ readonly key: ToField<K>; readonly value: ToField<V>
+
+ private constructor(typeArgs: [ToTypeStr<K>, ToTypeStr<V>], fields: EntryFields<K, V>, ) { this.$fullTypeName = composeSuiType( Entry.$typeName, ...typeArgs ) as `0x2::vec_map::Entry<${ToTypeStr<K>}, ${ToTypeStr<V>}>`; this.$typeArgs = typeArgs;
+
+ this.key = fields.key;; this.value = fields.value; }
+
+ static reified<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( K: K, V: V ): EntryReified<ToTypeArgument<K>, ToTypeArgument<V>> { return { typeName: Entry.$typeName, fullTypeName: composeSuiType( Entry.$typeName, ...[extractType(K), extractType(V)] ) as `0x2::vec_map::Entry<${ToTypeStr<ToTypeArgument<K>>}, ${ToTypeStr<ToTypeArgument<V>>}>`, typeArgs: [ extractType(K), extractType(V) ] as [ToTypeStr<ToTypeArgument<K>>, ToTypeStr<ToTypeArgument<V>>], reifiedTypeArgs: [K, V], fromFields: (fields: Record<string, any>) => Entry.fromFields( [K, V], fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Entry.fromFieldsWithTypes( [K, V], item, ), fromBcs: (data: Uint8Array) => Entry.fromBcs( [K, V], data, ), bcs: Entry.bcs(toBcs(K), toBcs(V)), fromJSONField: (field: any) => Entry.fromJSONField( [K, V], field, ), fromJSON: (json: Record<string, any>) => Entry.fromJSON( [K, V], json, ), fromSuiParsedData: (content: SuiParsedData) => Entry.fromSuiParsedData( [K, V], content, ), fetch: async (client: SuiClient, id: string) => Entry.fetch( client, [K, V], id, ), new: ( fields: EntryFields<ToTypeArgument<K>, ToTypeArgument<V>>, ) => { return new Entry( [extractType(K), extractType(V)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Entry.reified }
+
+ static phantom<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( K: K, V: V ): PhantomReified<ToTypeStr<Entry<ToTypeArgument<K>, ToTypeArgument<V>>>> { return phantom(Entry.reified( K, V )); } static get p() { return Entry.phantom }
+
+ static get bcs() { return <K extends BcsType<any>, V extends BcsType<any>>(K: K, V: V) => bcs.struct(`Entry<${K.name}, ${V.name}>`, {
+
+ key: K, value: V
+
+}) };
+
+ static fromFields<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], fields: Record<string, any> ): Entry<ToTypeArgument<K>, ToTypeArgument<V>> { return Entry.reified( typeArgs[0], typeArgs[1], ).new( { key: decodeFromFields(typeArgs[0], fields.key), value: decodeFromFields(typeArgs[1], fields.value) } ) }
+
+ static fromFieldsWithTypes<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], item: FieldsWithTypes ): Entry<ToTypeArgument<K>, ToTypeArgument<V>> { if (!isEntry(item.type)) { throw new Error("not a Entry type");
+
+ } assertFieldsWithTypesArgsMatch(item, typeArgs);
+
+ return Entry.reified( typeArgs[0], typeArgs[1], ).new( { key: decodeFromFieldsWithTypes(typeArgs[0], item.fields.key), value: decodeFromFieldsWithTypes(typeArgs[1], item.fields.value) } ) }
+
+ static fromBcs<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], data: Uint8Array ): Entry<ToTypeArgument<K>, ToTypeArgument<V>> { return Entry.fromFields( typeArgs, Entry.bcs( toBcs(typeArgs[0]), toBcs(typeArgs[1]) ).parse(data) ) }
+
+ toJSONField() { return {
+
+ key: fieldToJSON<K>(this.$typeArgs[0], this.key),value: fieldToJSON<V>(this.$typeArgs[1], this.value),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], field: any ): Entry<ToTypeArgument<K>, ToTypeArgument<V>> { return Entry.reified( typeArgs[0], typeArgs[1], ).new( { key: decodeFromJSONField(typeArgs[0], field.key), value: decodeFromJSONField(typeArgs[1], field.value) } ) }
+
+ static fromJSON<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], json: Record<string, any> ): Entry<ToTypeArgument<K>, ToTypeArgument<V>> { if (json.$typeName !== Entry.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(Entry.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs, )
+
+ return Entry.fromJSONField( typeArgs, json, ) }
+
+ static fromSuiParsedData<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], content: SuiParsedData ): Entry<ToTypeArgument<K>, ToTypeArgument<V>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isEntry(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Entry object`); } return Entry.fromFieldsWithTypes( typeArgs, content ); }
+
+ static async fetch<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( client: SuiClient, typeArgs: [K, V], id: string ): Promise<Entry<ToTypeArgument<K>, ToTypeArgument<V>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Entry object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isEntry(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Entry object`); }
+ return Entry.fromBcs( typeArgs, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== VecMap =============================== */
+
+export function isVecMap(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x2::vec_map::VecMap<"); }
+
+export interface VecMapFields<K extends TypeArgument, V extends TypeArgument> { contents: ToField<Vector<Entry<K, V>>> }
+
+export type VecMapReified<K extends TypeArgument, V extends TypeArgument> = Reified< VecMap<K, V>, VecMapFields<K, V> >;
+
+export class VecMap<K extends TypeArgument, V extends TypeArgument> implements StructClass { static readonly $typeName = "0x2::vec_map::VecMap"; static readonly $numTypeParams = 2;
+
+ readonly $typeName = VecMap.$typeName;
+
+ readonly $fullTypeName: `0x2::vec_map::VecMap<${ToTypeStr<K>}, ${ToTypeStr<V>}>`;
+
+ readonly $typeArgs: [ToTypeStr<K>, ToTypeStr<V>];
+
+ readonly contents: ToField<Vector<Entry<K, V>>>
+
+ private constructor(typeArgs: [ToTypeStr<K>, ToTypeStr<V>], fields: VecMapFields<K, V>, ) { this.$fullTypeName = composeSuiType( VecMap.$typeName, ...typeArgs ) as `0x2::vec_map::VecMap<${ToTypeStr<K>}, ${ToTypeStr<V>}>`; this.$typeArgs = typeArgs;
+
+ this.contents = fields.contents; }
+
+ static reified<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( K: K, V: V ): VecMapReified<ToTypeArgument<K>, ToTypeArgument<V>> { return { typeName: VecMap.$typeName, fullTypeName: composeSuiType( VecMap.$typeName, ...[extractType(K), extractType(V)] ) as `0x2::vec_map::VecMap<${ToTypeStr<ToTypeArgument<K>>}, ${ToTypeStr<ToTypeArgument<V>>}>`, typeArgs: [ extractType(K), extractType(V) ] as [ToTypeStr<ToTypeArgument<K>>, ToTypeStr<ToTypeArgument<V>>], reifiedTypeArgs: [K, V], fromFields: (fields: Record<string, any>) => VecMap.fromFields( [K, V], fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => VecMap.fromFieldsWithTypes( [K, V], item, ), fromBcs: (data: Uint8Array) => VecMap.fromBcs( [K, V], data, ), bcs: VecMap.bcs(toBcs(K), toBcs(V)), fromJSONField: (field: any) => VecMap.fromJSONField( [K, V], field, ), fromJSON: (json: Record<string, any>) => VecMap.fromJSON( [K, V], json, ), fromSuiParsedData: (content: SuiParsedData) => VecMap.fromSuiParsedData( [K, V], content, ), fetch: async (client: SuiClient, id: string) => VecMap.fetch( client, [K, V], id, ), new: ( fields: VecMapFields<ToTypeArgument<K>, ToTypeArgument<V>>, ) => { return new VecMap( [extractType(K), extractType(V)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return VecMap.reified }
+
+ static phantom<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( K: K, V: V ): PhantomReified<ToTypeStr<VecMap<ToTypeArgument<K>, ToTypeArgument<V>>>> { return phantom(VecMap.reified( K, V )); } static get p() { return VecMap.phantom }
+
+ static get bcs() { return <K extends BcsType<any>, V extends BcsType<any>>(K: K, V: V) => bcs.struct(`VecMap<${K.name}, ${V.name}>`, {
+
+ contents: bcs.vector(Entry.bcs(K, V))
+
+}) };
+
+ static fromFields<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], fields: Record<string, any> ): VecMap<ToTypeArgument<K>, ToTypeArgument<V>> { return VecMap.reified( typeArgs[0], typeArgs[1], ).new( { contents: decodeFromFields(reified.vector(Entry.reified(typeArgs[0], typeArgs[1])), fields.contents) } ) }
+
+ static fromFieldsWithTypes<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], item: FieldsWithTypes ): VecMap<ToTypeArgument<K>, ToTypeArgument<V>> { if (!isVecMap(item.type)) { throw new Error("not a VecMap type");
+
+ } assertFieldsWithTypesArgsMatch(item, typeArgs);
+
+ return VecMap.reified( typeArgs[0], typeArgs[1], ).new( { contents: decodeFromFieldsWithTypes(reified.vector(Entry.reified(typeArgs[0], typeArgs[1])), item.fields.contents) } ) }
+
+ static fromBcs<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], data: Uint8Array ): VecMap<ToTypeArgument<K>, ToTypeArgument<V>> { return VecMap.fromFields( typeArgs, VecMap.bcs( toBcs(typeArgs[0]), toBcs(typeArgs[1]) ).parse(data) ) }
+
+ toJSONField() { return {
+
+ contents: fieldToJSON<Vector<Entry<K, V>>>(`vector<0x2::vec_map::Entry<${this.$typeArgs[0]}, ${this.$typeArgs[1]}>>`, this.contents),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], field: any ): VecMap<ToTypeArgument<K>, ToTypeArgument<V>> { return VecMap.reified( typeArgs[0], typeArgs[1], ).new( { contents: decodeFromJSONField(reified.vector(Entry.reified(typeArgs[0], typeArgs[1])), field.contents) } ) }
+
+ static fromJSON<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], json: Record<string, any> ): VecMap<ToTypeArgument<K>, ToTypeArgument<V>> { if (json.$typeName !== VecMap.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(VecMap.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs, )
+
+ return VecMap.fromJSONField( typeArgs, json, ) }
+
+ static fromSuiParsedData<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( typeArgs: [K, V], content: SuiParsedData ): VecMap<ToTypeArgument<K>, ToTypeArgument<V>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isVecMap(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a VecMap object`); } return VecMap.fromFieldsWithTypes( typeArgs, content ); }
+
+ static async fetch<K extends Reified<TypeArgument, any>, V extends Reified<TypeArgument, any>>( client: SuiClient, typeArgs: [K, V], id: string ): Promise<VecMap<ToTypeArgument<K>, ToTypeArgument<V>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching VecMap object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isVecMap(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a VecMap object`); }
+ return VecMap.fromBcs( typeArgs, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

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

@@ -0,0 +1,72 @@
+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";
+
+/* ============================== VecSet =============================== */
+
+export function isVecSet(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x2::vec_set::VecSet<"); }
+
+export interface VecSetFields<K extends TypeArgument> { contents: ToField<Vector<K>> }
+
+export type VecSetReified<K extends TypeArgument> = Reified< VecSet<K>, VecSetFields<K> >;
+
+export class VecSet<K extends TypeArgument> implements StructClass { static readonly $typeName = "0x2::vec_set::VecSet"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = VecSet.$typeName;
+
+ readonly $fullTypeName: `0x2::vec_set::VecSet<${ToTypeStr<K>}>`;
+
+ readonly $typeArgs: [ToTypeStr<K>];
+
+ readonly contents: ToField<Vector<K>>
+
+ private constructor(typeArgs: [ToTypeStr<K>], fields: VecSetFields<K>, ) { this.$fullTypeName = composeSuiType( VecSet.$typeName, ...typeArgs ) as `0x2::vec_set::VecSet<${ToTypeStr<K>}>`; this.$typeArgs = typeArgs;
+
+ this.contents = fields.contents; }
+
+ static reified<K extends Reified<TypeArgument, any>>( K: K ): VecSetReified<ToTypeArgument<K>> { return { typeName: VecSet.$typeName, fullTypeName: composeSuiType( VecSet.$typeName, ...[extractType(K)] ) as `0x2::vec_set::VecSet<${ToTypeStr<ToTypeArgument<K>>}>`, typeArgs: [ extractType(K) ] as [ToTypeStr<ToTypeArgument<K>>], reifiedTypeArgs: [K], fromFields: (fields: Record<string, any>) => VecSet.fromFields( K, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => VecSet.fromFieldsWithTypes( K, item, ), fromBcs: (data: Uint8Array) => VecSet.fromBcs( K, data, ), bcs: VecSet.bcs(toBcs(K)), fromJSONField: (field: any) => VecSet.fromJSONField( K, field, ), fromJSON: (json: Record<string, any>) => VecSet.fromJSON( K, json, ), fromSuiParsedData: (content: SuiParsedData) => VecSet.fromSuiParsedData( K, content, ), fetch: async (client: SuiClient, id: string) => VecSet.fetch( client, K, id, ), new: ( fields: VecSetFields<ToTypeArgument<K>>, ) => { return new VecSet( [extractType(K)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return VecSet.reified }
+
+ static phantom<K extends Reified<TypeArgument, any>>( K: K ): PhantomReified<ToTypeStr<VecSet<ToTypeArgument<K>>>> { return phantom(VecSet.reified( K )); } static get p() { return VecSet.phantom }
+
+ static get bcs() { return <K extends BcsType<any>>(K: K) => bcs.struct(`VecSet<${K.name}>`, {
+
+ contents: bcs.vector(K)
+
+}) };
+
+ static fromFields<K extends Reified<TypeArgument, any>>( typeArg: K, fields: Record<string, any> ): VecSet<ToTypeArgument<K>> { return VecSet.reified( typeArg, ).new( { contents: decodeFromFields(reified.vector(typeArg), fields.contents) } ) }
+
+ static fromFieldsWithTypes<K extends Reified<TypeArgument, any>>( typeArg: K, item: FieldsWithTypes ): VecSet<ToTypeArgument<K>> { if (!isVecSet(item.type)) { throw new Error("not a VecSet type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return VecSet.reified( typeArg, ).new( { contents: decodeFromFieldsWithTypes(reified.vector(typeArg), item.fields.contents) } ) }
+
+ static fromBcs<K extends Reified<TypeArgument, any>>( typeArg: K, data: Uint8Array ): VecSet<ToTypeArgument<K>> { const typeArgs = [typeArg];
+
+ return VecSet.fromFields( typeArg, VecSet.bcs( toBcs(typeArgs[0]) ).parse(data) ) }
+
+ toJSONField() { return {
+
+ contents: fieldToJSON<Vector<K>>(`vector<${this.$typeArgs[0]}>`, this.contents),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<K extends Reified<TypeArgument, any>>( typeArg: K, field: any ): VecSet<ToTypeArgument<K>> { return VecSet.reified( typeArg, ).new( { contents: decodeFromJSONField(reified.vector(typeArg), field.contents) } ) }
+
+ static fromJSON<K extends Reified<TypeArgument, any>>( typeArg: K, json: Record<string, any> ): VecSet<ToTypeArgument<K>> { if (json.$typeName !== VecSet.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(VecSet.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return VecSet.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<K extends Reified<TypeArgument, any>>( typeArg: K, content: SuiParsedData ): VecSet<ToTypeArgument<K>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isVecSet(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a VecSet object`); } return VecSet.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<K extends Reified<TypeArgument, any>>( client: SuiClient, typeArg: K, id: string ): Promise<VecSet<ToTypeArgument<K>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching VecSet object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isVecSet(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a VecSet object`); }
+ return VecSet.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

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

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

package/src/_dependencies/source/0x2/zklogin-verified-id/structs.ts

@@ -0,0 +1,71 @@
+import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {String} from "../../0x1/string/structs";
+import {UID} from "../object/structs";
+import {bcs, fromB64, fromHEX, toHEX} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== VerifiedID =============================== */
+
+export function isVerifiedID(type: string): boolean { type = compressSuiType(type); return type === "0x2::zklogin_verified_id::VerifiedID"; }
+
+export interface VerifiedIDFields { id: ToField<UID>; owner: ToField<"address">; keyClaimName: ToField<String>; keyClaimValue: ToField<String>; issuer: ToField<String>; audience: ToField<String> }
+
+export type VerifiedIDReified = Reified< VerifiedID, VerifiedIDFields >;
+
+export class VerifiedID implements StructClass { static readonly $typeName = "0x2::zklogin_verified_id::VerifiedID"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = VerifiedID.$typeName;
+
+ readonly $fullTypeName: "0x2::zklogin_verified_id::VerifiedID";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly owner: ToField<"address">; readonly keyClaimName: ToField<String>; readonly keyClaimValue: ToField<String>; readonly issuer: ToField<String>; readonly audience: ToField<String>
+
+ private constructor(typeArgs: [], fields: VerifiedIDFields, ) { this.$fullTypeName = composeSuiType( VerifiedID.$typeName, ...typeArgs ) as "0x2::zklogin_verified_id::VerifiedID"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.owner = fields.owner;; this.keyClaimName = fields.keyClaimName;; this.keyClaimValue = fields.keyClaimValue;; this.issuer = fields.issuer;; this.audience = fields.audience; }
+
+ static reified( ): VerifiedIDReified { return { typeName: VerifiedID.$typeName, fullTypeName: composeSuiType( VerifiedID.$typeName, ...[] ) as "0x2::zklogin_verified_id::VerifiedID", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => VerifiedID.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => VerifiedID.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => VerifiedID.fromBcs( data, ), bcs: VerifiedID.bcs, fromJSONField: (field: any) => VerifiedID.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => VerifiedID.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => VerifiedID.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => VerifiedID.fetch( client, id, ), new: ( fields: VerifiedIDFields, ) => { return new VerifiedID( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return VerifiedID.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<VerifiedID>> { return phantom(VerifiedID.reified( )); } static get p() { return VerifiedID.phantom() }
+
+ static get bcs() { return bcs.struct("VerifiedID", {
+
+ id: UID.bcs, owner: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), key_claim_name: String.bcs, key_claim_value: String.bcs, issuer: String.bcs, audience: String.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): VerifiedID { return VerifiedID.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), owner: decodeFromFields("address", fields.owner), keyClaimName: decodeFromFields(String.reified(), fields.key_claim_name), keyClaimValue: decodeFromFields(String.reified(), fields.key_claim_value), issuer: decodeFromFields(String.reified(), fields.issuer), audience: decodeFromFields(String.reified(), fields.audience) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): VerifiedID { if (!isVerifiedID(item.type)) { throw new Error("not a VerifiedID type");
+
+ }
+
+ return VerifiedID.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), owner: decodeFromFieldsWithTypes("address", item.fields.owner), keyClaimName: decodeFromFieldsWithTypes(String.reified(), item.fields.key_claim_name), keyClaimValue: decodeFromFieldsWithTypes(String.reified(), item.fields.key_claim_value), issuer: decodeFromFieldsWithTypes(String.reified(), item.fields.issuer), audience: decodeFromFieldsWithTypes(String.reified(), item.fields.audience) } ) }
+
+ static fromBcs( data: Uint8Array ): VerifiedID { return VerifiedID.fromFields( VerifiedID.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,owner: this.owner,keyClaimName: this.keyClaimName,keyClaimValue: this.keyClaimValue,issuer: this.issuer,audience: this.audience,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): VerifiedID { return VerifiedID.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), owner: decodeFromJSONField("address", field.owner), keyClaimName: decodeFromJSONField(String.reified(), field.keyClaimName), keyClaimValue: decodeFromJSONField(String.reified(), field.keyClaimValue), issuer: decodeFromJSONField(String.reified(), field.issuer), audience: decodeFromJSONField(String.reified(), field.audience) } ) }
+
+ static fromJSON( json: Record<string, any> ): VerifiedID { if (json.$typeName !== VerifiedID.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return VerifiedID.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): VerifiedID { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isVerifiedID(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a VerifiedID object`); } return VerifiedID.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<VerifiedID> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching VerifiedID object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isVerifiedID(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a VerifiedID object`); }
+ return VerifiedID.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0x2/zklogin-verified-issuer/structs.ts

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

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

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

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

@@ -0,0 +1,5 @@
+import * as validator from "./validator/structs";
+import {StructClassLoader} from "../../../_framework/loader";
+
+export function registerClasses(loader: StructClassLoader) { loader.register(validator.DkgState);
+ }

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

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

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

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

@@ -0,0 +1,8 @@
+import * as priceDataPull from "./price-data-pull/structs";
+import * as supraSValueFeed from "./suprasvaluefeed/structs";
+import {StructClassLoader} from "../../../_framework/loader";
+
+export function registerClasses(loader: StructClassLoader) { loader.register(supraSValueFeed.Price);
+loader.register(supraSValueFeed.OracleHolder);
+loader.register(priceDataPull.PriceData);
+ }