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

package/src/_dependencies/source/0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3/set-governance-data-source/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 {ExternalAddress} from "../../0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/external-address/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== GovernanceDataSource =============================== */
+
+export function isGovernanceDataSource(type: string): boolean { type = compressSuiType(type); return type === "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::set_governance_data_source::GovernanceDataSource"; }
+
+export interface GovernanceDataSourceFields { emitterChainId: ToField<"u64">; emitterAddress: ToField<ExternalAddress>; initialSequence: ToField<"u64"> }
+
+export type GovernanceDataSourceReified = Reified< GovernanceDataSource, GovernanceDataSourceFields >;
+
+export class GovernanceDataSource implements StructClass { static readonly $typeName = "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::set_governance_data_source::GovernanceDataSource"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = GovernanceDataSource.$typeName;
+
+ readonly $fullTypeName: "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::set_governance_data_source::GovernanceDataSource";
+
+ readonly $typeArgs: [];
+
+ readonly emitterChainId: ToField<"u64">; readonly emitterAddress: ToField<ExternalAddress>; readonly initialSequence: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: GovernanceDataSourceFields, ) { this.$fullTypeName = composeSuiType( GovernanceDataSource.$typeName, ...typeArgs ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::set_governance_data_source::GovernanceDataSource"; this.$typeArgs = typeArgs;
+
+ this.emitterChainId = fields.emitterChainId;; this.emitterAddress = fields.emitterAddress;; this.initialSequence = fields.initialSequence; }
+
+ static reified( ): GovernanceDataSourceReified { return { typeName: GovernanceDataSource.$typeName, fullTypeName: composeSuiType( GovernanceDataSource.$typeName, ...[] ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::set_governance_data_source::GovernanceDataSource", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => GovernanceDataSource.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => GovernanceDataSource.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => GovernanceDataSource.fromBcs( data, ), bcs: GovernanceDataSource.bcs, fromJSONField: (field: any) => GovernanceDataSource.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => GovernanceDataSource.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => GovernanceDataSource.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => GovernanceDataSource.fetch( client, id, ), new: ( fields: GovernanceDataSourceFields, ) => { return new GovernanceDataSource( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return GovernanceDataSource.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<GovernanceDataSource>> { return phantom(GovernanceDataSource.reified( )); } static get p() { return GovernanceDataSource.phantom() }
+
+ static get bcs() { return bcs.struct("GovernanceDataSource", {
+
+ emitter_chain_id: bcs.u64(), emitter_address: ExternalAddress.bcs, initial_sequence: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): GovernanceDataSource { return GovernanceDataSource.reified( ).new( { emitterChainId: decodeFromFields("u64", fields.emitter_chain_id), emitterAddress: decodeFromFields(ExternalAddress.reified(), fields.emitter_address), initialSequence: decodeFromFields("u64", fields.initial_sequence) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): GovernanceDataSource { if (!isGovernanceDataSource(item.type)) { throw new Error("not a GovernanceDataSource type");
+
+ }
+
+ return GovernanceDataSource.reified( ).new( { emitterChainId: decodeFromFieldsWithTypes("u64", item.fields.emitter_chain_id), emitterAddress: decodeFromFieldsWithTypes(ExternalAddress.reified(), item.fields.emitter_address), initialSequence: decodeFromFieldsWithTypes("u64", item.fields.initial_sequence) } ) }
+
+ static fromBcs( data: Uint8Array ): GovernanceDataSource { return GovernanceDataSource.fromFields( GovernanceDataSource.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ emitterChainId: this.emitterChainId.toString(),emitterAddress: this.emitterAddress.toJSONField(),initialSequence: this.initialSequence.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): GovernanceDataSource { return GovernanceDataSource.reified( ).new( { emitterChainId: decodeFromJSONField("u64", field.emitterChainId), emitterAddress: decodeFromJSONField(ExternalAddress.reified(), field.emitterAddress), initialSequence: decodeFromJSONField("u64", field.initialSequence) } ) }
+
+ static fromJSON( json: Record<string, any> ): GovernanceDataSource { if (json.$typeName !== GovernanceDataSource.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return GovernanceDataSource.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): GovernanceDataSource { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isGovernanceDataSource(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a GovernanceDataSource object`); } return GovernanceDataSource.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<GovernanceDataSource> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching GovernanceDataSource object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isGovernanceDataSource(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a GovernanceDataSource object`); }
+ return GovernanceDataSource.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3/set-stale-price-threshold/structs.ts

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

package/src/_dependencies/source/0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3/set-update-fee/structs.ts

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

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

package/src/_dependencies/source/0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3/state/structs.ts

@@ -0,0 +1,203 @@
+import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {UID} from "../../0x2/object/structs";
+import {UpgradeCap} from "../../0x2/package/structs";
+import {ConsumedVAAs} from "../../0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/consumed-vaas/structs";
+import {DataSource} from "../data-source/structs";
+import {bcs, fromB64, fromHEX, toHEX} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== CurrentDigest =============================== */
+
+export function isCurrentDigest(type: string): boolean { type = compressSuiType(type); return type === "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::CurrentDigest"; }
+
+export interface CurrentDigestFields { dummyField: ToField<"bool"> }
+
+export type CurrentDigestReified = Reified< CurrentDigest, CurrentDigestFields >;
+
+export class CurrentDigest implements StructClass { static readonly $typeName = "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::CurrentDigest"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = CurrentDigest.$typeName;
+
+ readonly $fullTypeName: "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::CurrentDigest";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: CurrentDigestFields, ) { this.$fullTypeName = composeSuiType( CurrentDigest.$typeName, ...typeArgs ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::CurrentDigest"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): CurrentDigestReified { return { typeName: CurrentDigest.$typeName, fullTypeName: composeSuiType( CurrentDigest.$typeName, ...[] ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::CurrentDigest", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => CurrentDigest.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => CurrentDigest.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => CurrentDigest.fromBcs( data, ), bcs: CurrentDigest.bcs, fromJSONField: (field: any) => CurrentDigest.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => CurrentDigest.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => CurrentDigest.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => CurrentDigest.fetch( client, id, ), new: ( fields: CurrentDigestFields, ) => { return new CurrentDigest( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return CurrentDigest.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<CurrentDigest>> { return phantom(CurrentDigest.reified( )); } static get p() { return CurrentDigest.phantom() }
+
+ static get bcs() { return bcs.struct("CurrentDigest", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): CurrentDigest { return CurrentDigest.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): CurrentDigest { if (!isCurrentDigest(item.type)) { throw new Error("not a CurrentDigest type");
+
+ }
+
+ return CurrentDigest.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): CurrentDigest { return CurrentDigest.fromFields( CurrentDigest.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): CurrentDigest { return CurrentDigest.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): CurrentDigest { if (json.$typeName !== CurrentDigest.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return CurrentDigest.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): CurrentDigest { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isCurrentDigest(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a CurrentDigest object`); } return CurrentDigest.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<CurrentDigest> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching CurrentDigest object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isCurrentDigest(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a CurrentDigest object`); }
+ return CurrentDigest.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== LatestOnly =============================== */
+
+export function isLatestOnly(type: string): boolean { type = compressSuiType(type); return type === "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::LatestOnly"; }
+
+export interface LatestOnlyFields { dummyField: ToField<"bool"> }
+
+export type LatestOnlyReified = Reified< LatestOnly, LatestOnlyFields >;
+
+export class LatestOnly implements StructClass { static readonly $typeName = "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::LatestOnly"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = LatestOnly.$typeName;
+
+ readonly $fullTypeName: "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::LatestOnly";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: LatestOnlyFields, ) { this.$fullTypeName = composeSuiType( LatestOnly.$typeName, ...typeArgs ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::LatestOnly"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): LatestOnlyReified { return { typeName: LatestOnly.$typeName, fullTypeName: composeSuiType( LatestOnly.$typeName, ...[] ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::LatestOnly", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => LatestOnly.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => LatestOnly.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => LatestOnly.fromBcs( data, ), bcs: LatestOnly.bcs, fromJSONField: (field: any) => LatestOnly.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => LatestOnly.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => LatestOnly.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => LatestOnly.fetch( client, id, ), new: ( fields: LatestOnlyFields, ) => { return new LatestOnly( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return LatestOnly.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<LatestOnly>> { return phantom(LatestOnly.reified( )); } static get p() { return LatestOnly.phantom() }
+
+ static get bcs() { return bcs.struct("LatestOnly", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): LatestOnly { return LatestOnly.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): LatestOnly { if (!isLatestOnly(item.type)) { throw new Error("not a LatestOnly type");
+
+ }
+
+ return LatestOnly.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): LatestOnly { return LatestOnly.fromFields( LatestOnly.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): LatestOnly { return LatestOnly.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): LatestOnly { if (json.$typeName !== LatestOnly.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return LatestOnly.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): LatestOnly { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isLatestOnly(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a LatestOnly object`); } return LatestOnly.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<LatestOnly> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching LatestOnly object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isLatestOnly(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a LatestOnly object`); }
+ return LatestOnly.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== State =============================== */
+
+export function isState(type: string): boolean { type = compressSuiType(type); return type === "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::State"; }
+
+export interface StateFields { id: ToField<UID>; governanceDataSource: ToField<DataSource>; stalePriceThreshold: ToField<"u64">; baseUpdateFee: ToField<"u64">; feeRecipientAddress: ToField<"address">; lastExecutedGovernanceSequence: ToField<"u64">; consumedVaas: ToField<ConsumedVAAs>; upgradeCap: ToField<UpgradeCap> }
+
+export type StateReified = Reified< State, StateFields >;
+
+export class State implements StructClass { static readonly $typeName = "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::State"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = State.$typeName;
+
+ readonly $fullTypeName: "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::State";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly governanceDataSource: ToField<DataSource>; readonly stalePriceThreshold: ToField<"u64">; readonly baseUpdateFee: ToField<"u64">; readonly feeRecipientAddress: ToField<"address">; readonly lastExecutedGovernanceSequence: ToField<"u64">; readonly consumedVaas: ToField<ConsumedVAAs>; readonly upgradeCap: ToField<UpgradeCap>
+
+ private constructor(typeArgs: [], fields: StateFields, ) { this.$fullTypeName = composeSuiType( State.$typeName, ...typeArgs ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::State"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.governanceDataSource = fields.governanceDataSource;; this.stalePriceThreshold = fields.stalePriceThreshold;; this.baseUpdateFee = fields.baseUpdateFee;; this.feeRecipientAddress = fields.feeRecipientAddress;; this.lastExecutedGovernanceSequence = fields.lastExecutedGovernanceSequence;; this.consumedVaas = fields.consumedVaas;; this.upgradeCap = fields.upgradeCap; }
+
+ static reified( ): StateReified { return { typeName: State.$typeName, fullTypeName: composeSuiType( State.$typeName, ...[] ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::state::State", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => State.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => State.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => State.fromBcs( data, ), bcs: State.bcs, fromJSONField: (field: any) => State.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => State.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => State.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => State.fetch( client, id, ), new: ( fields: StateFields, ) => { return new State( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return State.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<State>> { return phantom(State.reified( )); } static get p() { return State.phantom() }
+
+ static get bcs() { return bcs.struct("State", {
+
+ id: UID.bcs, governance_data_source: DataSource.bcs, stale_price_threshold: bcs.u64(), base_update_fee: bcs.u64(), fee_recipient_address: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), last_executed_governance_sequence: bcs.u64(), consumed_vaas: ConsumedVAAs.bcs, upgrade_cap: UpgradeCap.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): State { return State.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), governanceDataSource: decodeFromFields(DataSource.reified(), fields.governance_data_source), stalePriceThreshold: decodeFromFields("u64", fields.stale_price_threshold), baseUpdateFee: decodeFromFields("u64", fields.base_update_fee), feeRecipientAddress: decodeFromFields("address", fields.fee_recipient_address), lastExecutedGovernanceSequence: decodeFromFields("u64", fields.last_executed_governance_sequence), consumedVaas: decodeFromFields(ConsumedVAAs.reified(), fields.consumed_vaas), upgradeCap: decodeFromFields(UpgradeCap.reified(), fields.upgrade_cap) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): State { if (!isState(item.type)) { throw new Error("not a State type");
+
+ }
+
+ return State.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), governanceDataSource: decodeFromFieldsWithTypes(DataSource.reified(), item.fields.governance_data_source), stalePriceThreshold: decodeFromFieldsWithTypes("u64", item.fields.stale_price_threshold), baseUpdateFee: decodeFromFieldsWithTypes("u64", item.fields.base_update_fee), feeRecipientAddress: decodeFromFieldsWithTypes("address", item.fields.fee_recipient_address), lastExecutedGovernanceSequence: decodeFromFieldsWithTypes("u64", item.fields.last_executed_governance_sequence), consumedVaas: decodeFromFieldsWithTypes(ConsumedVAAs.reified(), item.fields.consumed_vaas), upgradeCap: decodeFromFieldsWithTypes(UpgradeCap.reified(), item.fields.upgrade_cap) } ) }
+
+ static fromBcs( data: Uint8Array ): State { return State.fromFields( State.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,governanceDataSource: this.governanceDataSource.toJSONField(),stalePriceThreshold: this.stalePriceThreshold.toString(),baseUpdateFee: this.baseUpdateFee.toString(),feeRecipientAddress: this.feeRecipientAddress,lastExecutedGovernanceSequence: this.lastExecutedGovernanceSequence.toString(),consumedVaas: this.consumedVaas.toJSONField(),upgradeCap: this.upgradeCap.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): State { return State.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), governanceDataSource: decodeFromJSONField(DataSource.reified(), field.governanceDataSource), stalePriceThreshold: decodeFromJSONField("u64", field.stalePriceThreshold), baseUpdateFee: decodeFromJSONField("u64", field.baseUpdateFee), feeRecipientAddress: decodeFromJSONField("address", field.feeRecipientAddress), lastExecutedGovernanceSequence: decodeFromJSONField("u64", field.lastExecutedGovernanceSequence), consumedVaas: decodeFromJSONField(ConsumedVAAs.reified(), field.consumedVaas), upgradeCap: decodeFromJSONField(UpgradeCap.reified(), field.upgradeCap) } ) }
+
+ static fromJSON( json: Record<string, any> ): State { if (json.$typeName !== State.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return State.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): State { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isState(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a State object`); } return State.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<State> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching State object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isState(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a State object`); }
+ return State.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3/version-control/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";
+
+/* ============================== V__0_1_1 =============================== */
+
+export function isV__0_1_1(type: string): boolean { type = compressSuiType(type); return type === "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::version_control::V__0_1_1"; }
+
+export interface V__0_1_1Fields { dummyField: ToField<"bool"> }
+
+export type V__0_1_1Reified = Reified< V__0_1_1, V__0_1_1Fields >;
+
+export class V__0_1_1 implements StructClass { static readonly $typeName = "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::version_control::V__0_1_1"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = V__0_1_1.$typeName;
+
+ readonly $fullTypeName: "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::version_control::V__0_1_1";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: V__0_1_1Fields, ) { this.$fullTypeName = composeSuiType( V__0_1_1.$typeName, ...typeArgs ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::version_control::V__0_1_1"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): V__0_1_1Reified { return { typeName: V__0_1_1.$typeName, fullTypeName: composeSuiType( V__0_1_1.$typeName, ...[] ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::version_control::V__0_1_1", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => V__0_1_1.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => V__0_1_1.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => V__0_1_1.fromBcs( data, ), bcs: V__0_1_1.bcs, fromJSONField: (field: any) => V__0_1_1.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => V__0_1_1.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => V__0_1_1.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => V__0_1_1.fetch( client, id, ), new: ( fields: V__0_1_1Fields, ) => { return new V__0_1_1( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return V__0_1_1.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<V__0_1_1>> { return phantom(V__0_1_1.reified( )); } static get p() { return V__0_1_1.phantom() }
+
+ static get bcs() { return bcs.struct("V__0_1_1", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): V__0_1_1 { return V__0_1_1.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): V__0_1_1 { if (!isV__0_1_1(item.type)) { throw new Error("not a V__0_1_1 type");
+
+ }
+
+ return V__0_1_1.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): V__0_1_1 { return V__0_1_1.fromFields( V__0_1_1.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): V__0_1_1 { return V__0_1_1.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): V__0_1_1 { if (json.$typeName !== V__0_1_1.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return V__0_1_1.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): V__0_1_1 { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isV__0_1_1(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a V__0_1_1 object`); } return V__0_1_1.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<V__0_1_1> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching V__0_1_1 object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isV__0_1_1(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a V__0_1_1 object`); }
+ return V__0_1_1.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== V__DUMMY =============================== */
+
+export function isV__DUMMY(type: string): boolean { type = compressSuiType(type); return type === "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::version_control::V__DUMMY"; }
+
+export interface V__DUMMYFields { dummyField: ToField<"bool"> }
+
+export type V__DUMMYReified = Reified< V__DUMMY, V__DUMMYFields >;
+
+export class V__DUMMY implements StructClass { static readonly $typeName = "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::version_control::V__DUMMY"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = V__DUMMY.$typeName;
+
+ readonly $fullTypeName: "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::version_control::V__DUMMY";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: V__DUMMYFields, ) { this.$fullTypeName = composeSuiType( V__DUMMY.$typeName, ...typeArgs ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::version_control::V__DUMMY"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): V__DUMMYReified { return { typeName: V__DUMMY.$typeName, fullTypeName: composeSuiType( V__DUMMY.$typeName, ...[] ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::version_control::V__DUMMY", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => V__DUMMY.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => V__DUMMY.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => V__DUMMY.fromBcs( data, ), bcs: V__DUMMY.bcs, fromJSONField: (field: any) => V__DUMMY.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => V__DUMMY.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => V__DUMMY.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => V__DUMMY.fetch( client, id, ), new: ( fields: V__DUMMYFields, ) => { return new V__DUMMY( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return V__DUMMY.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<V__DUMMY>> { return phantom(V__DUMMY.reified( )); } static get p() { return V__DUMMY.phantom() }
+
+ static get bcs() { return bcs.struct("V__DUMMY", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): V__DUMMY { return V__DUMMY.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): V__DUMMY { if (!isV__DUMMY(item.type)) { throw new Error("not a V__DUMMY type");
+
+ }
+
+ return V__DUMMY.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): V__DUMMY { return V__DUMMY.fromFields( V__DUMMY.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): V__DUMMY { return V__DUMMY.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): V__DUMMY { if (json.$typeName !== V__DUMMY.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return V__DUMMY.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): V__DUMMY { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isV__DUMMY(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a V__DUMMY object`); } return V__DUMMY.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<V__DUMMY> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching V__DUMMY object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isV__DUMMY(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a V__DUMMY object`); }
+ return V__DUMMY.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }