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

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

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

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/consumed-vaas/structs.ts

@@ -0,0 +1,72 @@
+import * as reified from "../../../../_framework/reified";
+import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, ToTypeStr as ToPhantom} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {Bytes32} from "../bytes32/structs";
+import {Set} from "../set/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== ConsumedVAAs =============================== */
+
+export function isConsumedVAAs(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::consumed_vaas::ConsumedVAAs"; }
+
+export interface ConsumedVAAsFields { hashes: ToField<Set<ToPhantom<Bytes32>>> }
+
+export type ConsumedVAAsReified = Reified< ConsumedVAAs, ConsumedVAAsFields >;
+
+export class ConsumedVAAs implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::consumed_vaas::ConsumedVAAs"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = ConsumedVAAs.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::consumed_vaas::ConsumedVAAs";
+
+ readonly $typeArgs: [];
+
+ readonly hashes: ToField<Set<ToPhantom<Bytes32>>>
+
+ private constructor(typeArgs: [], fields: ConsumedVAAsFields, ) { this.$fullTypeName = composeSuiType( ConsumedVAAs.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::consumed_vaas::ConsumedVAAs"; this.$typeArgs = typeArgs;
+
+ this.hashes = fields.hashes; }
+
+ static reified( ): ConsumedVAAsReified { return { typeName: ConsumedVAAs.$typeName, fullTypeName: composeSuiType( ConsumedVAAs.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::consumed_vaas::ConsumedVAAs", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => ConsumedVAAs.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => ConsumedVAAs.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => ConsumedVAAs.fromBcs( data, ), bcs: ConsumedVAAs.bcs, fromJSONField: (field: any) => ConsumedVAAs.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => ConsumedVAAs.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => ConsumedVAAs.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => ConsumedVAAs.fetch( client, id, ), new: ( fields: ConsumedVAAsFields, ) => { return new ConsumedVAAs( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return ConsumedVAAs.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<ConsumedVAAs>> { return phantom(ConsumedVAAs.reified( )); } static get p() { return ConsumedVAAs.phantom() }
+
+ static get bcs() { return bcs.struct("ConsumedVAAs", {
+
+ hashes: Set.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): ConsumedVAAs { return ConsumedVAAs.reified( ).new( { hashes: decodeFromFields(Set.reified(reified.phantom(Bytes32.reified())), fields.hashes) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): ConsumedVAAs { if (!isConsumedVAAs(item.type)) { throw new Error("not a ConsumedVAAs type");
+
+ }
+
+ return ConsumedVAAs.reified( ).new( { hashes: decodeFromFieldsWithTypes(Set.reified(reified.phantom(Bytes32.reified())), item.fields.hashes) } ) }
+
+ static fromBcs( data: Uint8Array ): ConsumedVAAs { return ConsumedVAAs.fromFields( ConsumedVAAs.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ hashes: this.hashes.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): ConsumedVAAs { return ConsumedVAAs.reified( ).new( { hashes: decodeFromJSONField(Set.reified(reified.phantom(Bytes32.reified())), field.hashes) } ) }
+
+ static fromJSON( json: Record<string, any> ): ConsumedVAAs { if (json.$typeName !== ConsumedVAAs.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return ConsumedVAAs.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): ConsumedVAAs { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isConsumedVAAs(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a ConsumedVAAs object`); } return ConsumedVAAs.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<ConsumedVAAs> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching ConsumedVAAs object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isConsumedVAAs(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a ConsumedVAAs object`); }
+ return ConsumedVAAs.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

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

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

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

@@ -0,0 +1,200 @@
+import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {ID, UID} from "../../0x2/object/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== EmitterCap =============================== */
+
+export function isEmitterCap(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterCap"; }
+
+export interface EmitterCapFields { id: ToField<UID>; sequence: ToField<"u64"> }
+
+export type EmitterCapReified = Reified< EmitterCap, EmitterCapFields >;
+
+export class EmitterCap implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterCap"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = EmitterCap.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterCap";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly sequence: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: EmitterCapFields, ) { this.$fullTypeName = composeSuiType( EmitterCap.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterCap"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.sequence = fields.sequence; }
+
+ static reified( ): EmitterCapReified { return { typeName: EmitterCap.$typeName, fullTypeName: composeSuiType( EmitterCap.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterCap", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => EmitterCap.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => EmitterCap.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => EmitterCap.fromBcs( data, ), bcs: EmitterCap.bcs, fromJSONField: (field: any) => EmitterCap.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => EmitterCap.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => EmitterCap.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => EmitterCap.fetch( client, id, ), new: ( fields: EmitterCapFields, ) => { return new EmitterCap( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return EmitterCap.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<EmitterCap>> { return phantom(EmitterCap.reified( )); } static get p() { return EmitterCap.phantom() }
+
+ static get bcs() { return bcs.struct("EmitterCap", {
+
+ id: UID.bcs, sequence: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): EmitterCap { return EmitterCap.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), sequence: decodeFromFields("u64", fields.sequence) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): EmitterCap { if (!isEmitterCap(item.type)) { throw new Error("not a EmitterCap type");
+
+ }
+
+ return EmitterCap.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), sequence: decodeFromFieldsWithTypes("u64", item.fields.sequence) } ) }
+
+ static fromBcs( data: Uint8Array ): EmitterCap { return EmitterCap.fromFields( EmitterCap.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,sequence: this.sequence.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): EmitterCap { return EmitterCap.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), sequence: decodeFromJSONField("u64", field.sequence) } ) }
+
+ static fromJSON( json: Record<string, any> ): EmitterCap { if (json.$typeName !== EmitterCap.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return EmitterCap.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): EmitterCap { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isEmitterCap(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a EmitterCap object`); } return EmitterCap.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<EmitterCap> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching EmitterCap object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isEmitterCap(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a EmitterCap object`); }
+ return EmitterCap.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== EmitterCreated =============================== */
+
+export function isEmitterCreated(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterCreated"; }
+
+export interface EmitterCreatedFields { emitterCap: ToField<ID> }
+
+export type EmitterCreatedReified = Reified< EmitterCreated, EmitterCreatedFields >;
+
+export class EmitterCreated implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterCreated"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = EmitterCreated.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterCreated";
+
+ readonly $typeArgs: [];
+
+ readonly emitterCap: ToField<ID>
+
+ private constructor(typeArgs: [], fields: EmitterCreatedFields, ) { this.$fullTypeName = composeSuiType( EmitterCreated.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterCreated"; this.$typeArgs = typeArgs;
+
+ this.emitterCap = fields.emitterCap; }
+
+ static reified( ): EmitterCreatedReified { return { typeName: EmitterCreated.$typeName, fullTypeName: composeSuiType( EmitterCreated.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterCreated", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => EmitterCreated.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => EmitterCreated.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => EmitterCreated.fromBcs( data, ), bcs: EmitterCreated.bcs, fromJSONField: (field: any) => EmitterCreated.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => EmitterCreated.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => EmitterCreated.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => EmitterCreated.fetch( client, id, ), new: ( fields: EmitterCreatedFields, ) => { return new EmitterCreated( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return EmitterCreated.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<EmitterCreated>> { return phantom(EmitterCreated.reified( )); } static get p() { return EmitterCreated.phantom() }
+
+ static get bcs() { return bcs.struct("EmitterCreated", {
+
+ emitter_cap: ID.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): EmitterCreated { return EmitterCreated.reified( ).new( { emitterCap: decodeFromFields(ID.reified(), fields.emitter_cap) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): EmitterCreated { if (!isEmitterCreated(item.type)) { throw new Error("not a EmitterCreated type");
+
+ }
+
+ return EmitterCreated.reified( ).new( { emitterCap: decodeFromFieldsWithTypes(ID.reified(), item.fields.emitter_cap) } ) }
+
+ static fromBcs( data: Uint8Array ): EmitterCreated { return EmitterCreated.fromFields( EmitterCreated.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ emitterCap: this.emitterCap,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): EmitterCreated { return EmitterCreated.reified( ).new( { emitterCap: decodeFromJSONField(ID.reified(), field.emitterCap) } ) }
+
+ static fromJSON( json: Record<string, any> ): EmitterCreated { if (json.$typeName !== EmitterCreated.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return EmitterCreated.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): EmitterCreated { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isEmitterCreated(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a EmitterCreated object`); } return EmitterCreated.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<EmitterCreated> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching EmitterCreated object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isEmitterCreated(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a EmitterCreated object`); }
+ return EmitterCreated.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== EmitterDestroyed =============================== */
+
+export function isEmitterDestroyed(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterDestroyed"; }
+
+export interface EmitterDestroyedFields { emitterCap: ToField<ID> }
+
+export type EmitterDestroyedReified = Reified< EmitterDestroyed, EmitterDestroyedFields >;
+
+export class EmitterDestroyed implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterDestroyed"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = EmitterDestroyed.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterDestroyed";
+
+ readonly $typeArgs: [];
+
+ readonly emitterCap: ToField<ID>
+
+ private constructor(typeArgs: [], fields: EmitterDestroyedFields, ) { this.$fullTypeName = composeSuiType( EmitterDestroyed.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterDestroyed"; this.$typeArgs = typeArgs;
+
+ this.emitterCap = fields.emitterCap; }
+
+ static reified( ): EmitterDestroyedReified { return { typeName: EmitterDestroyed.$typeName, fullTypeName: composeSuiType( EmitterDestroyed.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::emitter::EmitterDestroyed", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => EmitterDestroyed.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => EmitterDestroyed.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => EmitterDestroyed.fromBcs( data, ), bcs: EmitterDestroyed.bcs, fromJSONField: (field: any) => EmitterDestroyed.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => EmitterDestroyed.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => EmitterDestroyed.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => EmitterDestroyed.fetch( client, id, ), new: ( fields: EmitterDestroyedFields, ) => { return new EmitterDestroyed( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return EmitterDestroyed.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<EmitterDestroyed>> { return phantom(EmitterDestroyed.reified( )); } static get p() { return EmitterDestroyed.phantom() }
+
+ static get bcs() { return bcs.struct("EmitterDestroyed", {
+
+ emitter_cap: ID.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): EmitterDestroyed { return EmitterDestroyed.reified( ).new( { emitterCap: decodeFromFields(ID.reified(), fields.emitter_cap) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): EmitterDestroyed { if (!isEmitterDestroyed(item.type)) { throw new Error("not a EmitterDestroyed type");
+
+ }
+
+ return EmitterDestroyed.reified( ).new( { emitterCap: decodeFromFieldsWithTypes(ID.reified(), item.fields.emitter_cap) } ) }
+
+ static fromBcs( data: Uint8Array ): EmitterDestroyed { return EmitterDestroyed.fromFields( EmitterDestroyed.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ emitterCap: this.emitterCap,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): EmitterDestroyed { return EmitterDestroyed.reified( ).new( { emitterCap: decodeFromJSONField(ID.reified(), field.emitterCap) } ) }
+
+ static fromJSON( json: Record<string, any> ): EmitterDestroyed { if (json.$typeName !== EmitterDestroyed.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return EmitterDestroyed.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): EmitterDestroyed { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isEmitterDestroyed(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a EmitterDestroyed object`); } return EmitterDestroyed.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<EmitterDestroyed> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching EmitterDestroyed object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isEmitterDestroyed(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a EmitterDestroyed object`); }
+ return EmitterDestroyed.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/external-address/structs.ts

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

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/fee-collector/structs.ts

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