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

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

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/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 === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::setup::DeployerCap"; }
+
+export interface DeployerCapFields { id: ToField<UID> }
+
+export type DeployerCapReified = Reified< DeployerCap, DeployerCapFields >;
+
+export class DeployerCap implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::setup::DeployerCap"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = DeployerCap.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::setup::DeployerCap";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>
+
+ private constructor(typeArgs: [], fields: DeployerCapFields, ) { this.$fullTypeName = composeSuiType( DeployerCap.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::setup::DeployerCap"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id; }
+
+ static reified( ): DeployerCapReified { return { typeName: DeployerCap.$typeName, fullTypeName: composeSuiType( DeployerCap.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::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/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/state/structs.ts

@@ -0,0 +1,142 @@
+import * as reified from "../../../../_framework/reified";
+import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, ToTypeStr as ToPhantom} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {UID} from "../../0x2/object/structs";
+import {UpgradeCap} from "../../0x2/package/structs";
+import {Table} from "../../0x2/table/structs";
+import {ConsumedVAAs} from "../consumed-vaas/structs";
+import {ExternalAddress} from "../external-address/structs";
+import {FeeCollector} from "../fee-collector/structs";
+import {GuardianSet} from "../guardian-set/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== LatestOnly =============================== */
+
+export function isLatestOnly(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::state::LatestOnly"; }
+
+export interface LatestOnlyFields { dummyField: ToField<"bool"> }
+
+export type LatestOnlyReified = Reified< LatestOnly, LatestOnlyFields >;
+
+export class LatestOnly implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::state::LatestOnly"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = LatestOnly.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::state::LatestOnly";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: LatestOnlyFields, ) { this.$fullTypeName = composeSuiType( LatestOnly.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::state::LatestOnly"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): LatestOnlyReified { return { typeName: LatestOnly.$typeName, fullTypeName: composeSuiType( LatestOnly.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::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 === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::state::State"; }
+
+export interface StateFields { id: ToField<UID>; governanceChain: ToField<"u16">; governanceContract: ToField<ExternalAddress>; guardianSetIndex: ToField<"u32">; guardianSets: ToField<Table<"u32", ToPhantom<GuardianSet>>>; guardianSetSecondsToLive: ToField<"u32">; consumedVaas: ToField<ConsumedVAAs>; feeCollector: ToField<FeeCollector>; upgradeCap: ToField<UpgradeCap> }
+
+export type StateReified = Reified< State, StateFields >;
+
+export class State implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::state::State"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = State.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::state::State";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly governanceChain: ToField<"u16">; readonly governanceContract: ToField<ExternalAddress>; readonly guardianSetIndex: ToField<"u32">; readonly guardianSets: ToField<Table<"u32", ToPhantom<GuardianSet>>>; readonly guardianSetSecondsToLive: ToField<"u32">; readonly consumedVaas: ToField<ConsumedVAAs>; readonly feeCollector: ToField<FeeCollector>; readonly upgradeCap: ToField<UpgradeCap>
+
+ private constructor(typeArgs: [], fields: StateFields, ) { this.$fullTypeName = composeSuiType( State.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::state::State"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.governanceChain = fields.governanceChain;; this.governanceContract = fields.governanceContract;; this.guardianSetIndex = fields.guardianSetIndex;; this.guardianSets = fields.guardianSets;; this.guardianSetSecondsToLive = fields.guardianSetSecondsToLive;; this.consumedVaas = fields.consumedVaas;; this.feeCollector = fields.feeCollector;; this.upgradeCap = fields.upgradeCap; }
+
+ static reified( ): StateReified { return { typeName: State.$typeName, fullTypeName: composeSuiType( State.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::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_chain: bcs.u16(), governance_contract: ExternalAddress.bcs, guardian_set_index: bcs.u32(), guardian_sets: Table.bcs, guardian_set_seconds_to_live: bcs.u32(), consumed_vaas: ConsumedVAAs.bcs, fee_collector: FeeCollector.bcs, upgrade_cap: UpgradeCap.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): State { return State.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), governanceChain: decodeFromFields("u16", fields.governance_chain), governanceContract: decodeFromFields(ExternalAddress.reified(), fields.governance_contract), guardianSetIndex: decodeFromFields("u32", fields.guardian_set_index), guardianSets: decodeFromFields(Table.reified(reified.phantom("u32"), reified.phantom(GuardianSet.reified())), fields.guardian_sets), guardianSetSecondsToLive: decodeFromFields("u32", fields.guardian_set_seconds_to_live), consumedVaas: decodeFromFields(ConsumedVAAs.reified(), fields.consumed_vaas), feeCollector: decodeFromFields(FeeCollector.reified(), fields.fee_collector), 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), governanceChain: decodeFromFieldsWithTypes("u16", item.fields.governance_chain), governanceContract: decodeFromFieldsWithTypes(ExternalAddress.reified(), item.fields.governance_contract), guardianSetIndex: decodeFromFieldsWithTypes("u32", item.fields.guardian_set_index), guardianSets: decodeFromFieldsWithTypes(Table.reified(reified.phantom("u32"), reified.phantom(GuardianSet.reified())), item.fields.guardian_sets), guardianSetSecondsToLive: decodeFromFieldsWithTypes("u32", item.fields.guardian_set_seconds_to_live), consumedVaas: decodeFromFieldsWithTypes(ConsumedVAAs.reified(), item.fields.consumed_vaas), feeCollector: decodeFromFieldsWithTypes(FeeCollector.reified(), item.fields.fee_collector), 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,governanceChain: this.governanceChain,governanceContract: this.governanceContract.toJSONField(),guardianSetIndex: this.guardianSetIndex,guardianSets: this.guardianSets.toJSONField(),guardianSetSecondsToLive: this.guardianSetSecondsToLive,consumedVaas: this.consumedVaas.toJSONField(),feeCollector: this.feeCollector.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), governanceChain: decodeFromJSONField("u16", field.governanceChain), governanceContract: decodeFromJSONField(ExternalAddress.reified(), field.governanceContract), guardianSetIndex: decodeFromJSONField("u32", field.guardianSetIndex), guardianSets: decodeFromJSONField(Table.reified(reified.phantom("u32"), reified.phantom(GuardianSet.reified())), field.guardianSets), guardianSetSecondsToLive: decodeFromJSONField("u32", field.guardianSetSecondsToLive), consumedVaas: decodeFromJSONField(ConsumedVAAs.reified(), field.consumedVaas), feeCollector: decodeFromJSONField(FeeCollector.reified(), field.feeCollector), 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/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/transfer-fee/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, fromHEX, toHEX} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== GovernanceWitness =============================== */
+
+export function isGovernanceWitness(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::transfer_fee::GovernanceWitness"; }
+
+export interface GovernanceWitnessFields { dummyField: ToField<"bool"> }
+
+export type GovernanceWitnessReified = Reified< GovernanceWitness, GovernanceWitnessFields >;
+
+export class GovernanceWitness implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::transfer_fee::GovernanceWitness"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = GovernanceWitness.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::transfer_fee::GovernanceWitness";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: GovernanceWitnessFields, ) { this.$fullTypeName = composeSuiType( GovernanceWitness.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::transfer_fee::GovernanceWitness"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): GovernanceWitnessReified { return { typeName: GovernanceWitness.$typeName, fullTypeName: composeSuiType( GovernanceWitness.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::transfer_fee::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) ); }
+
+ }
+
+/* ============================== TransferFee =============================== */
+
+export function isTransferFee(type: string): boolean { type = compressSuiType(type); return type === "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::transfer_fee::TransferFee"; }
+
+export interface TransferFeeFields { amount: ToField<"u64">; recipient: ToField<"address"> }
+
+export type TransferFeeReified = Reified< TransferFee, TransferFeeFields >;
+
+export class TransferFee implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::transfer_fee::TransferFee"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = TransferFee.$typeName;
+
+ readonly $fullTypeName: "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::transfer_fee::TransferFee";
+
+ readonly $typeArgs: [];
+
+ readonly amount: ToField<"u64">; readonly recipient: ToField<"address">
+
+ private constructor(typeArgs: [], fields: TransferFeeFields, ) { this.$fullTypeName = composeSuiType( TransferFee.$typeName, ...typeArgs ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::transfer_fee::TransferFee"; this.$typeArgs = typeArgs;
+
+ this.amount = fields.amount;; this.recipient = fields.recipient; }
+
+ static reified( ): TransferFeeReified { return { typeName: TransferFee.$typeName, fullTypeName: composeSuiType( TransferFee.$typeName, ...[] ) as "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::transfer_fee::TransferFee", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => TransferFee.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => TransferFee.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => TransferFee.fromBcs( data, ), bcs: TransferFee.bcs, fromJSONField: (field: any) => TransferFee.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => TransferFee.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => TransferFee.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => TransferFee.fetch( client, id, ), new: ( fields: TransferFeeFields, ) => { return new TransferFee( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return TransferFee.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<TransferFee>> { return phantom(TransferFee.reified( )); } static get p() { return TransferFee.phantom() }
+
+ static get bcs() { return bcs.struct("TransferFee", {
+
+ amount: bcs.u64(), recipient: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), })
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): TransferFee { return TransferFee.reified( ).new( { amount: decodeFromFields("u64", fields.amount), recipient: decodeFromFields("address", fields.recipient) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): TransferFee { if (!isTransferFee(item.type)) { throw new Error("not a TransferFee type");
+
+ }
+
+ return TransferFee.reified( ).new( { amount: decodeFromFieldsWithTypes("u64", item.fields.amount), recipient: decodeFromFieldsWithTypes("address", item.fields.recipient) } ) }
+
+ static fromBcs( data: Uint8Array ): TransferFee { return TransferFee.fromFields( TransferFee.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ amount: this.amount.toString(),recipient: this.recipient,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): TransferFee { return TransferFee.reified( ).new( { amount: decodeFromJSONField("u64", field.amount), recipient: decodeFromJSONField("address", field.recipient) } ) }
+
+ static fromJSON( json: Record<string, any> ): TransferFee { if (json.$typeName !== TransferFee.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return TransferFee.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): TransferFee { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isTransferFee(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a TransferFee object`); } return TransferFee.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<TransferFee> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching TransferFee object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isTransferFee(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a TransferFee object`); }
+ return TransferFee.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }