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

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

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

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

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