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

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

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

@@ -0,0 +1,264 @@
+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";
+
+/* ============================== G1 =============================== */
+
+export function isG1(type: string): boolean { type = compressSuiType(type); return type === "0x2::bls12381::G1"; }
+
+export interface G1Fields { dummyField: ToField<"bool"> }
+
+export type G1Reified = Reified< G1, G1Fields >;
+
+export class G1 implements StructClass { static readonly $typeName = "0x2::bls12381::G1"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = G1.$typeName;
+
+ readonly $fullTypeName: "0x2::bls12381::G1";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: G1Fields, ) { this.$fullTypeName = composeSuiType( G1.$typeName, ...typeArgs ) as "0x2::bls12381::G1"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): G1Reified { return { typeName: G1.$typeName, fullTypeName: composeSuiType( G1.$typeName, ...[] ) as "0x2::bls12381::G1", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => G1.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => G1.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => G1.fromBcs( data, ), bcs: G1.bcs, fromJSONField: (field: any) => G1.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => G1.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => G1.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => G1.fetch( client, id, ), new: ( fields: G1Fields, ) => { return new G1( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return G1.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<G1>> { return phantom(G1.reified( )); } static get p() { return G1.phantom() }
+
+ static get bcs() { return bcs.struct("G1", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): G1 { return G1.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): G1 { if (!isG1(item.type)) { throw new Error("not a G1 type");
+
+ }
+
+ return G1.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): G1 { return G1.fromFields( G1.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): G1 { return G1.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): G1 { if (json.$typeName !== G1.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return G1.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): G1 { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isG1(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a G1 object`); } return G1.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<G1> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching G1 object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isG1(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a G1 object`); }
+ return G1.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== G2 =============================== */
+
+export function isG2(type: string): boolean { type = compressSuiType(type); return type === "0x2::bls12381::G2"; }
+
+export interface G2Fields { dummyField: ToField<"bool"> }
+
+export type G2Reified = Reified< G2, G2Fields >;
+
+export class G2 implements StructClass { static readonly $typeName = "0x2::bls12381::G2"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = G2.$typeName;
+
+ readonly $fullTypeName: "0x2::bls12381::G2";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: G2Fields, ) { this.$fullTypeName = composeSuiType( G2.$typeName, ...typeArgs ) as "0x2::bls12381::G2"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): G2Reified { return { typeName: G2.$typeName, fullTypeName: composeSuiType( G2.$typeName, ...[] ) as "0x2::bls12381::G2", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => G2.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => G2.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => G2.fromBcs( data, ), bcs: G2.bcs, fromJSONField: (field: any) => G2.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => G2.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => G2.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => G2.fetch( client, id, ), new: ( fields: G2Fields, ) => { return new G2( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return G2.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<G2>> { return phantom(G2.reified( )); } static get p() { return G2.phantom() }
+
+ static get bcs() { return bcs.struct("G2", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): G2 { return G2.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): G2 { if (!isG2(item.type)) { throw new Error("not a G2 type");
+
+ }
+
+ return G2.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): G2 { return G2.fromFields( G2.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): G2 { return G2.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): G2 { if (json.$typeName !== G2.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return G2.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): G2 { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isG2(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a G2 object`); } return G2.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<G2> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching G2 object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isG2(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a G2 object`); }
+ return G2.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== GT =============================== */
+
+export function isGT(type: string): boolean { type = compressSuiType(type); return type === "0x2::bls12381::GT"; }
+
+export interface GTFields { dummyField: ToField<"bool"> }
+
+export type GTReified = Reified< GT, GTFields >;
+
+export class GT implements StructClass { static readonly $typeName = "0x2::bls12381::GT"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = GT.$typeName;
+
+ readonly $fullTypeName: "0x2::bls12381::GT";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: GTFields, ) { this.$fullTypeName = composeSuiType( GT.$typeName, ...typeArgs ) as "0x2::bls12381::GT"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): GTReified { return { typeName: GT.$typeName, fullTypeName: composeSuiType( GT.$typeName, ...[] ) as "0x2::bls12381::GT", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => GT.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => GT.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => GT.fromBcs( data, ), bcs: GT.bcs, fromJSONField: (field: any) => GT.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => GT.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => GT.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => GT.fetch( client, id, ), new: ( fields: GTFields, ) => { return new GT( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return GT.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<GT>> { return phantom(GT.reified( )); } static get p() { return GT.phantom() }
+
+ static get bcs() { return bcs.struct("GT", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): GT { return GT.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): GT { if (!isGT(item.type)) { throw new Error("not a GT type");
+
+ }
+
+ return GT.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): GT { return GT.fromFields( GT.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): GT { return GT.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): GT { if (json.$typeName !== GT.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return GT.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): GT { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isGT(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a GT object`); } return GT.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<GT> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching GT object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isGT(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a GT object`); }
+ return GT.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== Scalar =============================== */
+
+export function isScalar(type: string): boolean { type = compressSuiType(type); return type === "0x2::bls12381::Scalar"; }
+
+export interface ScalarFields { dummyField: ToField<"bool"> }
+
+export type ScalarReified = Reified< Scalar, ScalarFields >;
+
+export class Scalar implements StructClass { static readonly $typeName = "0x2::bls12381::Scalar"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Scalar.$typeName;
+
+ readonly $fullTypeName: "0x2::bls12381::Scalar";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: ScalarFields, ) { this.$fullTypeName = composeSuiType( Scalar.$typeName, ...typeArgs ) as "0x2::bls12381::Scalar"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): ScalarReified { return { typeName: Scalar.$typeName, fullTypeName: composeSuiType( Scalar.$typeName, ...[] ) as "0x2::bls12381::Scalar", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Scalar.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Scalar.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Scalar.fromBcs( data, ), bcs: Scalar.bcs, fromJSONField: (field: any) => Scalar.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Scalar.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Scalar.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Scalar.fetch( client, id, ), new: ( fields: ScalarFields, ) => { return new Scalar( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Scalar.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Scalar>> { return phantom(Scalar.reified( )); } static get p() { return Scalar.phantom() }
+
+ static get bcs() { return bcs.struct("Scalar", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Scalar { return Scalar.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Scalar { if (!isScalar(item.type)) { throw new Error("not a Scalar type");
+
+ }
+
+ return Scalar.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): Scalar { return Scalar.fromFields( Scalar.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Scalar { return Scalar.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): Scalar { if (json.$typeName !== Scalar.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Scalar.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Scalar { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isScalar(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Scalar object`); } return Scalar.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Scalar> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Scalar object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isScalar(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Scalar object`); }
+ return Scalar.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

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

@@ -0,0 +1,138 @@
+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 {Option} from "../../0x1/option/structs";
+import {ID} from "../object/structs";
+import {BcsType, bcs, fromB64, fromHEX, toHEX} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== Borrow =============================== */
+
+export function isBorrow(type: string): boolean { type = compressSuiType(type); return type === "0x2::borrow::Borrow"; }
+
+export interface BorrowFields { ref: ToField<"address">; obj: ToField<ID> }
+
+export type BorrowReified = Reified< Borrow, BorrowFields >;
+
+export class Borrow implements StructClass { static readonly $typeName = "0x2::borrow::Borrow"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Borrow.$typeName;
+
+ readonly $fullTypeName: "0x2::borrow::Borrow";
+
+ readonly $typeArgs: [];
+
+ readonly ref: ToField<"address">; readonly obj: ToField<ID>
+
+ private constructor(typeArgs: [], fields: BorrowFields, ) { this.$fullTypeName = composeSuiType( Borrow.$typeName, ...typeArgs ) as "0x2::borrow::Borrow"; this.$typeArgs = typeArgs;
+
+ this.ref = fields.ref;; this.obj = fields.obj; }
+
+ static reified( ): BorrowReified { return { typeName: Borrow.$typeName, fullTypeName: composeSuiType( Borrow.$typeName, ...[] ) as "0x2::borrow::Borrow", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Borrow.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Borrow.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Borrow.fromBcs( data, ), bcs: Borrow.bcs, fromJSONField: (field: any) => Borrow.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Borrow.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Borrow.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Borrow.fetch( client, id, ), new: ( fields: BorrowFields, ) => { return new Borrow( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Borrow.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Borrow>> { return phantom(Borrow.reified( )); } static get p() { return Borrow.phantom() }
+
+ static get bcs() { return bcs.struct("Borrow", {
+
+ ref: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), obj: ID.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Borrow { return Borrow.reified( ).new( { ref: decodeFromFields("address", fields.ref), obj: decodeFromFields(ID.reified(), fields.obj) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Borrow { if (!isBorrow(item.type)) { throw new Error("not a Borrow type");
+
+ }
+
+ return Borrow.reified( ).new( { ref: decodeFromFieldsWithTypes("address", item.fields.ref), obj: decodeFromFieldsWithTypes(ID.reified(), item.fields.obj) } ) }
+
+ static fromBcs( data: Uint8Array ): Borrow { return Borrow.fromFields( Borrow.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ ref: this.ref,obj: this.obj,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Borrow { return Borrow.reified( ).new( { ref: decodeFromJSONField("address", field.ref), obj: decodeFromJSONField(ID.reified(), field.obj) } ) }
+
+ static fromJSON( json: Record<string, any> ): Borrow { if (json.$typeName !== Borrow.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Borrow.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Borrow { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isBorrow(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Borrow object`); } return Borrow.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Borrow> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Borrow object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isBorrow(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Borrow object`); }
+ return Borrow.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== Referent =============================== */
+
+export function isReferent(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x2::borrow::Referent<"); }
+
+export interface ReferentFields<T extends TypeArgument> { id: ToField<"address">; value: ToField<Option<T>> }
+
+export type ReferentReified<T extends TypeArgument> = Reified< Referent<T>, ReferentFields<T> >;
+
+export class Referent<T extends TypeArgument> implements StructClass { static readonly $typeName = "0x2::borrow::Referent"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = Referent.$typeName;
+
+ readonly $fullTypeName: `0x2::borrow::Referent<${ToTypeStr<T>}>`;
+
+ readonly $typeArgs: [ToTypeStr<T>];
+
+ readonly id: ToField<"address">; readonly value: ToField<Option<T>>
+
+ private constructor(typeArgs: [ToTypeStr<T>], fields: ReferentFields<T>, ) { this.$fullTypeName = composeSuiType( Referent.$typeName, ...typeArgs ) as `0x2::borrow::Referent<${ToTypeStr<T>}>`; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.value = fields.value; }
+
+ static reified<T extends Reified<TypeArgument, any>>( T: T ): ReferentReified<ToTypeArgument<T>> { return { typeName: Referent.$typeName, fullTypeName: composeSuiType( Referent.$typeName, ...[extractType(T)] ) as `0x2::borrow::Referent<${ToTypeStr<ToTypeArgument<T>>}>`, typeArgs: [ extractType(T) ] as [ToTypeStr<ToTypeArgument<T>>], reifiedTypeArgs: [T], fromFields: (fields: Record<string, any>) => Referent.fromFields( T, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Referent.fromFieldsWithTypes( T, item, ), fromBcs: (data: Uint8Array) => Referent.fromBcs( T, data, ), bcs: Referent.bcs(toBcs(T)), fromJSONField: (field: any) => Referent.fromJSONField( T, field, ), fromJSON: (json: Record<string, any>) => Referent.fromJSON( T, json, ), fromSuiParsedData: (content: SuiParsedData) => Referent.fromSuiParsedData( T, content, ), fetch: async (client: SuiClient, id: string) => Referent.fetch( client, T, id, ), new: ( fields: ReferentFields<ToTypeArgument<T>>, ) => { return new Referent( [extractType(T)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Referent.reified }
+
+ static phantom<T extends Reified<TypeArgument, any>>( T: T ): PhantomReified<ToTypeStr<Referent<ToTypeArgument<T>>>> { return phantom(Referent.reified( T )); } static get p() { return Referent.phantom }
+
+ static get bcs() { return <T extends BcsType<any>>(T: T) => bcs.struct(`Referent<${T.name}>`, {
+
+ id: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), value: Option.bcs(T)
+
+}) };
+
+ static fromFields<T extends Reified<TypeArgument, any>>( typeArg: T, fields: Record<string, any> ): Referent<ToTypeArgument<T>> { return Referent.reified( typeArg, ).new( { id: decodeFromFields("address", fields.id), value: decodeFromFields(Option.reified(typeArg), fields.value) } ) }
+
+ static fromFieldsWithTypes<T extends Reified<TypeArgument, any>>( typeArg: T, item: FieldsWithTypes ): Referent<ToTypeArgument<T>> { if (!isReferent(item.type)) { throw new Error("not a Referent type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return Referent.reified( typeArg, ).new( { id: decodeFromFieldsWithTypes("address", item.fields.id), value: decodeFromFieldsWithTypes(Option.reified(typeArg), item.fields.value) } ) }
+
+ static fromBcs<T extends Reified<TypeArgument, any>>( typeArg: T, data: Uint8Array ): Referent<ToTypeArgument<T>> { const typeArgs = [typeArg];
+
+ return Referent.fromFields( typeArg, Referent.bcs( toBcs(typeArgs[0]) ).parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,value: fieldToJSON<Option<T>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.value),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<T extends Reified<TypeArgument, any>>( typeArg: T, field: any ): Referent<ToTypeArgument<T>> { return Referent.reified( typeArg, ).new( { id: decodeFromJSONField("address", field.id), value: decodeFromJSONField(Option.reified(typeArg), field.value) } ) }
+
+ static fromJSON<T extends Reified<TypeArgument, any>>( typeArg: T, json: Record<string, any> ): Referent<ToTypeArgument<T>> { if (json.$typeName !== Referent.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(Referent.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return Referent.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<T extends Reified<TypeArgument, any>>( typeArg: T, content: SuiParsedData ): Referent<ToTypeArgument<T>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isReferent(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Referent object`); } return Referent.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<T extends Reified<TypeArgument, any>>( client: SuiClient, typeArg: T, id: string ): Promise<Referent<ToTypeArgument<T>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Referent object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isReferent(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Referent object`); }
+ return Referent.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

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

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