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

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/package-utils/structs.ts

@@ -0,0 +1,266 @@
+import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {ID} from "../../0x2/object/structs";
+import {Bytes32} from "../bytes32/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== CurrentVersion =============================== */
+
+export function isCurrentVersion(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::CurrentVersion"; }
+
+export interface CurrentVersionFields { dummyField: ToField<"bool"> }
+
+export type CurrentVersionReified = Reified< CurrentVersion, CurrentVersionFields >;
+
+export class CurrentVersion implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::CurrentVersion"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = CurrentVersion.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::CurrentVersion";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: CurrentVersionFields, ) { this.$fullTypeName = composeSuiType( CurrentVersion.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::CurrentVersion"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): CurrentVersionReified { return { typeName: CurrentVersion.$typeName, fullTypeName: composeSuiType( CurrentVersion.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::CurrentVersion", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => CurrentVersion.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => CurrentVersion.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => CurrentVersion.fromBcs( data, ), bcs: CurrentVersion.bcs, fromJSONField: (field: any) => CurrentVersion.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => CurrentVersion.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => CurrentVersion.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => CurrentVersion.fetch( client, id, ), new: ( fields: CurrentVersionFields, ) => { return new CurrentVersion( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return CurrentVersion.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<CurrentVersion>> { return phantom(CurrentVersion.reified( )); } static get p() { return CurrentVersion.phantom() }
+
+ static get bcs() { return bcs.struct("CurrentVersion", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): CurrentVersion { return CurrentVersion.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): CurrentVersion { if (!isCurrentVersion(item.type)) { throw new Error("not a CurrentVersion type");
+
+ }
+
+ return CurrentVersion.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): CurrentVersion { return CurrentVersion.fromFields( CurrentVersion.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): CurrentVersion { return CurrentVersion.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): CurrentVersion { if (json.$typeName !== CurrentVersion.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return CurrentVersion.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): CurrentVersion { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isCurrentVersion(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a CurrentVersion object`); } return CurrentVersion.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<CurrentVersion> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching CurrentVersion object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isCurrentVersion(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a CurrentVersion object`); }
+ return CurrentVersion.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== CurrentPackage =============================== */
+
+export function isCurrentPackage(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::CurrentPackage"; }
+
+export interface CurrentPackageFields { dummyField: ToField<"bool"> }
+
+export type CurrentPackageReified = Reified< CurrentPackage, CurrentPackageFields >;
+
+export class CurrentPackage implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::CurrentPackage"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = CurrentPackage.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::CurrentPackage";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: CurrentPackageFields, ) { this.$fullTypeName = composeSuiType( CurrentPackage.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::CurrentPackage"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): CurrentPackageReified { return { typeName: CurrentPackage.$typeName, fullTypeName: composeSuiType( CurrentPackage.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::CurrentPackage", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => CurrentPackage.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => CurrentPackage.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => CurrentPackage.fromBcs( data, ), bcs: CurrentPackage.bcs, fromJSONField: (field: any) => CurrentPackage.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => CurrentPackage.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => CurrentPackage.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => CurrentPackage.fetch( client, id, ), new: ( fields: CurrentPackageFields, ) => { return new CurrentPackage( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return CurrentPackage.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<CurrentPackage>> { return phantom(CurrentPackage.reified( )); } static get p() { return CurrentPackage.phantom() }
+
+ static get bcs() { return bcs.struct("CurrentPackage", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): CurrentPackage { return CurrentPackage.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): CurrentPackage { if (!isCurrentPackage(item.type)) { throw new Error("not a CurrentPackage type");
+
+ }
+
+ return CurrentPackage.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): CurrentPackage { return CurrentPackage.fromFields( CurrentPackage.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): CurrentPackage { return CurrentPackage.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): CurrentPackage { if (json.$typeName !== CurrentPackage.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return CurrentPackage.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): CurrentPackage { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isCurrentPackage(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a CurrentPackage object`); } return CurrentPackage.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<CurrentPackage> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching CurrentPackage object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isCurrentPackage(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a CurrentPackage object`); }
+ return CurrentPackage.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== PackageInfo =============================== */
+
+export function isPackageInfo(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::PackageInfo"; }
+
+export interface PackageInfoFields { package: ToField<ID>; digest: ToField<Bytes32> }
+
+export type PackageInfoReified = Reified< PackageInfo, PackageInfoFields >;
+
+export class PackageInfo implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::PackageInfo"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = PackageInfo.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::PackageInfo";
+
+ readonly $typeArgs: [];
+
+ readonly package: ToField<ID>; readonly digest: ToField<Bytes32>
+
+ private constructor(typeArgs: [], fields: PackageInfoFields, ) { this.$fullTypeName = composeSuiType( PackageInfo.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::PackageInfo"; this.$typeArgs = typeArgs;
+
+ this.package = fields.package;; this.digest = fields.digest; }
+
+ static reified( ): PackageInfoReified { return { typeName: PackageInfo.$typeName, fullTypeName: composeSuiType( PackageInfo.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::PackageInfo", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => PackageInfo.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => PackageInfo.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => PackageInfo.fromBcs( data, ), bcs: PackageInfo.bcs, fromJSONField: (field: any) => PackageInfo.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => PackageInfo.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => PackageInfo.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => PackageInfo.fetch( client, id, ), new: ( fields: PackageInfoFields, ) => { return new PackageInfo( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return PackageInfo.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<PackageInfo>> { return phantom(PackageInfo.reified( )); } static get p() { return PackageInfo.phantom() }
+
+ static get bcs() { return bcs.struct("PackageInfo", {
+
+ package: ID.bcs, digest: Bytes32.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): PackageInfo { return PackageInfo.reified( ).new( { package: decodeFromFields(ID.reified(), fields.package), digest: decodeFromFields(Bytes32.reified(), fields.digest) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): PackageInfo { if (!isPackageInfo(item.type)) { throw new Error("not a PackageInfo type");
+
+ }
+
+ return PackageInfo.reified( ).new( { package: decodeFromFieldsWithTypes(ID.reified(), item.fields.package), digest: decodeFromFieldsWithTypes(Bytes32.reified(), item.fields.digest) } ) }
+
+ static fromBcs( data: Uint8Array ): PackageInfo { return PackageInfo.fromFields( PackageInfo.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ package: this.package,digest: this.digest.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): PackageInfo { return PackageInfo.reified( ).new( { package: decodeFromJSONField(ID.reified(), field.package), digest: decodeFromJSONField(Bytes32.reified(), field.digest) } ) }
+
+ static fromJSON( json: Record<string, any> ): PackageInfo { if (json.$typeName !== PackageInfo.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return PackageInfo.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): PackageInfo { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isPackageInfo(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a PackageInfo object`); } return PackageInfo.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<PackageInfo> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching PackageInfo object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isPackageInfo(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a PackageInfo object`); }
+ return PackageInfo.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== PendingPackage =============================== */
+
+export function isPendingPackage(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::PendingPackage"; }
+
+export interface PendingPackageFields { dummyField: ToField<"bool"> }
+
+export type PendingPackageReified = Reified< PendingPackage, PendingPackageFields >;
+
+export class PendingPackage implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::PendingPackage"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = PendingPackage.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::PendingPackage";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: PendingPackageFields, ) { this.$fullTypeName = composeSuiType( PendingPackage.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::PendingPackage"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): PendingPackageReified { return { typeName: PendingPackage.$typeName, fullTypeName: composeSuiType( PendingPackage.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::package_utils::PendingPackage", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => PendingPackage.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => PendingPackage.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => PendingPackage.fromBcs( data, ), bcs: PendingPackage.bcs, fromJSONField: (field: any) => PendingPackage.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => PendingPackage.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => PendingPackage.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => PendingPackage.fetch( client, id, ), new: ( fields: PendingPackageFields, ) => { return new PendingPackage( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return PendingPackage.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<PendingPackage>> { return phantom(PendingPackage.reified( )); } static get p() { return PendingPackage.phantom() }
+
+ static get bcs() { return bcs.struct("PendingPackage", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): PendingPackage { return PendingPackage.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): PendingPackage { if (!isPendingPackage(item.type)) { throw new Error("not a PendingPackage type");
+
+ }
+
+ return PendingPackage.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): PendingPackage { return PendingPackage.fromFields( PendingPackage.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): PendingPackage { return PendingPackage.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): PendingPackage { if (json.$typeName !== PendingPackage.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return PendingPackage.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): PendingPackage { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isPendingPackage(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a PendingPackage object`); } return PendingPackage.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<PendingPackage> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching PendingPackage object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isPendingPackage(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a PendingPackage object`); }
+ return PendingPackage.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/publish-message/structs.ts

@@ -0,0 +1,136 @@
+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 {ID} from "../../0x2/object/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== MessageTicket =============================== */
+
+export function isMessageTicket(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::publish_message::MessageTicket"; }
+
+export interface MessageTicketFields { sender: ToField<ID>; sequence: ToField<"u64">; nonce: ToField<"u32">; payload: ToField<Vector<"u8">> }
+
+export type MessageTicketReified = Reified< MessageTicket, MessageTicketFields >;
+
+export class MessageTicket implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::publish_message::MessageTicket"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = MessageTicket.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::publish_message::MessageTicket";
+
+ readonly $typeArgs: [];
+
+ readonly sender: ToField<ID>; readonly sequence: ToField<"u64">; readonly nonce: ToField<"u32">; readonly payload: ToField<Vector<"u8">>
+
+ private constructor(typeArgs: [], fields: MessageTicketFields, ) { this.$fullTypeName = composeSuiType( MessageTicket.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::publish_message::MessageTicket"; this.$typeArgs = typeArgs;
+
+ this.sender = fields.sender;; this.sequence = fields.sequence;; this.nonce = fields.nonce;; this.payload = fields.payload; }
+
+ static reified( ): MessageTicketReified { return { typeName: MessageTicket.$typeName, fullTypeName: composeSuiType( MessageTicket.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::publish_message::MessageTicket", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => MessageTicket.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => MessageTicket.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => MessageTicket.fromBcs( data, ), bcs: MessageTicket.bcs, fromJSONField: (field: any) => MessageTicket.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => MessageTicket.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => MessageTicket.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => MessageTicket.fetch( client, id, ), new: ( fields: MessageTicketFields, ) => { return new MessageTicket( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return MessageTicket.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<MessageTicket>> { return phantom(MessageTicket.reified( )); } static get p() { return MessageTicket.phantom() }
+
+ static get bcs() { return bcs.struct("MessageTicket", {
+
+ sender: ID.bcs, sequence: bcs.u64(), nonce: bcs.u32(), payload: bcs.vector(bcs.u8())
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): MessageTicket { return MessageTicket.reified( ).new( { sender: decodeFromFields(ID.reified(), fields.sender), sequence: decodeFromFields("u64", fields.sequence), nonce: decodeFromFields("u32", fields.nonce), payload: decodeFromFields(reified.vector("u8"), fields.payload) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): MessageTicket { if (!isMessageTicket(item.type)) { throw new Error("not a MessageTicket type");
+
+ }
+
+ return MessageTicket.reified( ).new( { sender: decodeFromFieldsWithTypes(ID.reified(), item.fields.sender), sequence: decodeFromFieldsWithTypes("u64", item.fields.sequence), nonce: decodeFromFieldsWithTypes("u32", item.fields.nonce), payload: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.payload) } ) }
+
+ static fromBcs( data: Uint8Array ): MessageTicket { return MessageTicket.fromFields( MessageTicket.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ sender: this.sender,sequence: this.sequence.toString(),nonce: this.nonce,payload: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.payload),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): MessageTicket { return MessageTicket.reified( ).new( { sender: decodeFromJSONField(ID.reified(), field.sender), sequence: decodeFromJSONField("u64", field.sequence), nonce: decodeFromJSONField("u32", field.nonce), payload: decodeFromJSONField(reified.vector("u8"), field.payload) } ) }
+
+ static fromJSON( json: Record<string, any> ): MessageTicket { if (json.$typeName !== MessageTicket.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return MessageTicket.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): MessageTicket { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isMessageTicket(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a MessageTicket object`); } return MessageTicket.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<MessageTicket> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching MessageTicket object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isMessageTicket(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a MessageTicket object`); }
+ return MessageTicket.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== WormholeMessage =============================== */
+
+export function isWormholeMessage(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::publish_message::WormholeMessage"; }
+
+export interface WormholeMessageFields { sender: ToField<ID>; sequence: ToField<"u64">; nonce: ToField<"u32">; payload: ToField<Vector<"u8">>; consistencyLevel: ToField<"u8">; timestamp: ToField<"u64"> }
+
+export type WormholeMessageReified = Reified< WormholeMessage, WormholeMessageFields >;
+
+export class WormholeMessage implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::publish_message::WormholeMessage"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = WormholeMessage.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::publish_message::WormholeMessage";
+
+ readonly $typeArgs: [];
+
+ readonly sender: ToField<ID>; readonly sequence: ToField<"u64">; readonly nonce: ToField<"u32">; readonly payload: ToField<Vector<"u8">>; readonly consistencyLevel: ToField<"u8">; readonly timestamp: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: WormholeMessageFields, ) { this.$fullTypeName = composeSuiType( WormholeMessage.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::publish_message::WormholeMessage"; this.$typeArgs = typeArgs;
+
+ this.sender = fields.sender;; this.sequence = fields.sequence;; this.nonce = fields.nonce;; this.payload = fields.payload;; this.consistencyLevel = fields.consistencyLevel;; this.timestamp = fields.timestamp; }
+
+ static reified( ): WormholeMessageReified { return { typeName: WormholeMessage.$typeName, fullTypeName: composeSuiType( WormholeMessage.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::publish_message::WormholeMessage", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => WormholeMessage.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => WormholeMessage.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => WormholeMessage.fromBcs( data, ), bcs: WormholeMessage.bcs, fromJSONField: (field: any) => WormholeMessage.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => WormholeMessage.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => WormholeMessage.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => WormholeMessage.fetch( client, id, ), new: ( fields: WormholeMessageFields, ) => { return new WormholeMessage( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return WormholeMessage.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<WormholeMessage>> { return phantom(WormholeMessage.reified( )); } static get p() { return WormholeMessage.phantom() }
+
+ static get bcs() { return bcs.struct("WormholeMessage", {
+
+ sender: ID.bcs, sequence: bcs.u64(), nonce: bcs.u32(), payload: bcs.vector(bcs.u8()), consistency_level: bcs.u8(), timestamp: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): WormholeMessage { return WormholeMessage.reified( ).new( { sender: decodeFromFields(ID.reified(), fields.sender), sequence: decodeFromFields("u64", fields.sequence), nonce: decodeFromFields("u32", fields.nonce), payload: decodeFromFields(reified.vector("u8"), fields.payload), consistencyLevel: decodeFromFields("u8", fields.consistency_level), timestamp: decodeFromFields("u64", fields.timestamp) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): WormholeMessage { if (!isWormholeMessage(item.type)) { throw new Error("not a WormholeMessage type");
+
+ }
+
+ return WormholeMessage.reified( ).new( { sender: decodeFromFieldsWithTypes(ID.reified(), item.fields.sender), sequence: decodeFromFieldsWithTypes("u64", item.fields.sequence), nonce: decodeFromFieldsWithTypes("u32", item.fields.nonce), payload: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.payload), consistencyLevel: decodeFromFieldsWithTypes("u8", item.fields.consistency_level), timestamp: decodeFromFieldsWithTypes("u64", item.fields.timestamp) } ) }
+
+ static fromBcs( data: Uint8Array ): WormholeMessage { return WormholeMessage.fromFields( WormholeMessage.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ sender: this.sender,sequence: this.sequence.toString(),nonce: this.nonce,payload: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.payload),consistencyLevel: this.consistencyLevel,timestamp: this.timestamp.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): WormholeMessage { return WormholeMessage.reified( ).new( { sender: decodeFromJSONField(ID.reified(), field.sender), sequence: decodeFromJSONField("u64", field.sequence), nonce: decodeFromJSONField("u32", field.nonce), payload: decodeFromJSONField(reified.vector("u8"), field.payload), consistencyLevel: decodeFromJSONField("u8", field.consistencyLevel), timestamp: decodeFromJSONField("u64", field.timestamp) } ) }
+
+ static fromJSON( json: Record<string, any> ): WormholeMessage { if (json.$typeName !== WormholeMessage.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return WormholeMessage.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): WormholeMessage { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isWormholeMessage(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a WormholeMessage object`); } return WormholeMessage.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<WormholeMessage> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching WormholeMessage object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isWormholeMessage(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a WormholeMessage object`); }
+ return WormholeMessage.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/set/structs.ts

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