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

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

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

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

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

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

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

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

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