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

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/governance-message/structs.ts

@@ -0,0 +1,137 @@
+import * as reified from "../../../../_framework/reified";
+import {PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToPhantomTypeArgument, ToTypeStr, Vector, assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, 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";
+
+/* ============================== DecreeReceipt =============================== */
+
+export function isDecreeReceipt(type: string): boolean { type = compressSuiType(type); return type.startsWith("0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::governance_message::DecreeReceipt<"); }
+
+export interface DecreeReceiptFields<T extends PhantomTypeArgument> { payload: ToField<Vector<"u8">>; digest: ToField<Bytes32>; sequence: ToField<"u64"> }
+
+export type DecreeReceiptReified<T extends PhantomTypeArgument> = Reified< DecreeReceipt<T>, DecreeReceiptFields<T> >;
+
+export class DecreeReceipt<T extends PhantomTypeArgument> implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::governance_message::DecreeReceipt"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = DecreeReceipt.$typeName;
+
+ readonly $fullTypeName: `0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::governance_message::DecreeReceipt<${PhantomToTypeStr<T>}>`;
+
+ readonly $typeArgs: [PhantomToTypeStr<T>];
+
+ readonly payload: ToField<Vector<"u8">>; readonly digest: ToField<Bytes32>; readonly sequence: ToField<"u64">
+
+ private constructor(typeArgs: [PhantomToTypeStr<T>], fields: DecreeReceiptFields<T>, ) { this.$fullTypeName = composeSuiType( DecreeReceipt.$typeName, ...typeArgs ) as `0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::governance_message::DecreeReceipt<${PhantomToTypeStr<T>}>`; this.$typeArgs = typeArgs;
+
+ this.payload = fields.payload;; this.digest = fields.digest;; this.sequence = fields.sequence; }
+
+ static reified<T extends PhantomReified<PhantomTypeArgument>>( T: T ): DecreeReceiptReified<ToPhantomTypeArgument<T>> { return { typeName: DecreeReceipt.$typeName, fullTypeName: composeSuiType( DecreeReceipt.$typeName, ...[extractType(T)] ) as `0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::governance_message::DecreeReceipt<${PhantomToTypeStr<ToPhantomTypeArgument<T>>}>`, typeArgs: [ extractType(T) ] as [PhantomToTypeStr<ToPhantomTypeArgument<T>>], reifiedTypeArgs: [T], fromFields: (fields: Record<string, any>) => DecreeReceipt.fromFields( T, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => DecreeReceipt.fromFieldsWithTypes( T, item, ), fromBcs: (data: Uint8Array) => DecreeReceipt.fromBcs( T, data, ), bcs: DecreeReceipt.bcs, fromJSONField: (field: any) => DecreeReceipt.fromJSONField( T, field, ), fromJSON: (json: Record<string, any>) => DecreeReceipt.fromJSON( T, json, ), fromSuiParsedData: (content: SuiParsedData) => DecreeReceipt.fromSuiParsedData( T, content, ), fetch: async (client: SuiClient, id: string) => DecreeReceipt.fetch( client, T, id, ), new: ( fields: DecreeReceiptFields<ToPhantomTypeArgument<T>>, ) => { return new DecreeReceipt( [extractType(T)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return DecreeReceipt.reified }
+
+ static phantom<T extends PhantomReified<PhantomTypeArgument>>( T: T ): PhantomReified<ToTypeStr<DecreeReceipt<ToPhantomTypeArgument<T>>>> { return phantom(DecreeReceipt.reified( T )); } static get p() { return DecreeReceipt.phantom }
+
+ static get bcs() { return bcs.struct("DecreeReceipt", {
+
+ payload: bcs.vector(bcs.u8()), digest: Bytes32.bcs, sequence: bcs.u64()
+
+}) };
+
+ static fromFields<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, fields: Record<string, any> ): DecreeReceipt<ToPhantomTypeArgument<T>> { return DecreeReceipt.reified( typeArg, ).new( { payload: decodeFromFields(reified.vector("u8"), fields.payload), digest: decodeFromFields(Bytes32.reified(), fields.digest), sequence: decodeFromFields("u64", fields.sequence) } ) }
+
+ static fromFieldsWithTypes<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, item: FieldsWithTypes ): DecreeReceipt<ToPhantomTypeArgument<T>> { if (!isDecreeReceipt(item.type)) { throw new Error("not a DecreeReceipt type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return DecreeReceipt.reified( typeArg, ).new( { payload: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.payload), digest: decodeFromFieldsWithTypes(Bytes32.reified(), item.fields.digest), sequence: decodeFromFieldsWithTypes("u64", item.fields.sequence) } ) }
+
+ static fromBcs<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, data: Uint8Array ): DecreeReceipt<ToPhantomTypeArgument<T>> { return DecreeReceipt.fromFields( typeArg, DecreeReceipt.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ payload: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.payload),digest: this.digest.toJSONField(),sequence: this.sequence.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, field: any ): DecreeReceipt<ToPhantomTypeArgument<T>> { return DecreeReceipt.reified( typeArg, ).new( { payload: decodeFromJSONField(reified.vector("u8"), field.payload), digest: decodeFromJSONField(Bytes32.reified(), field.digest), sequence: decodeFromJSONField("u64", field.sequence) } ) }
+
+ static fromJSON<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, json: Record<string, any> ): DecreeReceipt<ToPhantomTypeArgument<T>> { if (json.$typeName !== DecreeReceipt.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(DecreeReceipt.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return DecreeReceipt.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, content: SuiParsedData ): DecreeReceipt<ToPhantomTypeArgument<T>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isDecreeReceipt(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a DecreeReceipt object`); } return DecreeReceipt.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<T extends PhantomReified<PhantomTypeArgument>>( client: SuiClient, typeArg: T, id: string ): Promise<DecreeReceipt<ToPhantomTypeArgument<T>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching DecreeReceipt object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isDecreeReceipt(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a DecreeReceipt object`); }
+ return DecreeReceipt.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== DecreeTicket =============================== */
+
+export function isDecreeTicket(type: string): boolean { type = compressSuiType(type); return type.startsWith("0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::governance_message::DecreeTicket<"); }
+
+export interface DecreeTicketFields<T extends PhantomTypeArgument> { governanceChain: ToField<"u16">; governanceContract: ToField<ExternalAddress>; moduleName: ToField<Bytes32>; action: ToField<"u8">; global: ToField<"bool"> }
+
+export type DecreeTicketReified<T extends PhantomTypeArgument> = Reified< DecreeTicket<T>, DecreeTicketFields<T> >;
+
+export class DecreeTicket<T extends PhantomTypeArgument> implements StructClass { static readonly $typeName = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::governance_message::DecreeTicket"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = DecreeTicket.$typeName;
+
+ readonly $fullTypeName: `0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::governance_message::DecreeTicket<${PhantomToTypeStr<T>}>`;
+
+ readonly $typeArgs: [PhantomToTypeStr<T>];
+
+ readonly governanceChain: ToField<"u16">; readonly governanceContract: ToField<ExternalAddress>; readonly moduleName: ToField<Bytes32>; readonly action: ToField<"u8">; readonly global: ToField<"bool">
+
+ private constructor(typeArgs: [PhantomToTypeStr<T>], fields: DecreeTicketFields<T>, ) { this.$fullTypeName = composeSuiType( DecreeTicket.$typeName, ...typeArgs ) as `0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::governance_message::DecreeTicket<${PhantomToTypeStr<T>}>`; this.$typeArgs = typeArgs;
+
+ this.governanceChain = fields.governanceChain;; this.governanceContract = fields.governanceContract;; this.moduleName = fields.moduleName;; this.action = fields.action;; this.global = fields.global; }
+
+ static reified<T extends PhantomReified<PhantomTypeArgument>>( T: T ): DecreeTicketReified<ToPhantomTypeArgument<T>> { return { typeName: DecreeTicket.$typeName, fullTypeName: composeSuiType( DecreeTicket.$typeName, ...[extractType(T)] ) as `0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e::governance_message::DecreeTicket<${PhantomToTypeStr<ToPhantomTypeArgument<T>>}>`, typeArgs: [ extractType(T) ] as [PhantomToTypeStr<ToPhantomTypeArgument<T>>], reifiedTypeArgs: [T], fromFields: (fields: Record<string, any>) => DecreeTicket.fromFields( T, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => DecreeTicket.fromFieldsWithTypes( T, item, ), fromBcs: (data: Uint8Array) => DecreeTicket.fromBcs( T, data, ), bcs: DecreeTicket.bcs, fromJSONField: (field: any) => DecreeTicket.fromJSONField( T, field, ), fromJSON: (json: Record<string, any>) => DecreeTicket.fromJSON( T, json, ), fromSuiParsedData: (content: SuiParsedData) => DecreeTicket.fromSuiParsedData( T, content, ), fetch: async (client: SuiClient, id: string) => DecreeTicket.fetch( client, T, id, ), new: ( fields: DecreeTicketFields<ToPhantomTypeArgument<T>>, ) => { return new DecreeTicket( [extractType(T)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return DecreeTicket.reified }
+
+ static phantom<T extends PhantomReified<PhantomTypeArgument>>( T: T ): PhantomReified<ToTypeStr<DecreeTicket<ToPhantomTypeArgument<T>>>> { return phantom(DecreeTicket.reified( T )); } static get p() { return DecreeTicket.phantom }
+
+ static get bcs() { return bcs.struct("DecreeTicket", {
+
+ governance_chain: bcs.u16(), governance_contract: ExternalAddress.bcs, module_name: Bytes32.bcs, action: bcs.u8(), global: bcs.bool()
+
+}) };
+
+ static fromFields<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, fields: Record<string, any> ): DecreeTicket<ToPhantomTypeArgument<T>> { return DecreeTicket.reified( typeArg, ).new( { governanceChain: decodeFromFields("u16", fields.governance_chain), governanceContract: decodeFromFields(ExternalAddress.reified(), fields.governance_contract), moduleName: decodeFromFields(Bytes32.reified(), fields.module_name), action: decodeFromFields("u8", fields.action), global: decodeFromFields("bool", fields.global) } ) }
+
+ static fromFieldsWithTypes<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, item: FieldsWithTypes ): DecreeTicket<ToPhantomTypeArgument<T>> { if (!isDecreeTicket(item.type)) { throw new Error("not a DecreeTicket type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return DecreeTicket.reified( typeArg, ).new( { governanceChain: decodeFromFieldsWithTypes("u16", item.fields.governance_chain), governanceContract: decodeFromFieldsWithTypes(ExternalAddress.reified(), item.fields.governance_contract), moduleName: decodeFromFieldsWithTypes(Bytes32.reified(), item.fields.module_name), action: decodeFromFieldsWithTypes("u8", item.fields.action), global: decodeFromFieldsWithTypes("bool", item.fields.global) } ) }
+
+ static fromBcs<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, data: Uint8Array ): DecreeTicket<ToPhantomTypeArgument<T>> { return DecreeTicket.fromFields( typeArg, DecreeTicket.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ governanceChain: this.governanceChain,governanceContract: this.governanceContract.toJSONField(),moduleName: this.moduleName.toJSONField(),action: this.action,global: this.global,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, field: any ): DecreeTicket<ToPhantomTypeArgument<T>> { return DecreeTicket.reified( typeArg, ).new( { governanceChain: decodeFromJSONField("u16", field.governanceChain), governanceContract: decodeFromJSONField(ExternalAddress.reified(), field.governanceContract), moduleName: decodeFromJSONField(Bytes32.reified(), field.moduleName), action: decodeFromJSONField("u8", field.action), global: decodeFromJSONField("bool", field.global) } ) }
+
+ static fromJSON<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, json: Record<string, any> ): DecreeTicket<ToPhantomTypeArgument<T>> { if (json.$typeName !== DecreeTicket.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(DecreeTicket.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return DecreeTicket.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, content: SuiParsedData ): DecreeTicket<ToPhantomTypeArgument<T>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isDecreeTicket(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a DecreeTicket object`); } return DecreeTicket.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<T extends PhantomReified<PhantomTypeArgument>>( client: SuiClient, typeArg: T, id: string ): Promise<DecreeTicket<ToPhantomTypeArgument<T>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching DecreeTicket object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isDecreeTicket(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a DecreeTicket object`); }
+ return DecreeTicket.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

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

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

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

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

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

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/index.ts

@@ -0,0 +1 @@
+export const PACKAGE_ID = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e"; export const PUBLISHED_AT = "0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e";

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/init.ts

@@ -0,0 +1,65 @@
+import * as bytes20 from "./bytes20/structs";
+import * as bytes32 from "./bytes32/structs";
+import * as consumedVaas from "./consumed-vaas/structs";
+import * as cursor from "./cursor/structs";
+import * as emitter from "./emitter/structs";
+import * as externalAddress from "./external-address/structs";
+import * as feeCollector from "./fee-collector/structs";
+import * as governanceMessage from "./governance-message/structs";
+import * as guardianSet from "./guardian-set/structs";
+import * as guardianSignature from "./guardian-signature/structs";
+import * as guardian from "./guardian/structs";
+import * as migrate from "./migrate/structs";
+import * as packageUtils from "./package-utils/structs";
+import * as publishMessage from "./publish-message/structs";
+import * as setFee from "./set-fee/structs";
+import * as set from "./set/structs";
+import * as setup from "./setup/structs";
+import * as state from "./state/structs";
+import * as transferFee from "./transfer-fee/structs";
+import * as updateGuardianSet from "./update-guardian-set/structs";
+import * as upgradeContract from "./upgrade-contract/structs";
+import * as vaa from "./vaa/structs";
+import * as versionControl from "./version-control/structs";
+import {StructClassLoader} from "../../../_framework/loader";
+
+export function registerClasses(loader: StructClassLoader) { loader.register(cursor.Cursor);
+loader.register(bytes32.Bytes32);
+loader.register(externalAddress.ExternalAddress);
+loader.register(packageUtils.CurrentVersion);
+loader.register(packageUtils.CurrentPackage);
+loader.register(packageUtils.PackageInfo);
+loader.register(packageUtils.PendingPackage);
+loader.register(set.Set);
+loader.register(set.Empty);
+loader.register(consumedVaas.ConsumedVAAs);
+loader.register(bytes20.Bytes20);
+loader.register(versionControl.V__DUMMY);
+loader.register(versionControl.V__0_2_0);
+loader.register(guardianSignature.GuardianSignature);
+loader.register(guardian.Guardian);
+loader.register(guardianSet.GuardianSet);
+loader.register(feeCollector.FeeCollector);
+loader.register(state.LatestOnly);
+loader.register(state.State);
+loader.register(vaa.VAA);
+loader.register(emitter.EmitterCap);
+loader.register(emitter.EmitterCreated);
+loader.register(emitter.EmitterDestroyed);
+loader.register(governanceMessage.DecreeReceipt);
+loader.register(governanceMessage.DecreeTicket);
+loader.register(upgradeContract.ContractUpgraded);
+loader.register(upgradeContract.GovernanceWitness);
+loader.register(upgradeContract.UpgradeContract);
+loader.register(migrate.MigrateComplete);
+loader.register(publishMessage.MessageTicket);
+loader.register(publishMessage.WormholeMessage);
+loader.register(setFee.GovernanceWitness);
+loader.register(setFee.SetFee);
+loader.register(setup.DeployerCap);
+loader.register(transferFee.GovernanceWitness);
+loader.register(transferFee.TransferFee);
+loader.register(updateGuardianSet.GovernanceWitness);
+loader.register(updateGuardianSet.GuardianSetAdded);
+loader.register(updateGuardianSet.UpdateGuardianSet);
+ }

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