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

package/src/_dependencies/source/0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277/linked-object-table/structs.ts

@@ -0,0 +1,136 @@
+import {PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToPhantomTypeArgument, 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 {UID} from "../../0x2/object/structs";
+import {BcsType, bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== Node =============================== */
+
+export function isNode(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_object_table::Node<"); }
+
+export interface NodeFields<K extends TypeArgument, V extends PhantomTypeArgument> { prev: ToField<Option<K>>; next: ToField<Option<K>> }
+
+export type NodeReified<K extends TypeArgument, V extends PhantomTypeArgument> = Reified< Node<K, V>, NodeFields<K, V> >;
+
+export class Node<K extends TypeArgument, V extends PhantomTypeArgument> implements StructClass { static readonly $typeName = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_object_table::Node"; static readonly $numTypeParams = 2;
+
+ readonly $typeName = Node.$typeName;
+
+ readonly $fullTypeName: `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_object_table::Node<${ToTypeStr<K>}, ${PhantomToTypeStr<V>}>`;
+
+ readonly $typeArgs: [ToTypeStr<K>, PhantomToTypeStr<V>];
+
+ readonly prev: ToField<Option<K>>; readonly next: ToField<Option<K>>
+
+ private constructor(typeArgs: [ToTypeStr<K>, PhantomToTypeStr<V>], fields: NodeFields<K, V>, ) { this.$fullTypeName = composeSuiType( Node.$typeName, ...typeArgs ) as `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_object_table::Node<${ToTypeStr<K>}, ${PhantomToTypeStr<V>}>`; this.$typeArgs = typeArgs;
+
+ this.prev = fields.prev;; this.next = fields.next; }
+
+ static reified<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( K: K, V: V ): NodeReified<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return { typeName: Node.$typeName, fullTypeName: composeSuiType( Node.$typeName, ...[extractType(K), extractType(V)] ) as `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_object_table::Node<${ToTypeStr<ToTypeArgument<K>>}, ${PhantomToTypeStr<ToPhantomTypeArgument<V>>}>`, typeArgs: [ extractType(K), extractType(V) ] as [ToTypeStr<ToTypeArgument<K>>, PhantomToTypeStr<ToPhantomTypeArgument<V>>], reifiedTypeArgs: [K, V], fromFields: (fields: Record<string, any>) => Node.fromFields( [K, V], fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Node.fromFieldsWithTypes( [K, V], item, ), fromBcs: (data: Uint8Array) => Node.fromBcs( [K, V], data, ), bcs: Node.bcs(toBcs(K)), fromJSONField: (field: any) => Node.fromJSONField( [K, V], field, ), fromJSON: (json: Record<string, any>) => Node.fromJSON( [K, V], json, ), fromSuiParsedData: (content: SuiParsedData) => Node.fromSuiParsedData( [K, V], content, ), fetch: async (client: SuiClient, id: string) => Node.fetch( client, [K, V], id, ), new: ( fields: NodeFields<ToTypeArgument<K>, ToPhantomTypeArgument<V>>, ) => { return new Node( [extractType(K), extractType(V)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Node.reified }
+
+ static phantom<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( K: K, V: V ): PhantomReified<ToTypeStr<Node<ToTypeArgument<K>, ToPhantomTypeArgument<V>>>> { return phantom(Node.reified( K, V )); } static get p() { return Node.phantom }
+
+ static get bcs() { return <K extends BcsType<any>>(K: K) => bcs.struct(`Node<${K.name}>`, {
+
+ prev: Option.bcs(K), next: Option.bcs(K)
+
+}) };
+
+ static fromFields<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], fields: Record<string, any> ): Node<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return Node.reified( typeArgs[0], typeArgs[1], ).new( { prev: decodeFromFields(Option.reified(typeArgs[0]), fields.prev), next: decodeFromFields(Option.reified(typeArgs[0]), fields.next) } ) }
+
+ static fromFieldsWithTypes<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], item: FieldsWithTypes ): Node<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { if (!isNode(item.type)) { throw new Error("not a Node type");
+
+ } assertFieldsWithTypesArgsMatch(item, typeArgs);
+
+ return Node.reified( typeArgs[0], typeArgs[1], ).new( { prev: decodeFromFieldsWithTypes(Option.reified(typeArgs[0]), item.fields.prev), next: decodeFromFieldsWithTypes(Option.reified(typeArgs[0]), item.fields.next) } ) }
+
+ static fromBcs<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], data: Uint8Array ): Node<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return Node.fromFields( typeArgs, Node.bcs( toBcs(typeArgs[0]) ).parse(data) ) }
+
+ toJSONField() { return {
+
+ prev: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.prev),next: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.next),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], field: any ): Node<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return Node.reified( typeArgs[0], typeArgs[1], ).new( { prev: decodeFromJSONField(Option.reified(typeArgs[0]), field.prev), next: decodeFromJSONField(Option.reified(typeArgs[0]), field.next) } ) }
+
+ static fromJSON<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], json: Record<string, any> ): Node<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { if (json.$typeName !== Node.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(Node.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs, )
+
+ return Node.fromJSONField( typeArgs, json, ) }
+
+ static fromSuiParsedData<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], content: SuiParsedData ): Node<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isNode(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Node object`); } return Node.fromFieldsWithTypes( typeArgs, content ); }
+
+ static async fetch<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( client: SuiClient, typeArgs: [K, V], id: string ): Promise<Node<ToTypeArgument<K>, ToPhantomTypeArgument<V>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Node object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isNode(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Node object`); }
+ return Node.fromBcs( typeArgs, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== LinkedObjectTable =============================== */
+
+export function isLinkedObjectTable(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_object_table::LinkedObjectTable<"); }
+
+export interface LinkedObjectTableFields<K extends TypeArgument, V extends PhantomTypeArgument> { id: ToField<UID>; vid: ToField<UID>; size: ToField<"u64">; head: ToField<Option<K>>; tail: ToField<Option<K>> }
+
+export type LinkedObjectTableReified<K extends TypeArgument, V extends PhantomTypeArgument> = Reified< LinkedObjectTable<K, V>, LinkedObjectTableFields<K, V> >;
+
+export class LinkedObjectTable<K extends TypeArgument, V extends PhantomTypeArgument> implements StructClass { static readonly $typeName = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_object_table::LinkedObjectTable"; static readonly $numTypeParams = 2;
+
+ readonly $typeName = LinkedObjectTable.$typeName;
+
+ readonly $fullTypeName: `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_object_table::LinkedObjectTable<${ToTypeStr<K>}, ${PhantomToTypeStr<V>}>`;
+
+ readonly $typeArgs: [ToTypeStr<K>, PhantomToTypeStr<V>];
+
+ readonly id: ToField<UID>; readonly vid: ToField<UID>; readonly size: ToField<"u64">; readonly head: ToField<Option<K>>; readonly tail: ToField<Option<K>>
+
+ private constructor(typeArgs: [ToTypeStr<K>, PhantomToTypeStr<V>], fields: LinkedObjectTableFields<K, V>, ) { this.$fullTypeName = composeSuiType( LinkedObjectTable.$typeName, ...typeArgs ) as `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_object_table::LinkedObjectTable<${ToTypeStr<K>}, ${PhantomToTypeStr<V>}>`; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.vid = fields.vid;; this.size = fields.size;; this.head = fields.head;; this.tail = fields.tail; }
+
+ static reified<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( K: K, V: V ): LinkedObjectTableReified<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return { typeName: LinkedObjectTable.$typeName, fullTypeName: composeSuiType( LinkedObjectTable.$typeName, ...[extractType(K), extractType(V)] ) as `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_object_table::LinkedObjectTable<${ToTypeStr<ToTypeArgument<K>>}, ${PhantomToTypeStr<ToPhantomTypeArgument<V>>}>`, typeArgs: [ extractType(K), extractType(V) ] as [ToTypeStr<ToTypeArgument<K>>, PhantomToTypeStr<ToPhantomTypeArgument<V>>], reifiedTypeArgs: [K, V], fromFields: (fields: Record<string, any>) => LinkedObjectTable.fromFields( [K, V], fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => LinkedObjectTable.fromFieldsWithTypes( [K, V], item, ), fromBcs: (data: Uint8Array) => LinkedObjectTable.fromBcs( [K, V], data, ), bcs: LinkedObjectTable.bcs(toBcs(K)), fromJSONField: (field: any) => LinkedObjectTable.fromJSONField( [K, V], field, ), fromJSON: (json: Record<string, any>) => LinkedObjectTable.fromJSON( [K, V], json, ), fromSuiParsedData: (content: SuiParsedData) => LinkedObjectTable.fromSuiParsedData( [K, V], content, ), fetch: async (client: SuiClient, id: string) => LinkedObjectTable.fetch( client, [K, V], id, ), new: ( fields: LinkedObjectTableFields<ToTypeArgument<K>, ToPhantomTypeArgument<V>>, ) => { return new LinkedObjectTable( [extractType(K), extractType(V)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return LinkedObjectTable.reified }
+
+ static phantom<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( K: K, V: V ): PhantomReified<ToTypeStr<LinkedObjectTable<ToTypeArgument<K>, ToPhantomTypeArgument<V>>>> { return phantom(LinkedObjectTable.reified( K, V )); } static get p() { return LinkedObjectTable.phantom }
+
+ static get bcs() { return <K extends BcsType<any>>(K: K) => bcs.struct(`LinkedObjectTable<${K.name}>`, {
+
+ id: UID.bcs, vid: UID.bcs, size: bcs.u64(), head: Option.bcs(K), tail: Option.bcs(K)
+
+}) };
+
+ static fromFields<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], fields: Record<string, any> ): LinkedObjectTable<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return LinkedObjectTable.reified( typeArgs[0], typeArgs[1], ).new( { id: decodeFromFields(UID.reified(), fields.id), vid: decodeFromFields(UID.reified(), fields.vid), size: decodeFromFields("u64", fields.size), head: decodeFromFields(Option.reified(typeArgs[0]), fields.head), tail: decodeFromFields(Option.reified(typeArgs[0]), fields.tail) } ) }
+
+ static fromFieldsWithTypes<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], item: FieldsWithTypes ): LinkedObjectTable<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { if (!isLinkedObjectTable(item.type)) { throw new Error("not a LinkedObjectTable type");
+
+ } assertFieldsWithTypesArgsMatch(item, typeArgs);
+
+ return LinkedObjectTable.reified( typeArgs[0], typeArgs[1], ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), vid: decodeFromFieldsWithTypes(UID.reified(), item.fields.vid), size: decodeFromFieldsWithTypes("u64", item.fields.size), head: decodeFromFieldsWithTypes(Option.reified(typeArgs[0]), item.fields.head), tail: decodeFromFieldsWithTypes(Option.reified(typeArgs[0]), item.fields.tail) } ) }
+
+ static fromBcs<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], data: Uint8Array ): LinkedObjectTable<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return LinkedObjectTable.fromFields( typeArgs, LinkedObjectTable.bcs( toBcs(typeArgs[0]) ).parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,vid: this.vid,size: this.size.toString(),head: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.head),tail: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.tail),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], field: any ): LinkedObjectTable<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return LinkedObjectTable.reified( typeArgs[0], typeArgs[1], ).new( { id: decodeFromJSONField(UID.reified(), field.id), vid: decodeFromJSONField(UID.reified(), field.vid), size: decodeFromJSONField("u64", field.size), head: decodeFromJSONField(Option.reified(typeArgs[0]), field.head), tail: decodeFromJSONField(Option.reified(typeArgs[0]), field.tail) } ) }
+
+ static fromJSON<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], json: Record<string, any> ): LinkedObjectTable<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { if (json.$typeName !== LinkedObjectTable.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(LinkedObjectTable.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs, )
+
+ return LinkedObjectTable.fromJSONField( typeArgs, json, ) }
+
+ static fromSuiParsedData<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], content: SuiParsedData ): LinkedObjectTable<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isLinkedObjectTable(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a LinkedObjectTable object`); } return LinkedObjectTable.fromFieldsWithTypes( typeArgs, content ); }
+
+ static async fetch<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( client: SuiClient, typeArgs: [K, V], id: string ): Promise<LinkedObjectTable<ToTypeArgument<K>, ToPhantomTypeArgument<V>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching LinkedObjectTable object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isLinkedObjectTable(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a LinkedObjectTable object`); }
+ return LinkedObjectTable.fromBcs( typeArgs, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277/linked-set/structs.ts

@@ -0,0 +1,140 @@
+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 {UID} from "../../0x2/object/structs";
+import {BcsType, bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== Node =============================== */
+
+export function isNode(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_set::Node<"); }
+
+export interface NodeFields<K extends TypeArgument> { prev: ToField<Option<K>>; next: ToField<Option<K>> }
+
+export type NodeReified<K extends TypeArgument> = Reified< Node<K>, NodeFields<K> >;
+
+export class Node<K extends TypeArgument> implements StructClass { static readonly $typeName = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_set::Node"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = Node.$typeName;
+
+ readonly $fullTypeName: `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_set::Node<${ToTypeStr<K>}>`;
+
+ readonly $typeArgs: [ToTypeStr<K>];
+
+ readonly prev: ToField<Option<K>>; readonly next: ToField<Option<K>>
+
+ private constructor(typeArgs: [ToTypeStr<K>], fields: NodeFields<K>, ) { this.$fullTypeName = composeSuiType( Node.$typeName, ...typeArgs ) as `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_set::Node<${ToTypeStr<K>}>`; this.$typeArgs = typeArgs;
+
+ this.prev = fields.prev;; this.next = fields.next; }
+
+ static reified<K extends Reified<TypeArgument, any>>( K: K ): NodeReified<ToTypeArgument<K>> { return { typeName: Node.$typeName, fullTypeName: composeSuiType( Node.$typeName, ...[extractType(K)] ) as `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_set::Node<${ToTypeStr<ToTypeArgument<K>>}>`, typeArgs: [ extractType(K) ] as [ToTypeStr<ToTypeArgument<K>>], reifiedTypeArgs: [K], fromFields: (fields: Record<string, any>) => Node.fromFields( K, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Node.fromFieldsWithTypes( K, item, ), fromBcs: (data: Uint8Array) => Node.fromBcs( K, data, ), bcs: Node.bcs(toBcs(K)), fromJSONField: (field: any) => Node.fromJSONField( K, field, ), fromJSON: (json: Record<string, any>) => Node.fromJSON( K, json, ), fromSuiParsedData: (content: SuiParsedData) => Node.fromSuiParsedData( K, content, ), fetch: async (client: SuiClient, id: string) => Node.fetch( client, K, id, ), new: ( fields: NodeFields<ToTypeArgument<K>>, ) => { return new Node( [extractType(K)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Node.reified }
+
+ static phantom<K extends Reified<TypeArgument, any>>( K: K ): PhantomReified<ToTypeStr<Node<ToTypeArgument<K>>>> { return phantom(Node.reified( K )); } static get p() { return Node.phantom }
+
+ static get bcs() { return <K extends BcsType<any>>(K: K) => bcs.struct(`Node<${K.name}>`, {
+
+ prev: Option.bcs(K), next: Option.bcs(K)
+
+}) };
+
+ static fromFields<K extends Reified<TypeArgument, any>>( typeArg: K, fields: Record<string, any> ): Node<ToTypeArgument<K>> { return Node.reified( typeArg, ).new( { prev: decodeFromFields(Option.reified(typeArg), fields.prev), next: decodeFromFields(Option.reified(typeArg), fields.next) } ) }
+
+ static fromFieldsWithTypes<K extends Reified<TypeArgument, any>>( typeArg: K, item: FieldsWithTypes ): Node<ToTypeArgument<K>> { if (!isNode(item.type)) { throw new Error("not a Node type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return Node.reified( typeArg, ).new( { prev: decodeFromFieldsWithTypes(Option.reified(typeArg), item.fields.prev), next: decodeFromFieldsWithTypes(Option.reified(typeArg), item.fields.next) } ) }
+
+ static fromBcs<K extends Reified<TypeArgument, any>>( typeArg: K, data: Uint8Array ): Node<ToTypeArgument<K>> { const typeArgs = [typeArg];
+
+ return Node.fromFields( typeArg, Node.bcs( toBcs(typeArgs[0]) ).parse(data) ) }
+
+ toJSONField() { return {
+
+ prev: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.prev),next: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.next),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<K extends Reified<TypeArgument, any>>( typeArg: K, field: any ): Node<ToTypeArgument<K>> { return Node.reified( typeArg, ).new( { prev: decodeFromJSONField(Option.reified(typeArg), field.prev), next: decodeFromJSONField(Option.reified(typeArg), field.next) } ) }
+
+ static fromJSON<K extends Reified<TypeArgument, any>>( typeArg: K, json: Record<string, any> ): Node<ToTypeArgument<K>> { if (json.$typeName !== Node.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(Node.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return Node.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<K extends Reified<TypeArgument, any>>( typeArg: K, content: SuiParsedData ): Node<ToTypeArgument<K>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isNode(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Node object`); } return Node.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<K extends Reified<TypeArgument, any>>( client: SuiClient, typeArg: K, id: string ): Promise<Node<ToTypeArgument<K>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Node object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isNode(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Node object`); }
+ return Node.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== LinkedSet =============================== */
+
+export function isLinkedSet(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_set::LinkedSet<"); }
+
+export interface LinkedSetFields<K extends TypeArgument> { id: ToField<UID>; size: ToField<"u64">; head: ToField<Option<K>>; tail: ToField<Option<K>> }
+
+export type LinkedSetReified<K extends TypeArgument> = Reified< LinkedSet<K>, LinkedSetFields<K> >;
+
+export class LinkedSet<K extends TypeArgument> implements StructClass { static readonly $typeName = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_set::LinkedSet"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = LinkedSet.$typeName;
+
+ readonly $fullTypeName: `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_set::LinkedSet<${ToTypeStr<K>}>`;
+
+ readonly $typeArgs: [ToTypeStr<K>];
+
+ readonly id: ToField<UID>; readonly size: ToField<"u64">; readonly head: ToField<Option<K>>; readonly tail: ToField<Option<K>>
+
+ private constructor(typeArgs: [ToTypeStr<K>], fields: LinkedSetFields<K>, ) { this.$fullTypeName = composeSuiType( LinkedSet.$typeName, ...typeArgs ) as `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_set::LinkedSet<${ToTypeStr<K>}>`; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.size = fields.size;; this.head = fields.head;; this.tail = fields.tail; }
+
+ static reified<K extends Reified<TypeArgument, any>>( K: K ): LinkedSetReified<ToTypeArgument<K>> { return { typeName: LinkedSet.$typeName, fullTypeName: composeSuiType( LinkedSet.$typeName, ...[extractType(K)] ) as `0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::linked_set::LinkedSet<${ToTypeStr<ToTypeArgument<K>>}>`, typeArgs: [ extractType(K) ] as [ToTypeStr<ToTypeArgument<K>>], reifiedTypeArgs: [K], fromFields: (fields: Record<string, any>) => LinkedSet.fromFields( K, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => LinkedSet.fromFieldsWithTypes( K, item, ), fromBcs: (data: Uint8Array) => LinkedSet.fromBcs( K, data, ), bcs: LinkedSet.bcs(toBcs(K)), fromJSONField: (field: any) => LinkedSet.fromJSONField( K, field, ), fromJSON: (json: Record<string, any>) => LinkedSet.fromJSON( K, json, ), fromSuiParsedData: (content: SuiParsedData) => LinkedSet.fromSuiParsedData( K, content, ), fetch: async (client: SuiClient, id: string) => LinkedSet.fetch( client, K, id, ), new: ( fields: LinkedSetFields<ToTypeArgument<K>>, ) => { return new LinkedSet( [extractType(K)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return LinkedSet.reified }
+
+ static phantom<K extends Reified<TypeArgument, any>>( K: K ): PhantomReified<ToTypeStr<LinkedSet<ToTypeArgument<K>>>> { return phantom(LinkedSet.reified( K )); } static get p() { return LinkedSet.phantom }
+
+ static get bcs() { return <K extends BcsType<any>>(K: K) => bcs.struct(`LinkedSet<${K.name}>`, {
+
+ id: UID.bcs, size: bcs.u64(), head: Option.bcs(K), tail: Option.bcs(K)
+
+}) };
+
+ static fromFields<K extends Reified<TypeArgument, any>>( typeArg: K, fields: Record<string, any> ): LinkedSet<ToTypeArgument<K>> { return LinkedSet.reified( typeArg, ).new( { id: decodeFromFields(UID.reified(), fields.id), size: decodeFromFields("u64", fields.size), head: decodeFromFields(Option.reified(typeArg), fields.head), tail: decodeFromFields(Option.reified(typeArg), fields.tail) } ) }
+
+ static fromFieldsWithTypes<K extends Reified<TypeArgument, any>>( typeArg: K, item: FieldsWithTypes ): LinkedSet<ToTypeArgument<K>> { if (!isLinkedSet(item.type)) { throw new Error("not a LinkedSet type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return LinkedSet.reified( typeArg, ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), size: decodeFromFieldsWithTypes("u64", item.fields.size), head: decodeFromFieldsWithTypes(Option.reified(typeArg), item.fields.head), tail: decodeFromFieldsWithTypes(Option.reified(typeArg), item.fields.tail) } ) }
+
+ static fromBcs<K extends Reified<TypeArgument, any>>( typeArg: K, data: Uint8Array ): LinkedSet<ToTypeArgument<K>> { const typeArgs = [typeArg];
+
+ return LinkedSet.fromFields( typeArg, LinkedSet.bcs( toBcs(typeArgs[0]) ).parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,size: this.size.toString(),head: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.head),tail: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.tail),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<K extends Reified<TypeArgument, any>>( typeArg: K, field: any ): LinkedSet<ToTypeArgument<K>> { return LinkedSet.reified( typeArg, ).new( { id: decodeFromJSONField(UID.reified(), field.id), size: decodeFromJSONField("u64", field.size), head: decodeFromJSONField(Option.reified(typeArg), field.head), tail: decodeFromJSONField(Option.reified(typeArg), field.tail) } ) }
+
+ static fromJSON<K extends Reified<TypeArgument, any>>( typeArg: K, json: Record<string, any> ): LinkedSet<ToTypeArgument<K>> { if (json.$typeName !== LinkedSet.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(LinkedSet.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return LinkedSet.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<K extends Reified<TypeArgument, any>>( typeArg: K, content: SuiParsedData ): LinkedSet<ToTypeArgument<K>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isLinkedSet(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a LinkedSet object`); } return LinkedSet.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<K extends Reified<TypeArgument, any>>( client: SuiClient, typeArg: K, id: string ): Promise<LinkedSet<ToTypeArgument<K>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching LinkedSet object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isLinkedSet(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a LinkedSet object`); }
+ return LinkedSet.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277/tgld/structs.ts

@@ -0,0 +1,268 @@
+import * as reified from "../../../../_framework/reified";
+import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, Vector, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, fieldToJSON, phantom, ToTypeStr as ToPhantom} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {TreasuryCap} from "../../0x2/coin/structs";
+import {UID} from "../../0x2/object/structs";
+import {TokenPolicyCap} from "../../0x2/token/structs";
+import {bcs, fromB64, fromHEX, toHEX} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== BurnEvent =============================== */
+
+export function isBurnEvent(type: string): boolean { type = compressSuiType(type); return type === "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::BurnEvent"; }
+
+export interface BurnEventFields { log: ToField<Vector<"u64">>; bcsPadding: ToField<Vector<Vector<"u8">>> }
+
+export type BurnEventReified = Reified< BurnEvent, BurnEventFields >;
+
+export class BurnEvent implements StructClass { static readonly $typeName = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::BurnEvent"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = BurnEvent.$typeName;
+
+ readonly $fullTypeName: "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::BurnEvent";
+
+ readonly $typeArgs: [];
+
+ readonly log: ToField<Vector<"u64">>; readonly bcsPadding: ToField<Vector<Vector<"u8">>>
+
+ private constructor(typeArgs: [], fields: BurnEventFields, ) { this.$fullTypeName = composeSuiType( BurnEvent.$typeName, ...typeArgs ) as "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::BurnEvent"; this.$typeArgs = typeArgs;
+
+ this.log = fields.log;; this.bcsPadding = fields.bcsPadding; }
+
+ static reified( ): BurnEventReified { return { typeName: BurnEvent.$typeName, fullTypeName: composeSuiType( BurnEvent.$typeName, ...[] ) as "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::BurnEvent", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => BurnEvent.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => BurnEvent.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => BurnEvent.fromBcs( data, ), bcs: BurnEvent.bcs, fromJSONField: (field: any) => BurnEvent.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => BurnEvent.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => BurnEvent.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => BurnEvent.fetch( client, id, ), new: ( fields: BurnEventFields, ) => { return new BurnEvent( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return BurnEvent.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<BurnEvent>> { return phantom(BurnEvent.reified( )); } static get p() { return BurnEvent.phantom() }
+
+ static get bcs() { return bcs.struct("BurnEvent", {
+
+ log: bcs.vector(bcs.u64()), bcs_padding: bcs.vector(bcs.vector(bcs.u8()))
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): BurnEvent { return BurnEvent.reified( ).new( { log: decodeFromFields(reified.vector("u64"), fields.log), bcsPadding: decodeFromFields(reified.vector(reified.vector("u8")), fields.bcs_padding) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): BurnEvent { if (!isBurnEvent(item.type)) { throw new Error("not a BurnEvent type");
+
+ }
+
+ return BurnEvent.reified( ).new( { log: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.log), bcsPadding: decodeFromFieldsWithTypes(reified.vector(reified.vector("u8")), item.fields.bcs_padding) } ) }
+
+ static fromBcs( data: Uint8Array ): BurnEvent { return BurnEvent.fromFields( BurnEvent.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ log: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.log),bcsPadding: fieldToJSON<Vector<Vector<"u8">>>(`vector<vector<u8>>`, this.bcsPadding),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): BurnEvent { return BurnEvent.reified( ).new( { log: decodeFromJSONField(reified.vector("u64"), field.log), bcsPadding: decodeFromJSONField(reified.vector(reified.vector("u8")), field.bcsPadding) } ) }
+
+ static fromJSON( json: Record<string, any> ): BurnEvent { if (json.$typeName !== BurnEvent.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return BurnEvent.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): BurnEvent { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isBurnEvent(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a BurnEvent object`); } return BurnEvent.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<BurnEvent> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching BurnEvent object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isBurnEvent(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a BurnEvent object`); }
+ return BurnEvent.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== MintEvent =============================== */
+
+export function isMintEvent(type: string): boolean { type = compressSuiType(type); return type === "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::MintEvent"; }
+
+export interface MintEventFields { recipient: ToField<"address">; log: ToField<Vector<"u64">>; bcsPadding: ToField<Vector<Vector<"u8">>> }
+
+export type MintEventReified = Reified< MintEvent, MintEventFields >;
+
+export class MintEvent implements StructClass { static readonly $typeName = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::MintEvent"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = MintEvent.$typeName;
+
+ readonly $fullTypeName: "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::MintEvent";
+
+ readonly $typeArgs: [];
+
+ readonly recipient: ToField<"address">; readonly log: ToField<Vector<"u64">>; readonly bcsPadding: ToField<Vector<Vector<"u8">>>
+
+ private constructor(typeArgs: [], fields: MintEventFields, ) { this.$fullTypeName = composeSuiType( MintEvent.$typeName, ...typeArgs ) as "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::MintEvent"; this.$typeArgs = typeArgs;
+
+ this.recipient = fields.recipient;; this.log = fields.log;; this.bcsPadding = fields.bcsPadding; }
+
+ static reified( ): MintEventReified { return { typeName: MintEvent.$typeName, fullTypeName: composeSuiType( MintEvent.$typeName, ...[] ) as "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::MintEvent", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => MintEvent.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => MintEvent.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => MintEvent.fromBcs( data, ), bcs: MintEvent.bcs, fromJSONField: (field: any) => MintEvent.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => MintEvent.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => MintEvent.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => MintEvent.fetch( client, id, ), new: ( fields: MintEventFields, ) => { return new MintEvent( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return MintEvent.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<MintEvent>> { return phantom(MintEvent.reified( )); } static get p() { return MintEvent.phantom() }
+
+ static get bcs() { return bcs.struct("MintEvent", {
+
+ recipient: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), log: bcs.vector(bcs.u64()), bcs_padding: bcs.vector(bcs.vector(bcs.u8()))
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): MintEvent { return MintEvent.reified( ).new( { recipient: decodeFromFields("address", fields.recipient), log: decodeFromFields(reified.vector("u64"), fields.log), bcsPadding: decodeFromFields(reified.vector(reified.vector("u8")), fields.bcs_padding) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): MintEvent { if (!isMintEvent(item.type)) { throw new Error("not a MintEvent type");
+
+ }
+
+ return MintEvent.reified( ).new( { recipient: decodeFromFieldsWithTypes("address", item.fields.recipient), log: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.log), bcsPadding: decodeFromFieldsWithTypes(reified.vector(reified.vector("u8")), item.fields.bcs_padding) } ) }
+
+ static fromBcs( data: Uint8Array ): MintEvent { return MintEvent.fromFields( MintEvent.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ recipient: this.recipient,log: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.log),bcsPadding: fieldToJSON<Vector<Vector<"u8">>>(`vector<vector<u8>>`, this.bcsPadding),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): MintEvent { return MintEvent.reified( ).new( { recipient: decodeFromJSONField("address", field.recipient), log: decodeFromJSONField(reified.vector("u64"), field.log), bcsPadding: decodeFromJSONField(reified.vector(reified.vector("u8")), field.bcsPadding) } ) }
+
+ static fromJSON( json: Record<string, any> ): MintEvent { if (json.$typeName !== MintEvent.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return MintEvent.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): MintEvent { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isMintEvent(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a MintEvent object`); } return MintEvent.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<MintEvent> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching MintEvent object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isMintEvent(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a MintEvent object`); }
+ return MintEvent.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== TGLD =============================== */
+
+export function isTGLD(type: string): boolean { type = compressSuiType(type); return type === "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::TGLD"; }
+
+export interface TGLDFields { dummyField: ToField<"bool"> }
+
+export type TGLDReified = Reified< TGLD, TGLDFields >;
+
+export class TGLD implements StructClass { static readonly $typeName = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::TGLD"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = TGLD.$typeName;
+
+ readonly $fullTypeName: "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::TGLD";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: TGLDFields, ) { this.$fullTypeName = composeSuiType( TGLD.$typeName, ...typeArgs ) as "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::TGLD"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): TGLDReified { return { typeName: TGLD.$typeName, fullTypeName: composeSuiType( TGLD.$typeName, ...[] ) as "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::TGLD", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => TGLD.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => TGLD.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => TGLD.fromBcs( data, ), bcs: TGLD.bcs, fromJSONField: (field: any) => TGLD.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => TGLD.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => TGLD.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => TGLD.fetch( client, id, ), new: ( fields: TGLDFields, ) => { return new TGLD( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return TGLD.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<TGLD>> { return phantom(TGLD.reified( )); } static get p() { return TGLD.phantom() }
+
+ static get bcs() { return bcs.struct("TGLD", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): TGLD { return TGLD.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): TGLD { if (!isTGLD(item.type)) { throw new Error("not a TGLD type");
+
+ }
+
+ return TGLD.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): TGLD { return TGLD.fromFields( TGLD.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): TGLD { return TGLD.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): TGLD { if (json.$typeName !== TGLD.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return TGLD.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): TGLD { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isTGLD(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a TGLD object`); } return TGLD.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<TGLD> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching TGLD object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isTGLD(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a TGLD object`); }
+ return TGLD.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== TgldRegistry =============================== */
+
+export function isTgldRegistry(type: string): boolean { type = compressSuiType(type); return type === "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::TgldRegistry"; }
+
+export interface TgldRegistryFields { id: ToField<UID>; treasuryCap: ToField<TreasuryCap<ToPhantom<TGLD>>>; tokenPolicyCap: ToField<TokenPolicyCap<ToPhantom<TGLD>>> }
+
+export type TgldRegistryReified = Reified< TgldRegistry, TgldRegistryFields >;
+
+export class TgldRegistry implements StructClass { static readonly $typeName = "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::TgldRegistry"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = TgldRegistry.$typeName;
+
+ readonly $fullTypeName: "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::TgldRegistry";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly treasuryCap: ToField<TreasuryCap<ToPhantom<TGLD>>>; readonly tokenPolicyCap: ToField<TokenPolicyCap<ToPhantom<TGLD>>>
+
+ private constructor(typeArgs: [], fields: TgldRegistryFields, ) { this.$fullTypeName = composeSuiType( TgldRegistry.$typeName, ...typeArgs ) as "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::TgldRegistry"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.treasuryCap = fields.treasuryCap;; this.tokenPolicyCap = fields.tokenPolicyCap; }
+
+ static reified( ): TgldRegistryReified { return { typeName: TgldRegistry.$typeName, fullTypeName: composeSuiType( TgldRegistry.$typeName, ...[] ) as "0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277::tgld::TgldRegistry", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => TgldRegistry.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => TgldRegistry.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => TgldRegistry.fromBcs( data, ), bcs: TgldRegistry.bcs, fromJSONField: (field: any) => TgldRegistry.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => TgldRegistry.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => TgldRegistry.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => TgldRegistry.fetch( client, id, ), new: ( fields: TgldRegistryFields, ) => { return new TgldRegistry( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return TgldRegistry.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<TgldRegistry>> { return phantom(TgldRegistry.reified( )); } static get p() { return TgldRegistry.phantom() }
+
+ static get bcs() { return bcs.struct("TgldRegistry", {
+
+ id: UID.bcs, treasury_cap: TreasuryCap.bcs, token_policy_cap: TokenPolicyCap.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): TgldRegistry { return TgldRegistry.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), treasuryCap: decodeFromFields(TreasuryCap.reified(reified.phantom(TGLD.reified())), fields.treasury_cap), tokenPolicyCap: decodeFromFields(TokenPolicyCap.reified(reified.phantom(TGLD.reified())), fields.token_policy_cap) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): TgldRegistry { if (!isTgldRegistry(item.type)) { throw new Error("not a TgldRegistry type");
+
+ }
+
+ return TgldRegistry.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), treasuryCap: decodeFromFieldsWithTypes(TreasuryCap.reified(reified.phantom(TGLD.reified())), item.fields.treasury_cap), tokenPolicyCap: decodeFromFieldsWithTypes(TokenPolicyCap.reified(reified.phantom(TGLD.reified())), item.fields.token_policy_cap) } ) }
+
+ static fromBcs( data: Uint8Array ): TgldRegistry { return TgldRegistry.fromFields( TgldRegistry.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,treasuryCap: this.treasuryCap.toJSONField(),tokenPolicyCap: this.tokenPolicyCap.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): TgldRegistry { return TgldRegistry.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), treasuryCap: decodeFromJSONField(TreasuryCap.reified(reified.phantom(TGLD.reified())), field.treasuryCap), tokenPolicyCap: decodeFromJSONField(TokenPolicyCap.reified(reified.phantom(TGLD.reified())), field.tokenPolicyCap) } ) }
+
+ static fromJSON( json: Record<string, any> ): TgldRegistry { if (json.$typeName !== TgldRegistry.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return TgldRegistry.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): TgldRegistry { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isTgldRegistry(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a TgldRegistry object`); } return TgldRegistry.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<TgldRegistry> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching TgldRegistry object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isTgldRegistry(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a TgldRegistry object`); }
+ return TgldRegistry.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }