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

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/update-guardian-set/structs.ts

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

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/upgrade-contract/structs.ts

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

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

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

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