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

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

@@ -0,0 +1,267 @@
+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 {String} from "../../0x1/ascii/structs";
+import {ID, UID} from "../object/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== Publisher =============================== */
+
+export function isPublisher(type: string): boolean { type = compressSuiType(type); return type === "0x2::package::Publisher"; }
+
+export interface PublisherFields { id: ToField<UID>; package: ToField<String>; moduleName: ToField<String> }
+
+export type PublisherReified = Reified< Publisher, PublisherFields >;
+
+export class Publisher implements StructClass { static readonly $typeName = "0x2::package::Publisher"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Publisher.$typeName;
+
+ readonly $fullTypeName: "0x2::package::Publisher";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly package: ToField<String>; readonly moduleName: ToField<String>
+
+ private constructor(typeArgs: [], fields: PublisherFields, ) { this.$fullTypeName = composeSuiType( Publisher.$typeName, ...typeArgs ) as "0x2::package::Publisher"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.package = fields.package;; this.moduleName = fields.moduleName; }
+
+ static reified( ): PublisherReified { return { typeName: Publisher.$typeName, fullTypeName: composeSuiType( Publisher.$typeName, ...[] ) as "0x2::package::Publisher", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Publisher.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Publisher.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Publisher.fromBcs( data, ), bcs: Publisher.bcs, fromJSONField: (field: any) => Publisher.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Publisher.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Publisher.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Publisher.fetch( client, id, ), new: ( fields: PublisherFields, ) => { return new Publisher( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Publisher.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Publisher>> { return phantom(Publisher.reified( )); } static get p() { return Publisher.phantom() }
+
+ static get bcs() { return bcs.struct("Publisher", {
+
+ id: UID.bcs, package: String.bcs, module_name: String.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Publisher { return Publisher.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), package: decodeFromFields(String.reified(), fields.package), moduleName: decodeFromFields(String.reified(), fields.module_name) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Publisher { if (!isPublisher(item.type)) { throw new Error("not a Publisher type");
+
+ }
+
+ return Publisher.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), package: decodeFromFieldsWithTypes(String.reified(), item.fields.package), moduleName: decodeFromFieldsWithTypes(String.reified(), item.fields.module_name) } ) }
+
+ static fromBcs( data: Uint8Array ): Publisher { return Publisher.fromFields( Publisher.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,package: this.package,moduleName: this.moduleName,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Publisher { return Publisher.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), package: decodeFromJSONField(String.reified(), field.package), moduleName: decodeFromJSONField(String.reified(), field.moduleName) } ) }
+
+ static fromJSON( json: Record<string, any> ): Publisher { if (json.$typeName !== Publisher.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Publisher.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Publisher { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isPublisher(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Publisher object`); } return Publisher.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Publisher> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Publisher object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isPublisher(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Publisher object`); }
+ return Publisher.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== UpgradeCap =============================== */
+
+export function isUpgradeCap(type: string): boolean { type = compressSuiType(type); return type === "0x2::package::UpgradeCap"; }
+
+export interface UpgradeCapFields { id: ToField<UID>; package: ToField<ID>; version: ToField<"u64">; policy: ToField<"u8"> }
+
+export type UpgradeCapReified = Reified< UpgradeCap, UpgradeCapFields >;
+
+export class UpgradeCap implements StructClass { static readonly $typeName = "0x2::package::UpgradeCap"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = UpgradeCap.$typeName;
+
+ readonly $fullTypeName: "0x2::package::UpgradeCap";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly package: ToField<ID>; readonly version: ToField<"u64">; readonly policy: ToField<"u8">
+
+ private constructor(typeArgs: [], fields: UpgradeCapFields, ) { this.$fullTypeName = composeSuiType( UpgradeCap.$typeName, ...typeArgs ) as "0x2::package::UpgradeCap"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.package = fields.package;; this.version = fields.version;; this.policy = fields.policy; }
+
+ static reified( ): UpgradeCapReified { return { typeName: UpgradeCap.$typeName, fullTypeName: composeSuiType( UpgradeCap.$typeName, ...[] ) as "0x2::package::UpgradeCap", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => UpgradeCap.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => UpgradeCap.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => UpgradeCap.fromBcs( data, ), bcs: UpgradeCap.bcs, fromJSONField: (field: any) => UpgradeCap.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => UpgradeCap.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => UpgradeCap.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => UpgradeCap.fetch( client, id, ), new: ( fields: UpgradeCapFields, ) => { return new UpgradeCap( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return UpgradeCap.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<UpgradeCap>> { return phantom(UpgradeCap.reified( )); } static get p() { return UpgradeCap.phantom() }
+
+ static get bcs() { return bcs.struct("UpgradeCap", {
+
+ id: UID.bcs, package: ID.bcs, version: bcs.u64(), policy: bcs.u8()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): UpgradeCap { return UpgradeCap.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), package: decodeFromFields(ID.reified(), fields.package), version: decodeFromFields("u64", fields.version), policy: decodeFromFields("u8", fields.policy) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): UpgradeCap { if (!isUpgradeCap(item.type)) { throw new Error("not a UpgradeCap type");
+
+ }
+
+ return UpgradeCap.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), package: decodeFromFieldsWithTypes(ID.reified(), item.fields.package), version: decodeFromFieldsWithTypes("u64", item.fields.version), policy: decodeFromFieldsWithTypes("u8", item.fields.policy) } ) }
+
+ static fromBcs( data: Uint8Array ): UpgradeCap { return UpgradeCap.fromFields( UpgradeCap.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,package: this.package,version: this.version.toString(),policy: this.policy,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): UpgradeCap { return UpgradeCap.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), package: decodeFromJSONField(ID.reified(), field.package), version: decodeFromJSONField("u64", field.version), policy: decodeFromJSONField("u8", field.policy) } ) }
+
+ static fromJSON( json: Record<string, any> ): UpgradeCap { if (json.$typeName !== UpgradeCap.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return UpgradeCap.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): UpgradeCap { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isUpgradeCap(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a UpgradeCap object`); } return UpgradeCap.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<UpgradeCap> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching UpgradeCap object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isUpgradeCap(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a UpgradeCap object`); }
+ return UpgradeCap.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== UpgradeReceipt =============================== */
+
+export function isUpgradeReceipt(type: string): boolean { type = compressSuiType(type); return type === "0x2::package::UpgradeReceipt"; }
+
+export interface UpgradeReceiptFields { cap: ToField<ID>; package: ToField<ID> }
+
+export type UpgradeReceiptReified = Reified< UpgradeReceipt, UpgradeReceiptFields >;
+
+export class UpgradeReceipt implements StructClass { static readonly $typeName = "0x2::package::UpgradeReceipt"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = UpgradeReceipt.$typeName;
+
+ readonly $fullTypeName: "0x2::package::UpgradeReceipt";
+
+ readonly $typeArgs: [];
+
+ readonly cap: ToField<ID>; readonly package: ToField<ID>
+
+ private constructor(typeArgs: [], fields: UpgradeReceiptFields, ) { this.$fullTypeName = composeSuiType( UpgradeReceipt.$typeName, ...typeArgs ) as "0x2::package::UpgradeReceipt"; this.$typeArgs = typeArgs;
+
+ this.cap = fields.cap;; this.package = fields.package; }
+
+ static reified( ): UpgradeReceiptReified { return { typeName: UpgradeReceipt.$typeName, fullTypeName: composeSuiType( UpgradeReceipt.$typeName, ...[] ) as "0x2::package::UpgradeReceipt", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => UpgradeReceipt.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => UpgradeReceipt.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => UpgradeReceipt.fromBcs( data, ), bcs: UpgradeReceipt.bcs, fromJSONField: (field: any) => UpgradeReceipt.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => UpgradeReceipt.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => UpgradeReceipt.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => UpgradeReceipt.fetch( client, id, ), new: ( fields: UpgradeReceiptFields, ) => { return new UpgradeReceipt( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return UpgradeReceipt.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<UpgradeReceipt>> { return phantom(UpgradeReceipt.reified( )); } static get p() { return UpgradeReceipt.phantom() }
+
+ static get bcs() { return bcs.struct("UpgradeReceipt", {
+
+ cap: ID.bcs, package: ID.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): UpgradeReceipt { return UpgradeReceipt.reified( ).new( { cap: decodeFromFields(ID.reified(), fields.cap), package: decodeFromFields(ID.reified(), fields.package) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): UpgradeReceipt { if (!isUpgradeReceipt(item.type)) { throw new Error("not a UpgradeReceipt type");
+
+ }
+
+ return UpgradeReceipt.reified( ).new( { cap: decodeFromFieldsWithTypes(ID.reified(), item.fields.cap), package: decodeFromFieldsWithTypes(ID.reified(), item.fields.package) } ) }
+
+ static fromBcs( data: Uint8Array ): UpgradeReceipt { return UpgradeReceipt.fromFields( UpgradeReceipt.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ cap: this.cap,package: this.package,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): UpgradeReceipt { return UpgradeReceipt.reified( ).new( { cap: decodeFromJSONField(ID.reified(), field.cap), package: decodeFromJSONField(ID.reified(), field.package) } ) }
+
+ static fromJSON( json: Record<string, any> ): UpgradeReceipt { if (json.$typeName !== UpgradeReceipt.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return UpgradeReceipt.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): UpgradeReceipt { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isUpgradeReceipt(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a UpgradeReceipt object`); } return UpgradeReceipt.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<UpgradeReceipt> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching UpgradeReceipt object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isUpgradeReceipt(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a UpgradeReceipt object`); }
+ return UpgradeReceipt.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== UpgradeTicket =============================== */
+
+export function isUpgradeTicket(type: string): boolean { type = compressSuiType(type); return type === "0x2::package::UpgradeTicket"; }
+
+export interface UpgradeTicketFields { cap: ToField<ID>; package: ToField<ID>; policy: ToField<"u8">; digest: ToField<Vector<"u8">> }
+
+export type UpgradeTicketReified = Reified< UpgradeTicket, UpgradeTicketFields >;
+
+export class UpgradeTicket implements StructClass { static readonly $typeName = "0x2::package::UpgradeTicket"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = UpgradeTicket.$typeName;
+
+ readonly $fullTypeName: "0x2::package::UpgradeTicket";
+
+ readonly $typeArgs: [];
+
+ readonly cap: ToField<ID>; readonly package: ToField<ID>; readonly policy: ToField<"u8">; readonly digest: ToField<Vector<"u8">>
+
+ private constructor(typeArgs: [], fields: UpgradeTicketFields, ) { this.$fullTypeName = composeSuiType( UpgradeTicket.$typeName, ...typeArgs ) as "0x2::package::UpgradeTicket"; this.$typeArgs = typeArgs;
+
+ this.cap = fields.cap;; this.package = fields.package;; this.policy = fields.policy;; this.digest = fields.digest; }
+
+ static reified( ): UpgradeTicketReified { return { typeName: UpgradeTicket.$typeName, fullTypeName: composeSuiType( UpgradeTicket.$typeName, ...[] ) as "0x2::package::UpgradeTicket", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => UpgradeTicket.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => UpgradeTicket.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => UpgradeTicket.fromBcs( data, ), bcs: UpgradeTicket.bcs, fromJSONField: (field: any) => UpgradeTicket.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => UpgradeTicket.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => UpgradeTicket.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => UpgradeTicket.fetch( client, id, ), new: ( fields: UpgradeTicketFields, ) => { return new UpgradeTicket( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return UpgradeTicket.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<UpgradeTicket>> { return phantom(UpgradeTicket.reified( )); } static get p() { return UpgradeTicket.phantom() }
+
+ static get bcs() { return bcs.struct("UpgradeTicket", {
+
+ cap: ID.bcs, package: ID.bcs, policy: bcs.u8(), digest: bcs.vector(bcs.u8())
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): UpgradeTicket { return UpgradeTicket.reified( ).new( { cap: decodeFromFields(ID.reified(), fields.cap), package: decodeFromFields(ID.reified(), fields.package), policy: decodeFromFields("u8", fields.policy), digest: decodeFromFields(reified.vector("u8"), fields.digest) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): UpgradeTicket { if (!isUpgradeTicket(item.type)) { throw new Error("not a UpgradeTicket type");
+
+ }
+
+ return UpgradeTicket.reified( ).new( { cap: decodeFromFieldsWithTypes(ID.reified(), item.fields.cap), package: decodeFromFieldsWithTypes(ID.reified(), item.fields.package), policy: decodeFromFieldsWithTypes("u8", item.fields.policy), digest: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.digest) } ) }
+
+ static fromBcs( data: Uint8Array ): UpgradeTicket { return UpgradeTicket.fromFields( UpgradeTicket.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ cap: this.cap,package: this.package,policy: this.policy,digest: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.digest),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): UpgradeTicket { return UpgradeTicket.reified( ).new( { cap: decodeFromJSONField(ID.reified(), field.cap), package: decodeFromJSONField(ID.reified(), field.package), policy: decodeFromJSONField("u8", field.policy), digest: decodeFromJSONField(reified.vector("u8"), field.digest) } ) }
+
+ static fromJSON( json: Record<string, any> ): UpgradeTicket { if (json.$typeName !== UpgradeTicket.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return UpgradeTicket.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): UpgradeTicket { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isUpgradeTicket(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a UpgradeTicket object`); } return UpgradeTicket.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<UpgradeTicket> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching UpgradeTicket object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isUpgradeTicket(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a UpgradeTicket object`); }
+ return UpgradeTicket.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0x2/priority-queue/structs.ts

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

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

@@ -0,0 +1,202 @@
+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 {UID} from "../object/structs";
+import {Versioned} from "../versioned/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== Random =============================== */
+
+export function isRandom(type: string): boolean { type = compressSuiType(type); return type === "0x2::random::Random"; }
+
+export interface RandomFields { id: ToField<UID>; inner: ToField<Versioned> }
+
+export type RandomReified = Reified< Random, RandomFields >;
+
+export class Random implements StructClass { static readonly $typeName = "0x2::random::Random"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Random.$typeName;
+
+ readonly $fullTypeName: "0x2::random::Random";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly inner: ToField<Versioned>
+
+ private constructor(typeArgs: [], fields: RandomFields, ) { this.$fullTypeName = composeSuiType( Random.$typeName, ...typeArgs ) as "0x2::random::Random"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.inner = fields.inner; }
+
+ static reified( ): RandomReified { return { typeName: Random.$typeName, fullTypeName: composeSuiType( Random.$typeName, ...[] ) as "0x2::random::Random", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Random.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Random.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Random.fromBcs( data, ), bcs: Random.bcs, fromJSONField: (field: any) => Random.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Random.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Random.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Random.fetch( client, id, ), new: ( fields: RandomFields, ) => { return new Random( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Random.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Random>> { return phantom(Random.reified( )); } static get p() { return Random.phantom() }
+
+ static get bcs() { return bcs.struct("Random", {
+
+ id: UID.bcs, inner: Versioned.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Random { return Random.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), inner: decodeFromFields(Versioned.reified(), fields.inner) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Random { if (!isRandom(item.type)) { throw new Error("not a Random type");
+
+ }
+
+ return Random.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), inner: decodeFromFieldsWithTypes(Versioned.reified(), item.fields.inner) } ) }
+
+ static fromBcs( data: Uint8Array ): Random { return Random.fromFields( Random.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,inner: this.inner.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Random { return Random.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), inner: decodeFromJSONField(Versioned.reified(), field.inner) } ) }
+
+ static fromJSON( json: Record<string, any> ): Random { if (json.$typeName !== Random.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Random.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Random { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isRandom(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Random object`); } return Random.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Random> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Random object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isRandom(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Random object`); }
+ return Random.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== RandomGenerator =============================== */
+
+export function isRandomGenerator(type: string): boolean { type = compressSuiType(type); return type === "0x2::random::RandomGenerator"; }
+
+export interface RandomGeneratorFields { seed: ToField<Vector<"u8">>; counter: ToField<"u16">; buffer: ToField<Vector<"u8">> }
+
+export type RandomGeneratorReified = Reified< RandomGenerator, RandomGeneratorFields >;
+
+export class RandomGenerator implements StructClass { static readonly $typeName = "0x2::random::RandomGenerator"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = RandomGenerator.$typeName;
+
+ readonly $fullTypeName: "0x2::random::RandomGenerator";
+
+ readonly $typeArgs: [];
+
+ readonly seed: ToField<Vector<"u8">>; readonly counter: ToField<"u16">; readonly buffer: ToField<Vector<"u8">>
+
+ private constructor(typeArgs: [], fields: RandomGeneratorFields, ) { this.$fullTypeName = composeSuiType( RandomGenerator.$typeName, ...typeArgs ) as "0x2::random::RandomGenerator"; this.$typeArgs = typeArgs;
+
+ this.seed = fields.seed;; this.counter = fields.counter;; this.buffer = fields.buffer; }
+
+ static reified( ): RandomGeneratorReified { return { typeName: RandomGenerator.$typeName, fullTypeName: composeSuiType( RandomGenerator.$typeName, ...[] ) as "0x2::random::RandomGenerator", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => RandomGenerator.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => RandomGenerator.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => RandomGenerator.fromBcs( data, ), bcs: RandomGenerator.bcs, fromJSONField: (field: any) => RandomGenerator.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => RandomGenerator.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => RandomGenerator.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => RandomGenerator.fetch( client, id, ), new: ( fields: RandomGeneratorFields, ) => { return new RandomGenerator( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return RandomGenerator.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<RandomGenerator>> { return phantom(RandomGenerator.reified( )); } static get p() { return RandomGenerator.phantom() }
+
+ static get bcs() { return bcs.struct("RandomGenerator", {
+
+ seed: bcs.vector(bcs.u8()), counter: bcs.u16(), buffer: bcs.vector(bcs.u8())
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): RandomGenerator { return RandomGenerator.reified( ).new( { seed: decodeFromFields(reified.vector("u8"), fields.seed), counter: decodeFromFields("u16", fields.counter), buffer: decodeFromFields(reified.vector("u8"), fields.buffer) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): RandomGenerator { if (!isRandomGenerator(item.type)) { throw new Error("not a RandomGenerator type");
+
+ }
+
+ return RandomGenerator.reified( ).new( { seed: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.seed), counter: decodeFromFieldsWithTypes("u16", item.fields.counter), buffer: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.buffer) } ) }
+
+ static fromBcs( data: Uint8Array ): RandomGenerator { return RandomGenerator.fromFields( RandomGenerator.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ seed: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.seed),counter: this.counter,buffer: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.buffer),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): RandomGenerator { return RandomGenerator.reified( ).new( { seed: decodeFromJSONField(reified.vector("u8"), field.seed), counter: decodeFromJSONField("u16", field.counter), buffer: decodeFromJSONField(reified.vector("u8"), field.buffer) } ) }
+
+ static fromJSON( json: Record<string, any> ): RandomGenerator { if (json.$typeName !== RandomGenerator.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return RandomGenerator.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): RandomGenerator { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isRandomGenerator(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a RandomGenerator object`); } return RandomGenerator.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<RandomGenerator> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching RandomGenerator object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isRandomGenerator(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a RandomGenerator object`); }
+ return RandomGenerator.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== RandomInner =============================== */
+
+export function isRandomInner(type: string): boolean { type = compressSuiType(type); return type === "0x2::random::RandomInner"; }
+
+export interface RandomInnerFields { version: ToField<"u64">; epoch: ToField<"u64">; randomnessRound: ToField<"u64">; randomBytes: ToField<Vector<"u8">> }
+
+export type RandomInnerReified = Reified< RandomInner, RandomInnerFields >;
+
+export class RandomInner implements StructClass { static readonly $typeName = "0x2::random::RandomInner"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = RandomInner.$typeName;
+
+ readonly $fullTypeName: "0x2::random::RandomInner";
+
+ readonly $typeArgs: [];
+
+ readonly version: ToField<"u64">; readonly epoch: ToField<"u64">; readonly randomnessRound: ToField<"u64">; readonly randomBytes: ToField<Vector<"u8">>
+
+ private constructor(typeArgs: [], fields: RandomInnerFields, ) { this.$fullTypeName = composeSuiType( RandomInner.$typeName, ...typeArgs ) as "0x2::random::RandomInner"; this.$typeArgs = typeArgs;
+
+ this.version = fields.version;; this.epoch = fields.epoch;; this.randomnessRound = fields.randomnessRound;; this.randomBytes = fields.randomBytes; }
+
+ static reified( ): RandomInnerReified { return { typeName: RandomInner.$typeName, fullTypeName: composeSuiType( RandomInner.$typeName, ...[] ) as "0x2::random::RandomInner", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => RandomInner.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => RandomInner.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => RandomInner.fromBcs( data, ), bcs: RandomInner.bcs, fromJSONField: (field: any) => RandomInner.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => RandomInner.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => RandomInner.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => RandomInner.fetch( client, id, ), new: ( fields: RandomInnerFields, ) => { return new RandomInner( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return RandomInner.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<RandomInner>> { return phantom(RandomInner.reified( )); } static get p() { return RandomInner.phantom() }
+
+ static get bcs() { return bcs.struct("RandomInner", {
+
+ version: bcs.u64(), epoch: bcs.u64(), randomness_round: bcs.u64(), random_bytes: bcs.vector(bcs.u8())
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): RandomInner { return RandomInner.reified( ).new( { version: decodeFromFields("u64", fields.version), epoch: decodeFromFields("u64", fields.epoch), randomnessRound: decodeFromFields("u64", fields.randomness_round), randomBytes: decodeFromFields(reified.vector("u8"), fields.random_bytes) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): RandomInner { if (!isRandomInner(item.type)) { throw new Error("not a RandomInner type");
+
+ }
+
+ return RandomInner.reified( ).new( { version: decodeFromFieldsWithTypes("u64", item.fields.version), epoch: decodeFromFieldsWithTypes("u64", item.fields.epoch), randomnessRound: decodeFromFieldsWithTypes("u64", item.fields.randomness_round), randomBytes: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.random_bytes) } ) }
+
+ static fromBcs( data: Uint8Array ): RandomInner { return RandomInner.fromFields( RandomInner.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ version: this.version.toString(),epoch: this.epoch.toString(),randomnessRound: this.randomnessRound.toString(),randomBytes: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.randomBytes),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): RandomInner { return RandomInner.reified( ).new( { version: decodeFromJSONField("u64", field.version), epoch: decodeFromJSONField("u64", field.epoch), randomnessRound: decodeFromJSONField("u64", field.randomnessRound), randomBytes: decodeFromJSONField(reified.vector("u8"), field.randomBytes) } ) }
+
+ static fromJSON( json: Record<string, any> ): RandomInner { if (json.$typeName !== RandomInner.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return RandomInner.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): RandomInner { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isRandomInner(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a RandomInner object`); } return RandomInner.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<RandomInner> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching RandomInner object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isRandomInner(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a RandomInner object`); }
+ return RandomInner.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }