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

package/src/_dependencies/source/0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73/pyth-parser/structs.ts

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

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

package/src/_dependencies/source/0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73/switchboard-feed-parser/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";
+
+/* ============================== AggregatorInfo =============================== */
+
+export function isAggregatorInfo(type: string): boolean { type = compressSuiType(type); return type === "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::switchboard_feed_parser::AggregatorInfo"; }
+
+export interface AggregatorInfoFields { aggregatorAddr: ToField<"address">; latestResult: ToField<"u128">; latestResultScalingFactor: ToField<"u8">; latestTimestamp: ToField<"u64">; negative: ToField<"bool"> }
+
+export type AggregatorInfoReified = Reified< AggregatorInfo, AggregatorInfoFields >;
+
+export class AggregatorInfo implements StructClass { static readonly $typeName = "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::switchboard_feed_parser::AggregatorInfo"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = AggregatorInfo.$typeName;
+
+ readonly $fullTypeName: "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::switchboard_feed_parser::AggregatorInfo";
+
+ readonly $typeArgs: [];
+
+ readonly aggregatorAddr: ToField<"address">; readonly latestResult: ToField<"u128">; readonly latestResultScalingFactor: ToField<"u8">; readonly latestTimestamp: ToField<"u64">; readonly negative: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: AggregatorInfoFields, ) { this.$fullTypeName = composeSuiType( AggregatorInfo.$typeName, ...typeArgs ) as "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::switchboard_feed_parser::AggregatorInfo"; this.$typeArgs = typeArgs;
+
+ this.aggregatorAddr = fields.aggregatorAddr;; this.latestResult = fields.latestResult;; this.latestResultScalingFactor = fields.latestResultScalingFactor;; this.latestTimestamp = fields.latestTimestamp;; this.negative = fields.negative; }
+
+ static reified( ): AggregatorInfoReified { return { typeName: AggregatorInfo.$typeName, fullTypeName: composeSuiType( AggregatorInfo.$typeName, ...[] ) as "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::switchboard_feed_parser::AggregatorInfo", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => AggregatorInfo.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => AggregatorInfo.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => AggregatorInfo.fromBcs( data, ), bcs: AggregatorInfo.bcs, fromJSONField: (field: any) => AggregatorInfo.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => AggregatorInfo.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => AggregatorInfo.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => AggregatorInfo.fetch( client, id, ), new: ( fields: AggregatorInfoFields, ) => { return new AggregatorInfo( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return AggregatorInfo.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<AggregatorInfo>> { return phantom(AggregatorInfo.reified( )); } static get p() { return AggregatorInfo.phantom() }
+
+ static get bcs() { return bcs.struct("AggregatorInfo", {
+
+ aggregator_addr: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), latest_result: bcs.u128(), latest_result_scaling_factor: bcs.u8(), latest_timestamp: bcs.u64(), negative: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): AggregatorInfo { return AggregatorInfo.reified( ).new( { aggregatorAddr: decodeFromFields("address", fields.aggregator_addr), latestResult: decodeFromFields("u128", fields.latest_result), latestResultScalingFactor: decodeFromFields("u8", fields.latest_result_scaling_factor), latestTimestamp: decodeFromFields("u64", fields.latest_timestamp), negative: decodeFromFields("bool", fields.negative) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): AggregatorInfo { if (!isAggregatorInfo(item.type)) { throw new Error("not a AggregatorInfo type");
+
+ }
+
+ return AggregatorInfo.reified( ).new( { aggregatorAddr: decodeFromFieldsWithTypes("address", item.fields.aggregator_addr), latestResult: decodeFromFieldsWithTypes("u128", item.fields.latest_result), latestResultScalingFactor: decodeFromFieldsWithTypes("u8", item.fields.latest_result_scaling_factor), latestTimestamp: decodeFromFieldsWithTypes("u64", item.fields.latest_timestamp), negative: decodeFromFieldsWithTypes("bool", item.fields.negative) } ) }
+
+ static fromBcs( data: Uint8Array ): AggregatorInfo { return AggregatorInfo.fromFields( AggregatorInfo.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ aggregatorAddr: this.aggregatorAddr,latestResult: this.latestResult.toString(),latestResultScalingFactor: this.latestResultScalingFactor,latestTimestamp: this.latestTimestamp.toString(),negative: this.negative,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): AggregatorInfo { return AggregatorInfo.reified( ).new( { aggregatorAddr: decodeFromJSONField("address", field.aggregatorAddr), latestResult: decodeFromJSONField("u128", field.latestResult), latestResultScalingFactor: decodeFromJSONField("u8", field.latestResultScalingFactor), latestTimestamp: decodeFromJSONField("u64", field.latestTimestamp), negative: decodeFromJSONField("bool", field.negative) } ) }
+
+ static fromJSON( json: Record<string, any> ): AggregatorInfo { if (json.$typeName !== AggregatorInfo.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return AggregatorInfo.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): AggregatorInfo { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isAggregatorInfo(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a AggregatorInfo object`); } return AggregatorInfo.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<AggregatorInfo> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching AggregatorInfo object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isAggregatorInfo(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a AggregatorInfo object`); }
+ return AggregatorInfo.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }