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

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

@@ -0,0 +1,136 @@
+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 {PriceInfo} from "../price-info/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== BatchPriceAttestation =============================== */
+
+export function isBatchPriceAttestation(type: string): boolean { type = compressSuiType(type); return type === "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::batch_price_attestation::BatchPriceAttestation"; }
+
+export interface BatchPriceAttestationFields { header: ToField<Header>; attestationSize: ToField<"u64">; attestationCount: ToField<"u64">; priceInfos: ToField<Vector<PriceInfo>> }
+
+export type BatchPriceAttestationReified = Reified< BatchPriceAttestation, BatchPriceAttestationFields >;
+
+export class BatchPriceAttestation implements StructClass { static readonly $typeName = "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::batch_price_attestation::BatchPriceAttestation"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = BatchPriceAttestation.$typeName;
+
+ readonly $fullTypeName: "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::batch_price_attestation::BatchPriceAttestation";
+
+ readonly $typeArgs: [];
+
+ readonly header: ToField<Header>; readonly attestationSize: ToField<"u64">; readonly attestationCount: ToField<"u64">; readonly priceInfos: ToField<Vector<PriceInfo>>
+
+ private constructor(typeArgs: [], fields: BatchPriceAttestationFields, ) { this.$fullTypeName = composeSuiType( BatchPriceAttestation.$typeName, ...typeArgs ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::batch_price_attestation::BatchPriceAttestation"; this.$typeArgs = typeArgs;
+
+ this.header = fields.header;; this.attestationSize = fields.attestationSize;; this.attestationCount = fields.attestationCount;; this.priceInfos = fields.priceInfos; }
+
+ static reified( ): BatchPriceAttestationReified { return { typeName: BatchPriceAttestation.$typeName, fullTypeName: composeSuiType( BatchPriceAttestation.$typeName, ...[] ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::batch_price_attestation::BatchPriceAttestation", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => BatchPriceAttestation.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => BatchPriceAttestation.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => BatchPriceAttestation.fromBcs( data, ), bcs: BatchPriceAttestation.bcs, fromJSONField: (field: any) => BatchPriceAttestation.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => BatchPriceAttestation.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => BatchPriceAttestation.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => BatchPriceAttestation.fetch( client, id, ), new: ( fields: BatchPriceAttestationFields, ) => { return new BatchPriceAttestation( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return BatchPriceAttestation.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<BatchPriceAttestation>> { return phantom(BatchPriceAttestation.reified( )); } static get p() { return BatchPriceAttestation.phantom() }
+
+ static get bcs() { return bcs.struct("BatchPriceAttestation", {
+
+ header: Header.bcs, attestation_size: bcs.u64(), attestation_count: bcs.u64(), price_infos: bcs.vector(PriceInfo.bcs)
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): BatchPriceAttestation { return BatchPriceAttestation.reified( ).new( { header: decodeFromFields(Header.reified(), fields.header), attestationSize: decodeFromFields("u64", fields.attestation_size), attestationCount: decodeFromFields("u64", fields.attestation_count), priceInfos: decodeFromFields(reified.vector(PriceInfo.reified()), fields.price_infos) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): BatchPriceAttestation { if (!isBatchPriceAttestation(item.type)) { throw new Error("not a BatchPriceAttestation type");
+
+ }
+
+ return BatchPriceAttestation.reified( ).new( { header: decodeFromFieldsWithTypes(Header.reified(), item.fields.header), attestationSize: decodeFromFieldsWithTypes("u64", item.fields.attestation_size), attestationCount: decodeFromFieldsWithTypes("u64", item.fields.attestation_count), priceInfos: decodeFromFieldsWithTypes(reified.vector(PriceInfo.reified()), item.fields.price_infos) } ) }
+
+ static fromBcs( data: Uint8Array ): BatchPriceAttestation { return BatchPriceAttestation.fromFields( BatchPriceAttestation.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ header: this.header.toJSONField(),attestationSize: this.attestationSize.toString(),attestationCount: this.attestationCount.toString(),priceInfos: fieldToJSON<Vector<PriceInfo>>(`vector<0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::price_info::PriceInfo>`, this.priceInfos),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): BatchPriceAttestation { return BatchPriceAttestation.reified( ).new( { header: decodeFromJSONField(Header.reified(), field.header), attestationSize: decodeFromJSONField("u64", field.attestationSize), attestationCount: decodeFromJSONField("u64", field.attestationCount), priceInfos: decodeFromJSONField(reified.vector(PriceInfo.reified()), field.priceInfos) } ) }
+
+ static fromJSON( json: Record<string, any> ): BatchPriceAttestation { if (json.$typeName !== BatchPriceAttestation.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return BatchPriceAttestation.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): BatchPriceAttestation { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isBatchPriceAttestation(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a BatchPriceAttestation object`); } return BatchPriceAttestation.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<BatchPriceAttestation> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching BatchPriceAttestation object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isBatchPriceAttestation(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a BatchPriceAttestation object`); }
+ return BatchPriceAttestation.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== Header =============================== */
+
+export function isHeader(type: string): boolean { type = compressSuiType(type); return type === "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::batch_price_attestation::Header"; }
+
+export interface HeaderFields { magic: ToField<"u64">; versionMajor: ToField<"u64">; versionMinor: ToField<"u64">; headerSize: ToField<"u64">; payloadId: ToField<"u8"> }
+
+export type HeaderReified = Reified< Header, HeaderFields >;
+
+export class Header implements StructClass { static readonly $typeName = "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::batch_price_attestation::Header"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Header.$typeName;
+
+ readonly $fullTypeName: "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::batch_price_attestation::Header";
+
+ readonly $typeArgs: [];
+
+ readonly magic: ToField<"u64">; readonly versionMajor: ToField<"u64">; readonly versionMinor: ToField<"u64">; readonly headerSize: ToField<"u64">; readonly payloadId: ToField<"u8">
+
+ private constructor(typeArgs: [], fields: HeaderFields, ) { this.$fullTypeName = composeSuiType( Header.$typeName, ...typeArgs ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::batch_price_attestation::Header"; this.$typeArgs = typeArgs;
+
+ this.magic = fields.magic;; this.versionMajor = fields.versionMajor;; this.versionMinor = fields.versionMinor;; this.headerSize = fields.headerSize;; this.payloadId = fields.payloadId; }
+
+ static reified( ): HeaderReified { return { typeName: Header.$typeName, fullTypeName: composeSuiType( Header.$typeName, ...[] ) as "0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3::batch_price_attestation::Header", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Header.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Header.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Header.fromBcs( data, ), bcs: Header.bcs, fromJSONField: (field: any) => Header.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Header.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Header.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Header.fetch( client, id, ), new: ( fields: HeaderFields, ) => { return new Header( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Header.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Header>> { return phantom(Header.reified( )); } static get p() { return Header.phantom() }
+
+ static get bcs() { return bcs.struct("Header", {
+
+ magic: bcs.u64(), version_major: bcs.u64(), version_minor: bcs.u64(), header_size: bcs.u64(), payload_id: bcs.u8()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Header { return Header.reified( ).new( { magic: decodeFromFields("u64", fields.magic), versionMajor: decodeFromFields("u64", fields.version_major), versionMinor: decodeFromFields("u64", fields.version_minor), headerSize: decodeFromFields("u64", fields.header_size), payloadId: decodeFromFields("u8", fields.payload_id) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Header { if (!isHeader(item.type)) { throw new Error("not a Header type");
+
+ }
+
+ return Header.reified( ).new( { magic: decodeFromFieldsWithTypes("u64", item.fields.magic), versionMajor: decodeFromFieldsWithTypes("u64", item.fields.version_major), versionMinor: decodeFromFieldsWithTypes("u64", item.fields.version_minor), headerSize: decodeFromFieldsWithTypes("u64", item.fields.header_size), payloadId: decodeFromFieldsWithTypes("u8", item.fields.payload_id) } ) }
+
+ static fromBcs( data: Uint8Array ): Header { return Header.fromFields( Header.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ magic: this.magic.toString(),versionMajor: this.versionMajor.toString(),versionMinor: this.versionMinor.toString(),headerSize: this.headerSize.toString(),payloadId: this.payloadId,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Header { return Header.reified( ).new( { magic: decodeFromJSONField("u64", field.magic), versionMajor: decodeFromJSONField("u64", field.versionMajor), versionMinor: decodeFromJSONField("u64", field.versionMinor), headerSize: decodeFromJSONField("u64", field.headerSize), payloadId: decodeFromJSONField("u8", field.payloadId) } ) }
+
+ static fromJSON( json: Record<string, any> ): Header { if (json.$typeName !== Header.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Header.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Header { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isHeader(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Header object`); } return Header.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Header> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Header object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isHeader(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Header object`); }
+ return Header.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

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

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

package/src/_dependencies/source/0xe76d8a37d4132278a7a752183e90e04890b9e7d0f6657eadb68821609a2a56a3/data-source/structs.ts

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

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

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

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