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

package/src/_dependencies/source/0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3/governance-action/structs.ts

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

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

package/src/_dependencies/source/0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3/hot-potato-vector/structs.ts

@@ -0,0 +1,72 @@
+import * as reified from "../../../../_framework/reified";
+import {PhantomReified, Reified, StructClass, ToField, ToTypeArgument, ToTypeStr, TypeArgument, Vector, assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, toBcs} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {BcsType, bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== HotPotatoVector =============================== */
+
+export function isHotPotatoVector(type: string): boolean { type = compressSuiType(type); return type.startsWith("0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::hot_potato_vector::HotPotatoVector<"); }
+
+export interface HotPotatoVectorFields<T extends TypeArgument> { contents: ToField<Vector<T>> }
+
+export type HotPotatoVectorReified<T extends TypeArgument> = Reified< HotPotatoVector<T>, HotPotatoVectorFields<T> >;
+
+export class HotPotatoVector<T extends TypeArgument> implements StructClass { static readonly $typeName = "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::hot_potato_vector::HotPotatoVector"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = HotPotatoVector.$typeName;
+
+ readonly $fullTypeName: `0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::hot_potato_vector::HotPotatoVector<${ToTypeStr<T>}>`;
+
+ readonly $typeArgs: [ToTypeStr<T>];
+
+ readonly contents: ToField<Vector<T>>
+
+ private constructor(typeArgs: [ToTypeStr<T>], fields: HotPotatoVectorFields<T>, ) { this.$fullTypeName = composeSuiType( HotPotatoVector.$typeName, ...typeArgs ) as `0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::hot_potato_vector::HotPotatoVector<${ToTypeStr<T>}>`; this.$typeArgs = typeArgs;
+
+ this.contents = fields.contents; }
+
+ static reified<T extends Reified<TypeArgument, any>>( T: T ): HotPotatoVectorReified<ToTypeArgument<T>> { return { typeName: HotPotatoVector.$typeName, fullTypeName: composeSuiType( HotPotatoVector.$typeName, ...[extractType(T)] ) as `0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::hot_potato_vector::HotPotatoVector<${ToTypeStr<ToTypeArgument<T>>}>`, typeArgs: [ extractType(T) ] as [ToTypeStr<ToTypeArgument<T>>], reifiedTypeArgs: [T], fromFields: (fields: Record<string, any>) => HotPotatoVector.fromFields( T, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => HotPotatoVector.fromFieldsWithTypes( T, item, ), fromBcs: (data: Uint8Array) => HotPotatoVector.fromBcs( T, data, ), bcs: HotPotatoVector.bcs(toBcs(T)), fromJSONField: (field: any) => HotPotatoVector.fromJSONField( T, field, ), fromJSON: (json: Record<string, any>) => HotPotatoVector.fromJSON( T, json, ), fromSuiParsedData: (content: SuiParsedData) => HotPotatoVector.fromSuiParsedData( T, content, ), fetch: async (client: SuiClient, id: string) => HotPotatoVector.fetch( client, T, id, ), new: ( fields: HotPotatoVectorFields<ToTypeArgument<T>>, ) => { return new HotPotatoVector( [extractType(T)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return HotPotatoVector.reified }
+
+ static phantom<T extends Reified<TypeArgument, any>>( T: T ): PhantomReified<ToTypeStr<HotPotatoVector<ToTypeArgument<T>>>> { return phantom(HotPotatoVector.reified( T )); } static get p() { return HotPotatoVector.phantom }
+
+ static get bcs() { return <T extends BcsType<any>>(T: T) => bcs.struct(`HotPotatoVector<${T.name}>`, {
+
+ contents: bcs.vector(T)
+
+}) };
+
+ static fromFields<T extends Reified<TypeArgument, any>>( typeArg: T, fields: Record<string, any> ): HotPotatoVector<ToTypeArgument<T>> { return HotPotatoVector.reified( typeArg, ).new( { contents: decodeFromFields(reified.vector(typeArg), fields.contents) } ) }
+
+ static fromFieldsWithTypes<T extends Reified<TypeArgument, any>>( typeArg: T, item: FieldsWithTypes ): HotPotatoVector<ToTypeArgument<T>> { if (!isHotPotatoVector(item.type)) { throw new Error("not a HotPotatoVector type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return HotPotatoVector.reified( typeArg, ).new( { contents: decodeFromFieldsWithTypes(reified.vector(typeArg), item.fields.contents) } ) }
+
+ static fromBcs<T extends Reified<TypeArgument, any>>( typeArg: T, data: Uint8Array ): HotPotatoVector<ToTypeArgument<T>> { const typeArgs = [typeArg];
+
+ return HotPotatoVector.fromFields( typeArg, HotPotatoVector.bcs( toBcs(typeArgs[0]) ).parse(data) ) }
+
+ toJSONField() { return {
+
+ contents: fieldToJSON<Vector<T>>(`vector<${this.$typeArgs[0]}>`, this.contents),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<T extends Reified<TypeArgument, any>>( typeArg: T, field: any ): HotPotatoVector<ToTypeArgument<T>> { return HotPotatoVector.reified( typeArg, ).new( { contents: decodeFromJSONField(reified.vector(typeArg), field.contents) } ) }
+
+ static fromJSON<T extends Reified<TypeArgument, any>>( typeArg: T, json: Record<string, any> ): HotPotatoVector<ToTypeArgument<T>> { if (json.$typeName !== HotPotatoVector.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(HotPotatoVector.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return HotPotatoVector.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<T extends Reified<TypeArgument, any>>( typeArg: T, content: SuiParsedData ): HotPotatoVector<ToTypeArgument<T>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isHotPotatoVector(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a HotPotatoVector object`); } return HotPotatoVector.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<T extends Reified<TypeArgument, any>>( client: SuiClient, typeArg: T, id: string ): Promise<HotPotatoVector<ToTypeArgument<T>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching HotPotatoVector object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isHotPotatoVector(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a HotPotatoVector object`); }
+ return HotPotatoVector.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

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

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

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

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

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

@@ -0,0 +1,59 @@
+import * as batchPriceAttestation from "./batch-price-attestation/structs";
+import * as contractUpgrade from "./contract-upgrade/structs";
+import * as dataSource from "./data-source/structs";
+import * as event from "./event/structs";
+import * as governanceAction from "./governance-action/structs";
+import * as governanceInstruction from "./governance-instruction/structs";
+import * as governance from "./governance/structs";
+import * as hotPotatoVector from "./hot-potato-vector/structs";
+import * as i64 from "./i64/structs";
+import * as migrate from "./migrate/structs";
+import * as priceFeed from "./price-feed/structs";
+import * as priceIdentifier from "./price-identifier/structs";
+import * as priceInfo from "./price-info/structs";
+import * as priceStatus from "./price-status/structs";
+import * as price from "./price/structs";
+import * as setDataSources from "./set-data-sources/structs";
+import * as setFeeRecipient from "./set-fee-recipient/structs";
+import * as setGovernanceDataSource from "./set-governance-data-source/structs";
+import * as setStalePriceThreshold from "./set-stale-price-threshold/structs";
+import * as setUpdateFee from "./set-update-fee/structs";
+import * as set from "./set/structs";
+import * as setup from "./setup/structs";
+import * as state from "./state/structs";
+import * as versionControl from "./version-control/structs";
+import {StructClassLoader} from "../../../_framework/loader";
+
+export function registerClasses(loader: StructClassLoader) { loader.register(versionControl.V__0_1_1);
+loader.register(versionControl.V__DUMMY);
+loader.register(priceIdentifier.PriceIdentifier);
+loader.register(i64.I64);
+loader.register(price.Price);
+loader.register(priceFeed.PriceFeed);
+loader.register(priceInfo.PriceInfo);
+loader.register(priceInfo.PriceInfoObject);
+loader.register(event.PriceFeedUpdateEvent);
+loader.register(event.PythInitializationEvent);
+loader.register(set.Set);
+loader.register(set.Unit);
+loader.register(dataSource.DataSource);
+loader.register(state.CurrentDigest);
+loader.register(state.LatestOnly);
+loader.register(state.State);
+loader.register(setup.DeployerCap);
+loader.register(hotPotatoVector.HotPotatoVector);
+loader.register(priceStatus.PriceStatus);
+loader.register(batchPriceAttestation.BatchPriceAttestation);
+loader.register(batchPriceAttestation.Header);
+loader.register(governanceAction.GovernanceAction);
+loader.register(governanceInstruction.GovernanceInstruction);
+loader.register(setUpdateFee.UpdateFee);
+loader.register(setStalePriceThreshold.StalePriceThreshold);
+loader.register(setGovernanceDataSource.GovernanceDataSource);
+loader.register(setFeeRecipient.PythFeeRecipient);
+loader.register(setDataSources.DataSources);
+loader.register(governance.WormholeVAAVerificationReceipt);
+loader.register(contractUpgrade.ContractUpgraded);
+loader.register(contractUpgrade.UpgradeContract);
+loader.register(migrate.MigrateComplete);
+ }

package/src/_dependencies/source/0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3/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 === "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::migrate::MigrateComplete"; }
+
+export interface MigrateCompleteFields { package: ToField<ID> }
+
+export type MigrateCompleteReified = Reified< MigrateComplete, MigrateCompleteFields >;
+
+export class MigrateComplete implements StructClass { static readonly $typeName = "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::migrate::MigrateComplete"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = MigrateComplete.$typeName;
+
+ readonly $fullTypeName: "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::migrate::MigrateComplete";
+
+ readonly $typeArgs: [];
+
+ readonly package: ToField<ID>
+
+ private constructor(typeArgs: [], fields: MigrateCompleteFields, ) { this.$fullTypeName = composeSuiType( MigrateComplete.$typeName, ...typeArgs ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::migrate::MigrateComplete"; this.$typeArgs = typeArgs;
+
+ this.package = fields.package; }
+
+ static reified( ): MigrateCompleteReified { return { typeName: MigrateComplete.$typeName, fullTypeName: composeSuiType( MigrateComplete.$typeName, ...[] ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::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) ); }
+
+ }

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

package/src/_dependencies/source/0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3/price-feed/structs.ts

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