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

package/src/_dependencies/source/0x2/kiosk-extension/structs.ts

@@ -0,0 +1,135 @@
+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 {Bag} from "../bag/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== Extension =============================== */
+
+export function isExtension(type: string): boolean { type = compressSuiType(type); return type === "0x2::kiosk_extension::Extension"; }
+
+export interface ExtensionFields { storage: ToField<Bag>; permissions: ToField<"u128">; isEnabled: ToField<"bool"> }
+
+export type ExtensionReified = Reified< Extension, ExtensionFields >;
+
+export class Extension implements StructClass { static readonly $typeName = "0x2::kiosk_extension::Extension"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Extension.$typeName;
+
+ readonly $fullTypeName: "0x2::kiosk_extension::Extension";
+
+ readonly $typeArgs: [];
+
+ readonly storage: ToField<Bag>; readonly permissions: ToField<"u128">; readonly isEnabled: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: ExtensionFields, ) { this.$fullTypeName = composeSuiType( Extension.$typeName, ...typeArgs ) as "0x2::kiosk_extension::Extension"; this.$typeArgs = typeArgs;
+
+ this.storage = fields.storage;; this.permissions = fields.permissions;; this.isEnabled = fields.isEnabled; }
+
+ static reified( ): ExtensionReified { return { typeName: Extension.$typeName, fullTypeName: composeSuiType( Extension.$typeName, ...[] ) as "0x2::kiosk_extension::Extension", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Extension.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Extension.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Extension.fromBcs( data, ), bcs: Extension.bcs, fromJSONField: (field: any) => Extension.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Extension.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Extension.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Extension.fetch( client, id, ), new: ( fields: ExtensionFields, ) => { return new Extension( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Extension.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Extension>> { return phantom(Extension.reified( )); } static get p() { return Extension.phantom() }
+
+ static get bcs() { return bcs.struct("Extension", {
+
+ storage: Bag.bcs, permissions: bcs.u128(), is_enabled: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Extension { return Extension.reified( ).new( { storage: decodeFromFields(Bag.reified(), fields.storage), permissions: decodeFromFields("u128", fields.permissions), isEnabled: decodeFromFields("bool", fields.is_enabled) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Extension { if (!isExtension(item.type)) { throw new Error("not a Extension type");
+
+ }
+
+ return Extension.reified( ).new( { storage: decodeFromFieldsWithTypes(Bag.reified(), item.fields.storage), permissions: decodeFromFieldsWithTypes("u128", item.fields.permissions), isEnabled: decodeFromFieldsWithTypes("bool", item.fields.is_enabled) } ) }
+
+ static fromBcs( data: Uint8Array ): Extension { return Extension.fromFields( Extension.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ storage: this.storage.toJSONField(),permissions: this.permissions.toString(),isEnabled: this.isEnabled,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Extension { return Extension.reified( ).new( { storage: decodeFromJSONField(Bag.reified(), field.storage), permissions: decodeFromJSONField("u128", field.permissions), isEnabled: decodeFromJSONField("bool", field.isEnabled) } ) }
+
+ static fromJSON( json: Record<string, any> ): Extension { if (json.$typeName !== Extension.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Extension.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Extension { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isExtension(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Extension object`); } return Extension.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Extension> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Extension object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isExtension(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Extension object`); }
+ return Extension.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== ExtensionKey =============================== */
+
+export function isExtensionKey(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x2::kiosk_extension::ExtensionKey<"); }
+
+export interface ExtensionKeyFields<Ext extends PhantomTypeArgument> { dummyField: ToField<"bool"> }
+
+export type ExtensionKeyReified<Ext extends PhantomTypeArgument> = Reified< ExtensionKey<Ext>, ExtensionKeyFields<Ext> >;
+
+export class ExtensionKey<Ext extends PhantomTypeArgument> implements StructClass { static readonly $typeName = "0x2::kiosk_extension::ExtensionKey"; static readonly $numTypeParams = 1;
+
+ readonly $typeName = ExtensionKey.$typeName;
+
+ readonly $fullTypeName: `0x2::kiosk_extension::ExtensionKey<${PhantomToTypeStr<Ext>}>`;
+
+ readonly $typeArgs: [PhantomToTypeStr<Ext>];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [PhantomToTypeStr<Ext>], fields: ExtensionKeyFields<Ext>, ) { this.$fullTypeName = composeSuiType( ExtensionKey.$typeName, ...typeArgs ) as `0x2::kiosk_extension::ExtensionKey<${PhantomToTypeStr<Ext>}>`; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified<Ext extends PhantomReified<PhantomTypeArgument>>( Ext: Ext ): ExtensionKeyReified<ToPhantomTypeArgument<Ext>> { return { typeName: ExtensionKey.$typeName, fullTypeName: composeSuiType( ExtensionKey.$typeName, ...[extractType(Ext)] ) as `0x2::kiosk_extension::ExtensionKey<${PhantomToTypeStr<ToPhantomTypeArgument<Ext>>}>`, typeArgs: [ extractType(Ext) ] as [PhantomToTypeStr<ToPhantomTypeArgument<Ext>>], reifiedTypeArgs: [Ext], fromFields: (fields: Record<string, any>) => ExtensionKey.fromFields( Ext, fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => ExtensionKey.fromFieldsWithTypes( Ext, item, ), fromBcs: (data: Uint8Array) => ExtensionKey.fromBcs( Ext, data, ), bcs: ExtensionKey.bcs, fromJSONField: (field: any) => ExtensionKey.fromJSONField( Ext, field, ), fromJSON: (json: Record<string, any>) => ExtensionKey.fromJSON( Ext, json, ), fromSuiParsedData: (content: SuiParsedData) => ExtensionKey.fromSuiParsedData( Ext, content, ), fetch: async (client: SuiClient, id: string) => ExtensionKey.fetch( client, Ext, id, ), new: ( fields: ExtensionKeyFields<ToPhantomTypeArgument<Ext>>, ) => { return new ExtensionKey( [extractType(Ext)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return ExtensionKey.reified }
+
+ static phantom<Ext extends PhantomReified<PhantomTypeArgument>>( Ext: Ext ): PhantomReified<ToTypeStr<ExtensionKey<ToPhantomTypeArgument<Ext>>>> { return phantom(ExtensionKey.reified( Ext )); } static get p() { return ExtensionKey.phantom }
+
+ static get bcs() { return bcs.struct("ExtensionKey", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields<Ext extends PhantomReified<PhantomTypeArgument>>( typeArg: Ext, fields: Record<string, any> ): ExtensionKey<ToPhantomTypeArgument<Ext>> { return ExtensionKey.reified( typeArg, ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes<Ext extends PhantomReified<PhantomTypeArgument>>( typeArg: Ext, item: FieldsWithTypes ): ExtensionKey<ToPhantomTypeArgument<Ext>> { if (!isExtensionKey(item.type)) { throw new Error("not a ExtensionKey type");
+
+ } assertFieldsWithTypesArgsMatch(item, [typeArg]);
+
+ return ExtensionKey.reified( typeArg, ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs<Ext extends PhantomReified<PhantomTypeArgument>>( typeArg: Ext, data: Uint8Array ): ExtensionKey<ToPhantomTypeArgument<Ext>> { return ExtensionKey.fromFields( typeArg, ExtensionKey.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField<Ext extends PhantomReified<PhantomTypeArgument>>( typeArg: Ext, field: any ): ExtensionKey<ToPhantomTypeArgument<Ext>> { return ExtensionKey.reified( typeArg, ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON<Ext extends PhantomReified<PhantomTypeArgument>>( typeArg: Ext, json: Record<string, any> ): ExtensionKey<ToPhantomTypeArgument<Ext>> { if (json.$typeName !== ExtensionKey.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(ExtensionKey.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg], )
+
+ return ExtensionKey.fromJSONField( typeArg, json, ) }
+
+ static fromSuiParsedData<Ext extends PhantomReified<PhantomTypeArgument>>( typeArg: Ext, content: SuiParsedData ): ExtensionKey<ToPhantomTypeArgument<Ext>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isExtensionKey(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a ExtensionKey object`); } return ExtensionKey.fromFieldsWithTypes( typeArg, content ); }
+
+ static async fetch<Ext extends PhantomReified<PhantomTypeArgument>>( client: SuiClient, typeArg: Ext, id: string ): Promise<ExtensionKey<ToPhantomTypeArgument<Ext>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching ExtensionKey object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isExtensionKey(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a ExtensionKey object`); }
+ return ExtensionKey.fromBcs( typeArg, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

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

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

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

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

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

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