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

package/src/_dependencies/source/0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828/royalty-rule/structs.ts

@@ -0,0 +1,134 @@
+import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, 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";
+
+/* ============================== Rule =============================== */
+
+export function isRule(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::royalty_rule::Rule"; }
+
+export interface RuleFields { dummyField: ToField<"bool"> }
+
+export type RuleReified = Reified< Rule, RuleFields >;
+
+export class Rule implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::royalty_rule::Rule"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Rule.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::royalty_rule::Rule";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: RuleFields, ) { this.$fullTypeName = composeSuiType( Rule.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::royalty_rule::Rule"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): RuleReified { return { typeName: Rule.$typeName, fullTypeName: composeSuiType( Rule.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::royalty_rule::Rule", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Rule.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Rule.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Rule.fromBcs( data, ), bcs: Rule.bcs, fromJSONField: (field: any) => Rule.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Rule.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Rule.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Rule.fetch( client, id, ), new: ( fields: RuleFields, ) => { return new Rule( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Rule.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Rule>> { return phantom(Rule.reified( )); } static get p() { return Rule.phantom() }
+
+ static get bcs() { return bcs.struct("Rule", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Rule { return Rule.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Rule { if (!isRule(item.type)) { throw new Error("not a Rule type");
+
+ }
+
+ return Rule.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): Rule { return Rule.fromFields( Rule.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Rule { return Rule.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): Rule { if (json.$typeName !== Rule.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Rule.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Rule { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isRule(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Rule object`); } return Rule.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Rule> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Rule object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isRule(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Rule object`); }
+ return Rule.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== Config =============================== */
+
+export function isConfig(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::royalty_rule::Config"; }
+
+export interface ConfigFields { amountBp: ToField<"u16">; minAmount: ToField<"u64"> }
+
+export type ConfigReified = Reified< Config, ConfigFields >;
+
+export class Config implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::royalty_rule::Config"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Config.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::royalty_rule::Config";
+
+ readonly $typeArgs: [];
+
+ readonly amountBp: ToField<"u16">; readonly minAmount: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: ConfigFields, ) { this.$fullTypeName = composeSuiType( Config.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::royalty_rule::Config"; this.$typeArgs = typeArgs;
+
+ this.amountBp = fields.amountBp;; this.minAmount = fields.minAmount; }
+
+ static reified( ): ConfigReified { return { typeName: Config.$typeName, fullTypeName: composeSuiType( Config.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::royalty_rule::Config", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Config.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Config.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Config.fromBcs( data, ), bcs: Config.bcs, fromJSONField: (field: any) => Config.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Config.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Config.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Config.fetch( client, id, ), new: ( fields: ConfigFields, ) => { return new Config( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Config.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Config>> { return phantom(Config.reified( )); } static get p() { return Config.phantom() }
+
+ static get bcs() { return bcs.struct("Config", {
+
+ amount_bp: bcs.u16(), min_amount: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Config { return Config.reified( ).new( { amountBp: decodeFromFields("u16", fields.amount_bp), minAmount: decodeFromFields("u64", fields.min_amount) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Config { if (!isConfig(item.type)) { throw new Error("not a Config type");
+
+ }
+
+ return Config.reified( ).new( { amountBp: decodeFromFieldsWithTypes("u16", item.fields.amount_bp), minAmount: decodeFromFieldsWithTypes("u64", item.fields.min_amount) } ) }
+
+ static fromBcs( data: Uint8Array ): Config { return Config.fromFields( Config.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ amountBp: this.amountBp,minAmount: this.minAmount.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Config { return Config.reified( ).new( { amountBp: decodeFromJSONField("u16", field.amountBp), minAmount: decodeFromJSONField("u64", field.minAmount) } ) }
+
+ static fromJSON( json: Record<string, any> ): Config { if (json.$typeName !== Config.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Config.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Config { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isConfig(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Config object`); } return Config.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Config> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Config object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isConfig(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Config object`); }
+ return Config.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828/staking/structs.ts

@@ -0,0 +1,333 @@
+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 {ID, UID} from "../../0x2/object/structs";
+import {Table} from "../../0x2/table/structs";
+import {Tails, ManagerCap as ManagerCap1} from "../typus-nft/structs";
+import {bcs, fromB64, fromHEX, toHEX} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== ManagerCap =============================== */
+
+export function isManagerCap(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::ManagerCap"; }
+
+export interface ManagerCapFields { id: ToField<UID> }
+
+export type ManagerCapReified = Reified< ManagerCap, ManagerCapFields >;
+
+export class ManagerCap implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::ManagerCap"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = ManagerCap.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::ManagerCap";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>
+
+ private constructor(typeArgs: [], fields: ManagerCapFields, ) { this.$fullTypeName = composeSuiType( ManagerCap.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::ManagerCap"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id; }
+
+ static reified( ): ManagerCapReified { return { typeName: ManagerCap.$typeName, fullTypeName: composeSuiType( ManagerCap.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::ManagerCap", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => ManagerCap.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => ManagerCap.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => ManagerCap.fromBcs( data, ), bcs: ManagerCap.bcs, fromJSONField: (field: any) => ManagerCap.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => ManagerCap.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => ManagerCap.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => ManagerCap.fetch( client, id, ), new: ( fields: ManagerCapFields, ) => { return new ManagerCap( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return ManagerCap.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<ManagerCap>> { return phantom(ManagerCap.reified( )); } static get p() { return ManagerCap.phantom() }
+
+ static get bcs() { return bcs.struct("ManagerCap", {
+
+ id: UID.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): ManagerCap { return ManagerCap.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): ManagerCap { if (!isManagerCap(item.type)) { throw new Error("not a ManagerCap type");
+
+ }
+
+ return ManagerCap.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id) } ) }
+
+ static fromBcs( data: Uint8Array ): ManagerCap { return ManagerCap.fromFields( ManagerCap.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): ManagerCap { return ManagerCap.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id) } ) }
+
+ static fromJSON( json: Record<string, any> ): ManagerCap { if (json.$typeName !== ManagerCap.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return ManagerCap.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): ManagerCap { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isManagerCap(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a ManagerCap object`); } return ManagerCap.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<ManagerCap> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching ManagerCap object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isManagerCap(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a ManagerCap object`); }
+ return ManagerCap.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== Registry =============================== */
+
+export function isRegistry(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::Registry"; }
+
+export interface RegistryFields { id: ToField<UID> }
+
+export type RegistryReified = Reified< Registry, RegistryFields >;
+
+export class Registry implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::Registry"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Registry.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::Registry";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>
+
+ private constructor(typeArgs: [], fields: RegistryFields, ) { this.$fullTypeName = composeSuiType( Registry.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::Registry"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id; }
+
+ static reified( ): RegistryReified { return { typeName: Registry.$typeName, fullTypeName: composeSuiType( Registry.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::Registry", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Registry.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Registry.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Registry.fromBcs( data, ), bcs: Registry.bcs, fromJSONField: (field: any) => Registry.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Registry.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Registry.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Registry.fetch( client, id, ), new: ( fields: RegistryFields, ) => { return new Registry( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Registry.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Registry>> { return phantom(Registry.reified( )); } static get p() { return Registry.phantom() }
+
+ static get bcs() { return bcs.struct("Registry", {
+
+ id: UID.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Registry { return Registry.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Registry { if (!isRegistry(item.type)) { throw new Error("not a Registry type");
+
+ }
+
+ return Registry.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id) } ) }
+
+ static fromBcs( data: Uint8Array ): Registry { return Registry.fromFields( Registry.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Registry { return Registry.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id) } ) }
+
+ static fromJSON( json: Record<string, any> ): Registry { if (json.$typeName !== Registry.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Registry.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Registry { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isRegistry(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Registry object`); } return Registry.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Registry> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Registry object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isRegistry(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Registry object`); }
+ return Registry.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== LevelUpEvent =============================== */
+
+export function isLevelUpEvent(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::LevelUpEvent"; }
+
+export interface LevelUpEventFields { nftId: ToField<ID>; sender: ToField<"address">; number: ToField<"u64">; level: ToField<"u64"> }
+
+export type LevelUpEventReified = Reified< LevelUpEvent, LevelUpEventFields >;
+
+export class LevelUpEvent implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::LevelUpEvent"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = LevelUpEvent.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::LevelUpEvent";
+
+ readonly $typeArgs: [];
+
+ readonly nftId: ToField<ID>; readonly sender: ToField<"address">; readonly number: ToField<"u64">; readonly level: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: LevelUpEventFields, ) { this.$fullTypeName = composeSuiType( LevelUpEvent.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::LevelUpEvent"; this.$typeArgs = typeArgs;
+
+ this.nftId = fields.nftId;; this.sender = fields.sender;; this.number = fields.number;; this.level = fields.level; }
+
+ static reified( ): LevelUpEventReified { return { typeName: LevelUpEvent.$typeName, fullTypeName: composeSuiType( LevelUpEvent.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::LevelUpEvent", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => LevelUpEvent.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => LevelUpEvent.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => LevelUpEvent.fromBcs( data, ), bcs: LevelUpEvent.bcs, fromJSONField: (field: any) => LevelUpEvent.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => LevelUpEvent.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => LevelUpEvent.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => LevelUpEvent.fetch( client, id, ), new: ( fields: LevelUpEventFields, ) => { return new LevelUpEvent( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return LevelUpEvent.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<LevelUpEvent>> { return phantom(LevelUpEvent.reified( )); } static get p() { return LevelUpEvent.phantom() }
+
+ static get bcs() { return bcs.struct("LevelUpEvent", {
+
+ nft_id: ID.bcs, sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), number: bcs.u64(), level: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): LevelUpEvent { return LevelUpEvent.reified( ).new( { nftId: decodeFromFields(ID.reified(), fields.nft_id), sender: decodeFromFields("address", fields.sender), number: decodeFromFields("u64", fields.number), level: decodeFromFields("u64", fields.level) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): LevelUpEvent { if (!isLevelUpEvent(item.type)) { throw new Error("not a LevelUpEvent type");
+
+ }
+
+ return LevelUpEvent.reified( ).new( { nftId: decodeFromFieldsWithTypes(ID.reified(), item.fields.nft_id), sender: decodeFromFieldsWithTypes("address", item.fields.sender), number: decodeFromFieldsWithTypes("u64", item.fields.number), level: decodeFromFieldsWithTypes("u64", item.fields.level) } ) }
+
+ static fromBcs( data: Uint8Array ): LevelUpEvent { return LevelUpEvent.fromFields( LevelUpEvent.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ nftId: this.nftId,sender: this.sender,number: this.number.toString(),level: this.level.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): LevelUpEvent { return LevelUpEvent.reified( ).new( { nftId: decodeFromJSONField(ID.reified(), field.nftId), sender: decodeFromJSONField("address", field.sender), number: decodeFromJSONField("u64", field.number), level: decodeFromJSONField("u64", field.level) } ) }
+
+ static fromJSON( json: Record<string, any> ): LevelUpEvent { if (json.$typeName !== LevelUpEvent.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return LevelUpEvent.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): LevelUpEvent { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isLevelUpEvent(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a LevelUpEvent object`); } return LevelUpEvent.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<LevelUpEvent> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching LevelUpEvent object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isLevelUpEvent(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a LevelUpEvent object`); }
+ return LevelUpEvent.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== NftExtension =============================== */
+
+export function isNftExtension(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::NftExtension"; }
+
+export interface NftExtensionFields { nftTable: ToField<Table<"address", ToPhantom<StakingTails>>>; nftManagerCap: ToField<ManagerCap1> }
+
+export type NftExtensionReified = Reified< NftExtension, NftExtensionFields >;
+
+export class NftExtension implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::NftExtension"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = NftExtension.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::NftExtension";
+
+ readonly $typeArgs: [];
+
+ readonly nftTable: ToField<Table<"address", ToPhantom<StakingTails>>>; readonly nftManagerCap: ToField<ManagerCap1>
+
+ private constructor(typeArgs: [], fields: NftExtensionFields, ) { this.$fullTypeName = composeSuiType( NftExtension.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::NftExtension"; this.$typeArgs = typeArgs;
+
+ this.nftTable = fields.nftTable;; this.nftManagerCap = fields.nftManagerCap; }
+
+ static reified( ): NftExtensionReified { return { typeName: NftExtension.$typeName, fullTypeName: composeSuiType( NftExtension.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::NftExtension", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => NftExtension.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => NftExtension.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => NftExtension.fromBcs( data, ), bcs: NftExtension.bcs, fromJSONField: (field: any) => NftExtension.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => NftExtension.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => NftExtension.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => NftExtension.fetch( client, id, ), new: ( fields: NftExtensionFields, ) => { return new NftExtension( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return NftExtension.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<NftExtension>> { return phantom(NftExtension.reified( )); } static get p() { return NftExtension.phantom() }
+
+ static get bcs() { return bcs.struct("NftExtension", {
+
+ nft_table: Table.bcs, nft_manager_cap: ManagerCap1.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): NftExtension { return NftExtension.reified( ).new( { nftTable: decodeFromFields(Table.reified(reified.phantom("address"), reified.phantom(StakingTails.reified())), fields.nft_table), nftManagerCap: decodeFromFields(ManagerCap1.reified(), fields.nft_manager_cap) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): NftExtension { if (!isNftExtension(item.type)) { throw new Error("not a NftExtension type");
+
+ }
+
+ return NftExtension.reified( ).new( { nftTable: decodeFromFieldsWithTypes(Table.reified(reified.phantom("address"), reified.phantom(StakingTails.reified())), item.fields.nft_table), nftManagerCap: decodeFromFieldsWithTypes(ManagerCap1.reified(), item.fields.nft_manager_cap) } ) }
+
+ static fromBcs( data: Uint8Array ): NftExtension { return NftExtension.fromFields( NftExtension.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ nftTable: this.nftTable.toJSONField(),nftManagerCap: this.nftManagerCap.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): NftExtension { return NftExtension.reified( ).new( { nftTable: decodeFromJSONField(Table.reified(reified.phantom("address"), reified.phantom(StakingTails.reified())), field.nftTable), nftManagerCap: decodeFromJSONField(ManagerCap1.reified(), field.nftManagerCap) } ) }
+
+ static fromJSON( json: Record<string, any> ): NftExtension { if (json.$typeName !== NftExtension.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return NftExtension.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): NftExtension { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isNftExtension(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a NftExtension object`); } return NftExtension.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<NftExtension> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching NftExtension object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isNftExtension(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a NftExtension object`); }
+ return NftExtension.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== StakingTails =============================== */
+
+export function isStakingTails(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::StakingTails"; }
+
+export interface StakingTailsFields { nft: ToField<Tails>; snapshotMs: ToField<"u64">; updatingUrl: ToField<"bool"> }
+
+export type StakingTailsReified = Reified< StakingTails, StakingTailsFields >;
+
+export class StakingTails implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::StakingTails"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = StakingTails.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::StakingTails";
+
+ readonly $typeArgs: [];
+
+ readonly nft: ToField<Tails>; readonly snapshotMs: ToField<"u64">; readonly updatingUrl: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: StakingTailsFields, ) { this.$fullTypeName = composeSuiType( StakingTails.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::StakingTails"; this.$typeArgs = typeArgs;
+
+ this.nft = fields.nft;; this.snapshotMs = fields.snapshotMs;; this.updatingUrl = fields.updatingUrl; }
+
+ static reified( ): StakingTailsReified { return { typeName: StakingTails.$typeName, fullTypeName: composeSuiType( StakingTails.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::staking::StakingTails", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => StakingTails.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => StakingTails.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => StakingTails.fromBcs( data, ), bcs: StakingTails.bcs, fromJSONField: (field: any) => StakingTails.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => StakingTails.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => StakingTails.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => StakingTails.fetch( client, id, ), new: ( fields: StakingTailsFields, ) => { return new StakingTails( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return StakingTails.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<StakingTails>> { return phantom(StakingTails.reified( )); } static get p() { return StakingTails.phantom() }
+
+ static get bcs() { return bcs.struct("StakingTails", {
+
+ nft: Tails.bcs, snapshot_ms: bcs.u64(), updating_url: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): StakingTails { return StakingTails.reified( ).new( { nft: decodeFromFields(Tails.reified(), fields.nft), snapshotMs: decodeFromFields("u64", fields.snapshot_ms), updatingUrl: decodeFromFields("bool", fields.updating_url) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): StakingTails { if (!isStakingTails(item.type)) { throw new Error("not a StakingTails type");
+
+ }
+
+ return StakingTails.reified( ).new( { nft: decodeFromFieldsWithTypes(Tails.reified(), item.fields.nft), snapshotMs: decodeFromFieldsWithTypes("u64", item.fields.snapshot_ms), updatingUrl: decodeFromFieldsWithTypes("bool", item.fields.updating_url) } ) }
+
+ static fromBcs( data: Uint8Array ): StakingTails { return StakingTails.fromFields( StakingTails.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ nft: this.nft.toJSONField(),snapshotMs: this.snapshotMs.toString(),updatingUrl: this.updatingUrl,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): StakingTails { return StakingTails.reified( ).new( { nft: decodeFromJSONField(Tails.reified(), field.nft), snapshotMs: decodeFromJSONField("u64", field.snapshotMs), updatingUrl: decodeFromJSONField("bool", field.updatingUrl) } ) }
+
+ static fromJSON( json: Record<string, any> ): StakingTails { if (json.$typeName !== StakingTails.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return StakingTails.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): StakingTails { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isStakingTails(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a StakingTails object`); } return StakingTails.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<StakingTails> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching StakingTails object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isStakingTails(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a StakingTails object`); }
+ return StakingTails.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828/table-vec/structs.ts

@@ -0,0 +1,71 @@
+import * as reified from "../../../../_framework/reified";
+import {PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToPhantomTypeArgument, ToTypeStr, assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, phantom} 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";
+
+/* ============================== TableVec =============================== */
+
+export function isTableVec(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::table_vec::TableVec<"); }
+
+export interface TableVecFields<Element extends PhantomTypeArgument> { contents: ToField<Table<"u64", Element>> }
+
+export type TableVecReified<Element extends PhantomTypeArgument> = Reified< TableVec<Element>, TableVecFields<Element> >;
+
+export class TableVec<Element extends PhantomTypeArgument> implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::table_vec::TableVec"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = TableVec.$typeName;
+
+ readonly $fullTypeName: `0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::table_vec::TableVec<${PhantomToTypeStr<Element>}>`;
+
+ readonly $typeArgs: [PhantomToTypeStr<Element>];
+
+ readonly contents: ToField<Table<"u64", Element>>
+
+ private constructor(typeArgs: [PhantomToTypeStr<Element>], fields: TableVecFields<Element>, ) { this.$fullTypeName = composeSuiType( TableVec.$typeName, ...typeArgs ) as `0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::table_vec::TableVec<${PhantomToTypeStr<Element>}>`; this.$typeArgs = typeArgs;
+
+ this.contents = fields.contents; }
+
+ static reified<Element extends PhantomReified<PhantomTypeArgument>>( Element: Element ): TableVecReified<ToPhantomTypeArgument<Element>> { return { typeName: TableVec.$typeName, fullTypeName: composeSuiType( TableVec.$typeName, ...[extractType(Element)] ) as `0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::table_vec::TableVec<${PhantomToTypeStr<ToPhantomTypeArgument<Element>>}>`, typeArgs: [ extractType(Element) ] as [PhantomToTypeStr<ToPhantomTypeArgument<Element>>], reifiedTypeArgs: [Element], fromFields: (fields: Record<string, any>) => TableVec.fromFields( Element, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => TableVec.fromFieldsWithTypes( Element, item, ), fromBcs: (data: Uint8Array) => TableVec.fromBcs( Element, data, ), bcs: TableVec.bcs, fromJSONField: (field: any) => TableVec.fromJSONField( Element, field, ), fromJSON: (json: Record<string, any>) => TableVec.fromJSON( Element, json, ), fromSuiParsedData: (content: SuiParsedData) => TableVec.fromSuiParsedData( Element, content, ), fetch: async (client: SuiClient, id: string) => TableVec.fetch( client, Element, id, ), new: ( fields: TableVecFields<ToPhantomTypeArgument<Element>>, ) => { return new TableVec( [extractType(Element)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return TableVec.reified }
+
+ static phantom<Element extends PhantomReified<PhantomTypeArgument>>( Element: Element ): PhantomReified<ToTypeStr<TableVec<ToPhantomTypeArgument<Element>>>> { return phantom(TableVec.reified( Element )); } static get p() { return TableVec.phantom }
+
+ static get bcs() { return bcs.struct("TableVec", {
+
+ contents: Table.bcs
+
+}) };
+
+ static fromFields<Element extends PhantomReified<PhantomTypeArgument>>( typeArg: Element, fields: Record<string, any> ): TableVec<ToPhantomTypeArgument<Element>> { return TableVec.reified( typeArg, ).new( { contents: decodeFromFields(Table.reified(reified.phantom("u64"), typeArg), fields.contents) } ) }
+
+ static fromFieldsWithTypes<Element extends PhantomReified<PhantomTypeArgument>>( typeArg: Element, item: FieldsWithTypes ): TableVec<ToPhantomTypeArgument<Element>> { if (!isTableVec(item.type)) { throw new Error("not a TableVec type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return TableVec.reified( typeArg, ).new( { contents: decodeFromFieldsWithTypes(Table.reified(reified.phantom("u64"), typeArg), item.fields.contents) } ) }
+
+ static fromBcs<Element extends PhantomReified<PhantomTypeArgument>>( typeArg: Element, data: Uint8Array ): TableVec<ToPhantomTypeArgument<Element>> { return TableVec.fromFields( typeArg, TableVec.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ contents: this.contents.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<Element extends PhantomReified<PhantomTypeArgument>>( typeArg: Element, field: any ): TableVec<ToPhantomTypeArgument<Element>> { return TableVec.reified( typeArg, ).new( { contents: decodeFromJSONField(Table.reified(reified.phantom("u64"), typeArg), field.contents) } ) }
+
+ static fromJSON<Element extends PhantomReified<PhantomTypeArgument>>( typeArg: Element, json: Record<string, any> ): TableVec<ToPhantomTypeArgument<Element>> { if (json.$typeName !== TableVec.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(TableVec.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return TableVec.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<Element extends PhantomReified<PhantomTypeArgument>>( typeArg: Element, content: SuiParsedData ): TableVec<ToPhantomTypeArgument<Element>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isTableVec(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a TableVec object`); } return TableVec.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<Element extends PhantomReified<PhantomTypeArgument>>( client: SuiClient, typeArg: Element, id: string ): Promise<TableVec<ToPhantomTypeArgument<Element>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching TableVec object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isTableVec(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a TableVec object`); }
+ return TableVec.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }