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

package/src/_dependencies/source/0x2/display/structs.ts

@@ -0,0 +1,202 @@
+import {PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToPhantomTypeArgument, ToTypeStr, assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, phantom} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {String} from "../../0x1/string/structs";
+import {ID, UID} from "../object/structs";
+import {VecMap} from "../vec-map/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== Display =============================== */
+
+export function isDisplay(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x2::display::Display<"); }
+
+export interface DisplayFields<T extends PhantomTypeArgument> { id: ToField<UID>; fields: ToField<VecMap<String, String>>; version: ToField<"u16"> }
+
+export type DisplayReified<T extends PhantomTypeArgument> = Reified< Display<T>, DisplayFields<T> >;
+
+export class Display<T extends PhantomTypeArgument> implements StructClass { static readonly $typeName = "0x2::display::Display"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = Display.$typeName;
+
+ readonly $fullTypeName: `0x2::display::Display<${PhantomToTypeStr<T>}>`;
+
+ readonly $typeArgs: [PhantomToTypeStr<T>];
+
+ readonly id: ToField<UID>; readonly fields: ToField<VecMap<String, String>>; readonly version: ToField<"u16">
+
+ private constructor(typeArgs: [PhantomToTypeStr<T>], fields: DisplayFields<T>, ) { this.$fullTypeName = composeSuiType( Display.$typeName, ...typeArgs ) as `0x2::display::Display<${PhantomToTypeStr<T>}>`; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.fields = fields.fields;; this.version = fields.version; }
+
+ static reified<T extends PhantomReified<PhantomTypeArgument>>( T: T ): DisplayReified<ToPhantomTypeArgument<T>> { return { typeName: Display.$typeName, fullTypeName: composeSuiType( Display.$typeName, ...[extractType(T)] ) as `0x2::display::Display<${PhantomToTypeStr<ToPhantomTypeArgument<T>>}>`, typeArgs: [ extractType(T) ] as [PhantomToTypeStr<ToPhantomTypeArgument<T>>], reifiedTypeArgs: [T], fromFields: (fields: Record<string, any>) => Display.fromFields( T, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Display.fromFieldsWithTypes( T, item, ), fromBcs: (data: Uint8Array) => Display.fromBcs( T, data, ), bcs: Display.bcs, fromJSONField: (field: any) => Display.fromJSONField( T, field, ), fromJSON: (json: Record<string, any>) => Display.fromJSON( T, json, ), fromSuiParsedData: (content: SuiParsedData) => Display.fromSuiParsedData( T, content, ), fetch: async (client: SuiClient, id: string) => Display.fetch( client, T, id, ), new: ( fields: DisplayFields<ToPhantomTypeArgument<T>>, ) => { return new Display( [extractType(T)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Display.reified }
+
+ static phantom<T extends PhantomReified<PhantomTypeArgument>>( T: T ): PhantomReified<ToTypeStr<Display<ToPhantomTypeArgument<T>>>> { return phantom(Display.reified( T )); } static get p() { return Display.phantom }
+
+ static get bcs() { return bcs.struct("Display", {
+
+ id: UID.bcs, fields: VecMap.bcs(String.bcs, String.bcs), version: bcs.u16()
+
+}) };
+
+ static fromFields<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, fields: Record<string, any> ): Display<ToPhantomTypeArgument<T>> { return Display.reified( typeArg, ).new( { id: decodeFromFields(UID.reified(), fields.id), fields: decodeFromFields(VecMap.reified(String.reified(), String.reified()), fields.fields), version: decodeFromFields("u16", fields.version) } ) }
+
+ static fromFieldsWithTypes<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, item: FieldsWithTypes ): Display<ToPhantomTypeArgument<T>> { if (!isDisplay(item.type)) { throw new Error("not a Display type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return Display.reified( typeArg, ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), fields: decodeFromFieldsWithTypes(VecMap.reified(String.reified(), String.reified()), item.fields.fields), version: decodeFromFieldsWithTypes("u16", item.fields.version) } ) }
+
+ static fromBcs<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, data: Uint8Array ): Display<ToPhantomTypeArgument<T>> { return Display.fromFields( typeArg, Display.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,fields: this.fields.toJSONField(),version: this.version,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, field: any ): Display<ToPhantomTypeArgument<T>> { return Display.reified( typeArg, ).new( { id: decodeFromJSONField(UID.reified(), field.id), fields: decodeFromJSONField(VecMap.reified(String.reified(), String.reified()), field.fields), version: decodeFromJSONField("u16", field.version) } ) }
+
+ static fromJSON<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, json: Record<string, any> ): Display<ToPhantomTypeArgument<T>> { if (json.$typeName !== Display.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(Display.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return Display.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, content: SuiParsedData ): Display<ToPhantomTypeArgument<T>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isDisplay(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Display object`); } return Display.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<T extends PhantomReified<PhantomTypeArgument>>( client: SuiClient, typeArg: T, id: string ): Promise<Display<ToPhantomTypeArgument<T>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Display object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isDisplay(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Display object`); }
+ return Display.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== DisplayCreated =============================== */
+
+export function isDisplayCreated(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x2::display::DisplayCreated<"); }
+
+export interface DisplayCreatedFields<T extends PhantomTypeArgument> { id: ToField<ID> }
+
+export type DisplayCreatedReified<T extends PhantomTypeArgument> = Reified< DisplayCreated<T>, DisplayCreatedFields<T> >;
+
+export class DisplayCreated<T extends PhantomTypeArgument> implements StructClass { static readonly $typeName = "0x2::display::DisplayCreated"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = DisplayCreated.$typeName;
+
+ readonly $fullTypeName: `0x2::display::DisplayCreated<${PhantomToTypeStr<T>}>`;
+
+ readonly $typeArgs: [PhantomToTypeStr<T>];
+
+ readonly id: ToField<ID>
+
+ private constructor(typeArgs: [PhantomToTypeStr<T>], fields: DisplayCreatedFields<T>, ) { this.$fullTypeName = composeSuiType( DisplayCreated.$typeName, ...typeArgs ) as `0x2::display::DisplayCreated<${PhantomToTypeStr<T>}>`; this.$typeArgs = typeArgs;
+
+ this.id = fields.id; }
+
+ static reified<T extends PhantomReified<PhantomTypeArgument>>( T: T ): DisplayCreatedReified<ToPhantomTypeArgument<T>> { return { typeName: DisplayCreated.$typeName, fullTypeName: composeSuiType( DisplayCreated.$typeName, ...[extractType(T)] ) as `0x2::display::DisplayCreated<${PhantomToTypeStr<ToPhantomTypeArgument<T>>}>`, typeArgs: [ extractType(T) ] as [PhantomToTypeStr<ToPhantomTypeArgument<T>>], reifiedTypeArgs: [T], fromFields: (fields: Record<string, any>) => DisplayCreated.fromFields( T, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => DisplayCreated.fromFieldsWithTypes( T, item, ), fromBcs: (data: Uint8Array) => DisplayCreated.fromBcs( T, data, ), bcs: DisplayCreated.bcs, fromJSONField: (field: any) => DisplayCreated.fromJSONField( T, field, ), fromJSON: (json: Record<string, any>) => DisplayCreated.fromJSON( T, json, ), fromSuiParsedData: (content: SuiParsedData) => DisplayCreated.fromSuiParsedData( T, content, ), fetch: async (client: SuiClient, id: string) => DisplayCreated.fetch( client, T, id, ), new: ( fields: DisplayCreatedFields<ToPhantomTypeArgument<T>>, ) => { return new DisplayCreated( [extractType(T)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return DisplayCreated.reified }
+
+ static phantom<T extends PhantomReified<PhantomTypeArgument>>( T: T ): PhantomReified<ToTypeStr<DisplayCreated<ToPhantomTypeArgument<T>>>> { return phantom(DisplayCreated.reified( T )); } static get p() { return DisplayCreated.phantom }
+
+ static get bcs() { return bcs.struct("DisplayCreated", {
+
+ id: ID.bcs
+
+}) };
+
+ static fromFields<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, fields: Record<string, any> ): DisplayCreated<ToPhantomTypeArgument<T>> { return DisplayCreated.reified( typeArg, ).new( { id: decodeFromFields(ID.reified(), fields.id) } ) }
+
+ static fromFieldsWithTypes<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, item: FieldsWithTypes ): DisplayCreated<ToPhantomTypeArgument<T>> { if (!isDisplayCreated(item.type)) { throw new Error("not a DisplayCreated type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return DisplayCreated.reified( typeArg, ).new( { id: decodeFromFieldsWithTypes(ID.reified(), item.fields.id) } ) }
+
+ static fromBcs<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, data: Uint8Array ): DisplayCreated<ToPhantomTypeArgument<T>> { return DisplayCreated.fromFields( typeArg, DisplayCreated.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, field: any ): DisplayCreated<ToPhantomTypeArgument<T>> { return DisplayCreated.reified( typeArg, ).new( { id: decodeFromJSONField(ID.reified(), field.id) } ) }
+
+ static fromJSON<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, json: Record<string, any> ): DisplayCreated<ToPhantomTypeArgument<T>> { if (json.$typeName !== DisplayCreated.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(DisplayCreated.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return DisplayCreated.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, content: SuiParsedData ): DisplayCreated<ToPhantomTypeArgument<T>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isDisplayCreated(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a DisplayCreated object`); } return DisplayCreated.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<T extends PhantomReified<PhantomTypeArgument>>( client: SuiClient, typeArg: T, id: string ): Promise<DisplayCreated<ToPhantomTypeArgument<T>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching DisplayCreated object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isDisplayCreated(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a DisplayCreated object`); }
+ return DisplayCreated.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== VersionUpdated =============================== */
+
+export function isVersionUpdated(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x2::display::VersionUpdated<"); }
+
+export interface VersionUpdatedFields<T extends PhantomTypeArgument> { id: ToField<ID>; version: ToField<"u16">; fields: ToField<VecMap<String, String>> }
+
+export type VersionUpdatedReified<T extends PhantomTypeArgument> = Reified< VersionUpdated<T>, VersionUpdatedFields<T> >;
+
+export class VersionUpdated<T extends PhantomTypeArgument> implements StructClass { static readonly $typeName = "0x2::display::VersionUpdated"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = VersionUpdated.$typeName;
+
+ readonly $fullTypeName: `0x2::display::VersionUpdated<${PhantomToTypeStr<T>}>`;
+
+ readonly $typeArgs: [PhantomToTypeStr<T>];
+
+ readonly id: ToField<ID>; readonly version: ToField<"u16">; readonly fields: ToField<VecMap<String, String>>
+
+ private constructor(typeArgs: [PhantomToTypeStr<T>], fields: VersionUpdatedFields<T>, ) { this.$fullTypeName = composeSuiType( VersionUpdated.$typeName, ...typeArgs ) as `0x2::display::VersionUpdated<${PhantomToTypeStr<T>}>`; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.version = fields.version;; this.fields = fields.fields; }
+
+ static reified<T extends PhantomReified<PhantomTypeArgument>>( T: T ): VersionUpdatedReified<ToPhantomTypeArgument<T>> { return { typeName: VersionUpdated.$typeName, fullTypeName: composeSuiType( VersionUpdated.$typeName, ...[extractType(T)] ) as `0x2::display::VersionUpdated<${PhantomToTypeStr<ToPhantomTypeArgument<T>>}>`, typeArgs: [ extractType(T) ] as [PhantomToTypeStr<ToPhantomTypeArgument<T>>], reifiedTypeArgs: [T], fromFields: (fields: Record<string, any>) => VersionUpdated.fromFields( T, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => VersionUpdated.fromFieldsWithTypes( T, item, ), fromBcs: (data: Uint8Array) => VersionUpdated.fromBcs( T, data, ), bcs: VersionUpdated.bcs, fromJSONField: (field: any) => VersionUpdated.fromJSONField( T, field, ), fromJSON: (json: Record<string, any>) => VersionUpdated.fromJSON( T, json, ), fromSuiParsedData: (content: SuiParsedData) => VersionUpdated.fromSuiParsedData( T, content, ), fetch: async (client: SuiClient, id: string) => VersionUpdated.fetch( client, T, id, ), new: ( fields: VersionUpdatedFields<ToPhantomTypeArgument<T>>, ) => { return new VersionUpdated( [extractType(T)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return VersionUpdated.reified }
+
+ static phantom<T extends PhantomReified<PhantomTypeArgument>>( T: T ): PhantomReified<ToTypeStr<VersionUpdated<ToPhantomTypeArgument<T>>>> { return phantom(VersionUpdated.reified( T )); } static get p() { return VersionUpdated.phantom }
+
+ static get bcs() { return bcs.struct("VersionUpdated", {
+
+ id: ID.bcs, version: bcs.u16(), fields: VecMap.bcs(String.bcs, String.bcs)
+
+}) };
+
+ static fromFields<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, fields: Record<string, any> ): VersionUpdated<ToPhantomTypeArgument<T>> { return VersionUpdated.reified( typeArg, ).new( { id: decodeFromFields(ID.reified(), fields.id), version: decodeFromFields("u16", fields.version), fields: decodeFromFields(VecMap.reified(String.reified(), String.reified()), fields.fields) } ) }
+
+ static fromFieldsWithTypes<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, item: FieldsWithTypes ): VersionUpdated<ToPhantomTypeArgument<T>> { if (!isVersionUpdated(item.type)) { throw new Error("not a VersionUpdated type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return VersionUpdated.reified( typeArg, ).new( { id: decodeFromFieldsWithTypes(ID.reified(), item.fields.id), version: decodeFromFieldsWithTypes("u16", item.fields.version), fields: decodeFromFieldsWithTypes(VecMap.reified(String.reified(), String.reified()), item.fields.fields) } ) }
+
+ static fromBcs<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, data: Uint8Array ): VersionUpdated<ToPhantomTypeArgument<T>> { return VersionUpdated.fromFields( typeArg, VersionUpdated.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,version: this.version,fields: this.fields.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, field: any ): VersionUpdated<ToPhantomTypeArgument<T>> { return VersionUpdated.reified( typeArg, ).new( { id: decodeFromJSONField(ID.reified(), field.id), version: decodeFromJSONField("u16", field.version), fields: decodeFromJSONField(VecMap.reified(String.reified(), String.reified()), field.fields) } ) }
+
+ static fromJSON<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, json: Record<string, any> ): VersionUpdated<ToPhantomTypeArgument<T>> { if (json.$typeName !== VersionUpdated.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(VersionUpdated.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return VersionUpdated.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<T extends PhantomReified<PhantomTypeArgument>>( typeArg: T, content: SuiParsedData ): VersionUpdated<ToPhantomTypeArgument<T>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isVersionUpdated(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a VersionUpdated object`); } return VersionUpdated.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<T extends PhantomReified<PhantomTypeArgument>>( client: SuiClient, typeArg: T, id: string ): Promise<VersionUpdated<ToPhantomTypeArgument<T>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching VersionUpdated object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isVersionUpdated(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a VersionUpdated object`); }
+ return VersionUpdated.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0x2/dynamic-field/structs.ts

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

package/src/_dependencies/source/0x2/dynamic-object-field/structs.ts

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

package/src/_dependencies/source/0x2/groth16/structs.ts

@@ -0,0 +1,265 @@
+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";
+
+/* ============================== Curve =============================== */
+
+export function isCurve(type: string): boolean { type = compressSuiType(type); return type === "0x2::groth16::Curve"; }
+
+export interface CurveFields { id: ToField<"u8"> }
+
+export type CurveReified = Reified< Curve, CurveFields >;
+
+export class Curve implements StructClass { static readonly $typeName = "0x2::groth16::Curve"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Curve.$typeName;
+
+ readonly $fullTypeName: "0x2::groth16::Curve";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<"u8">
+
+ private constructor(typeArgs: [], fields: CurveFields, ) { this.$fullTypeName = composeSuiType( Curve.$typeName, ...typeArgs ) as "0x2::groth16::Curve"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id; }
+
+ static reified( ): CurveReified { return { typeName: Curve.$typeName, fullTypeName: composeSuiType( Curve.$typeName, ...[] ) as "0x2::groth16::Curve", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Curve.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Curve.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Curve.fromBcs( data, ), bcs: Curve.bcs, fromJSONField: (field: any) => Curve.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Curve.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Curve.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Curve.fetch( client, id, ), new: ( fields: CurveFields, ) => { return new Curve( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Curve.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Curve>> { return phantom(Curve.reified( )); } static get p() { return Curve.phantom() }
+
+ static get bcs() { return bcs.struct("Curve", {
+
+ id: bcs.u8()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Curve { return Curve.reified( ).new( { id: decodeFromFields("u8", fields.id) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Curve { if (!isCurve(item.type)) { throw new Error("not a Curve type");
+
+ }
+
+ return Curve.reified( ).new( { id: decodeFromFieldsWithTypes("u8", item.fields.id) } ) }
+
+ static fromBcs( data: Uint8Array ): Curve { return Curve.fromFields( Curve.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Curve { return Curve.reified( ).new( { id: decodeFromJSONField("u8", field.id) } ) }
+
+ static fromJSON( json: Record<string, any> ): Curve { if (json.$typeName !== Curve.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Curve.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Curve { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isCurve(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Curve object`); } return Curve.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Curve> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Curve object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isCurve(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Curve object`); }
+ return Curve.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== PreparedVerifyingKey =============================== */
+
+export function isPreparedVerifyingKey(type: string): boolean { type = compressSuiType(type); return type === "0x2::groth16::PreparedVerifyingKey"; }
+
+export interface PreparedVerifyingKeyFields { vkGammaAbcG1Bytes: ToField<Vector<"u8">>; alphaG1BetaG2Bytes: ToField<Vector<"u8">>; gammaG2NegPcBytes: ToField<Vector<"u8">>; deltaG2NegPcBytes: ToField<Vector<"u8">> }
+
+export type PreparedVerifyingKeyReified = Reified< PreparedVerifyingKey, PreparedVerifyingKeyFields >;
+
+export class PreparedVerifyingKey implements StructClass { static readonly $typeName = "0x2::groth16::PreparedVerifyingKey"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = PreparedVerifyingKey.$typeName;
+
+ readonly $fullTypeName: "0x2::groth16::PreparedVerifyingKey";
+
+ readonly $typeArgs: [];
+
+ readonly vkGammaAbcG1Bytes: ToField<Vector<"u8">>; readonly alphaG1BetaG2Bytes: ToField<Vector<"u8">>; readonly gammaG2NegPcBytes: ToField<Vector<"u8">>; readonly deltaG2NegPcBytes: ToField<Vector<"u8">>
+
+ private constructor(typeArgs: [], fields: PreparedVerifyingKeyFields, ) { this.$fullTypeName = composeSuiType( PreparedVerifyingKey.$typeName, ...typeArgs ) as "0x2::groth16::PreparedVerifyingKey"; this.$typeArgs = typeArgs;
+
+ this.vkGammaAbcG1Bytes = fields.vkGammaAbcG1Bytes;; this.alphaG1BetaG2Bytes = fields.alphaG1BetaG2Bytes;; this.gammaG2NegPcBytes = fields.gammaG2NegPcBytes;; this.deltaG2NegPcBytes = fields.deltaG2NegPcBytes; }
+
+ static reified( ): PreparedVerifyingKeyReified { return { typeName: PreparedVerifyingKey.$typeName, fullTypeName: composeSuiType( PreparedVerifyingKey.$typeName, ...[] ) as "0x2::groth16::PreparedVerifyingKey", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => PreparedVerifyingKey.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => PreparedVerifyingKey.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => PreparedVerifyingKey.fromBcs( data, ), bcs: PreparedVerifyingKey.bcs, fromJSONField: (field: any) => PreparedVerifyingKey.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => PreparedVerifyingKey.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => PreparedVerifyingKey.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => PreparedVerifyingKey.fetch( client, id, ), new: ( fields: PreparedVerifyingKeyFields, ) => { return new PreparedVerifyingKey( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return PreparedVerifyingKey.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<PreparedVerifyingKey>> { return phantom(PreparedVerifyingKey.reified( )); } static get p() { return PreparedVerifyingKey.phantom() }
+
+ static get bcs() { return bcs.struct("PreparedVerifyingKey", {
+
+ vk_gamma_abc_g1_bytes: bcs.vector(bcs.u8()), alpha_g1_beta_g2_bytes: bcs.vector(bcs.u8()), gamma_g2_neg_pc_bytes: bcs.vector(bcs.u8()), delta_g2_neg_pc_bytes: bcs.vector(bcs.u8())
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): PreparedVerifyingKey { return PreparedVerifyingKey.reified( ).new( { vkGammaAbcG1Bytes: decodeFromFields(reified.vector("u8"), fields.vk_gamma_abc_g1_bytes), alphaG1BetaG2Bytes: decodeFromFields(reified.vector("u8"), fields.alpha_g1_beta_g2_bytes), gammaG2NegPcBytes: decodeFromFields(reified.vector("u8"), fields.gamma_g2_neg_pc_bytes), deltaG2NegPcBytes: decodeFromFields(reified.vector("u8"), fields.delta_g2_neg_pc_bytes) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): PreparedVerifyingKey { if (!isPreparedVerifyingKey(item.type)) { throw new Error("not a PreparedVerifyingKey type");
+
+ }
+
+ return PreparedVerifyingKey.reified( ).new( { vkGammaAbcG1Bytes: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.vk_gamma_abc_g1_bytes), alphaG1BetaG2Bytes: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.alpha_g1_beta_g2_bytes), gammaG2NegPcBytes: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.gamma_g2_neg_pc_bytes), deltaG2NegPcBytes: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.delta_g2_neg_pc_bytes) } ) }
+
+ static fromBcs( data: Uint8Array ): PreparedVerifyingKey { return PreparedVerifyingKey.fromFields( PreparedVerifyingKey.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ vkGammaAbcG1Bytes: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.vkGammaAbcG1Bytes),alphaG1BetaG2Bytes: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.alphaG1BetaG2Bytes),gammaG2NegPcBytes: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.gammaG2NegPcBytes),deltaG2NegPcBytes: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.deltaG2NegPcBytes),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): PreparedVerifyingKey { return PreparedVerifyingKey.reified( ).new( { vkGammaAbcG1Bytes: decodeFromJSONField(reified.vector("u8"), field.vkGammaAbcG1Bytes), alphaG1BetaG2Bytes: decodeFromJSONField(reified.vector("u8"), field.alphaG1BetaG2Bytes), gammaG2NegPcBytes: decodeFromJSONField(reified.vector("u8"), field.gammaG2NegPcBytes), deltaG2NegPcBytes: decodeFromJSONField(reified.vector("u8"), field.deltaG2NegPcBytes) } ) }
+
+ static fromJSON( json: Record<string, any> ): PreparedVerifyingKey { if (json.$typeName !== PreparedVerifyingKey.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return PreparedVerifyingKey.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): PreparedVerifyingKey { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isPreparedVerifyingKey(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a PreparedVerifyingKey object`); } return PreparedVerifyingKey.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<PreparedVerifyingKey> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching PreparedVerifyingKey object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isPreparedVerifyingKey(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a PreparedVerifyingKey object`); }
+ return PreparedVerifyingKey.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== ProofPoints =============================== */
+
+export function isProofPoints(type: string): boolean { type = compressSuiType(type); return type === "0x2::groth16::ProofPoints"; }
+
+export interface ProofPointsFields { bytes: ToField<Vector<"u8">> }
+
+export type ProofPointsReified = Reified< ProofPoints, ProofPointsFields >;
+
+export class ProofPoints implements StructClass { static readonly $typeName = "0x2::groth16::ProofPoints"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = ProofPoints.$typeName;
+
+ readonly $fullTypeName: "0x2::groth16::ProofPoints";
+
+ readonly $typeArgs: [];
+
+ readonly bytes: ToField<Vector<"u8">>
+
+ private constructor(typeArgs: [], fields: ProofPointsFields, ) { this.$fullTypeName = composeSuiType( ProofPoints.$typeName, ...typeArgs ) as "0x2::groth16::ProofPoints"; this.$typeArgs = typeArgs;
+
+ this.bytes = fields.bytes; }
+
+ static reified( ): ProofPointsReified { return { typeName: ProofPoints.$typeName, fullTypeName: composeSuiType( ProofPoints.$typeName, ...[] ) as "0x2::groth16::ProofPoints", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => ProofPoints.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => ProofPoints.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => ProofPoints.fromBcs( data, ), bcs: ProofPoints.bcs, fromJSONField: (field: any) => ProofPoints.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => ProofPoints.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => ProofPoints.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => ProofPoints.fetch( client, id, ), new: ( fields: ProofPointsFields, ) => { return new ProofPoints( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return ProofPoints.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<ProofPoints>> { return phantom(ProofPoints.reified( )); } static get p() { return ProofPoints.phantom() }
+
+ static get bcs() { return bcs.struct("ProofPoints", {
+
+ bytes: bcs.vector(bcs.u8())
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): ProofPoints { return ProofPoints.reified( ).new( { bytes: decodeFromFields(reified.vector("u8"), fields.bytes) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): ProofPoints { if (!isProofPoints(item.type)) { throw new Error("not a ProofPoints type");
+
+ }
+
+ return ProofPoints.reified( ).new( { bytes: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.bytes) } ) }
+
+ static fromBcs( data: Uint8Array ): ProofPoints { return ProofPoints.fromFields( ProofPoints.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 ): ProofPoints { return ProofPoints.reified( ).new( { bytes: decodeFromJSONField(reified.vector("u8"), field.bytes) } ) }
+
+ static fromJSON( json: Record<string, any> ): ProofPoints { if (json.$typeName !== ProofPoints.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return ProofPoints.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): ProofPoints { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isProofPoints(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a ProofPoints object`); } return ProofPoints.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<ProofPoints> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching ProofPoints object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isProofPoints(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a ProofPoints object`); }
+ return ProofPoints.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== PublicProofInputs =============================== */
+
+export function isPublicProofInputs(type: string): boolean { type = compressSuiType(type); return type === "0x2::groth16::PublicProofInputs"; }
+
+export interface PublicProofInputsFields { bytes: ToField<Vector<"u8">> }
+
+export type PublicProofInputsReified = Reified< PublicProofInputs, PublicProofInputsFields >;
+
+export class PublicProofInputs implements StructClass { static readonly $typeName = "0x2::groth16::PublicProofInputs"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = PublicProofInputs.$typeName;
+
+ readonly $fullTypeName: "0x2::groth16::PublicProofInputs";
+
+ readonly $typeArgs: [];
+
+ readonly bytes: ToField<Vector<"u8">>
+
+ private constructor(typeArgs: [], fields: PublicProofInputsFields, ) { this.$fullTypeName = composeSuiType( PublicProofInputs.$typeName, ...typeArgs ) as "0x2::groth16::PublicProofInputs"; this.$typeArgs = typeArgs;
+
+ this.bytes = fields.bytes; }
+
+ static reified( ): PublicProofInputsReified { return { typeName: PublicProofInputs.$typeName, fullTypeName: composeSuiType( PublicProofInputs.$typeName, ...[] ) as "0x2::groth16::PublicProofInputs", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => PublicProofInputs.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => PublicProofInputs.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => PublicProofInputs.fromBcs( data, ), bcs: PublicProofInputs.bcs, fromJSONField: (field: any) => PublicProofInputs.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => PublicProofInputs.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => PublicProofInputs.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => PublicProofInputs.fetch( client, id, ), new: ( fields: PublicProofInputsFields, ) => { return new PublicProofInputs( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return PublicProofInputs.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<PublicProofInputs>> { return phantom(PublicProofInputs.reified( )); } static get p() { return PublicProofInputs.phantom() }
+
+ static get bcs() { return bcs.struct("PublicProofInputs", {
+
+ bytes: bcs.vector(bcs.u8())
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): PublicProofInputs { return PublicProofInputs.reified( ).new( { bytes: decodeFromFields(reified.vector("u8"), fields.bytes) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): PublicProofInputs { if (!isPublicProofInputs(item.type)) { throw new Error("not a PublicProofInputs type");
+
+ }
+
+ return PublicProofInputs.reified( ).new( { bytes: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.bytes) } ) }
+
+ static fromBcs( data: Uint8Array ): PublicProofInputs { return PublicProofInputs.fromFields( PublicProofInputs.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 ): PublicProofInputs { return PublicProofInputs.reified( ).new( { bytes: decodeFromJSONField(reified.vector("u8"), field.bytes) } ) }
+
+ static fromJSON( json: Record<string, any> ): PublicProofInputs { if (json.$typeName !== PublicProofInputs.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return PublicProofInputs.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): PublicProofInputs { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isPublicProofInputs(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a PublicProofInputs object`); } return PublicProofInputs.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<PublicProofInputs> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching PublicProofInputs object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isPublicProofInputs(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a PublicProofInputs object`); }
+ return PublicProofInputs.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }