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

package/src/_dependencies/source/0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded/i64/structs.ts

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

package/src/_dependencies/source/0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded/index.ts

@@ -0,0 +1 @@
+export const PACKAGE_ID = "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded"; export const PUBLISHED_AT = "0x3f108ef0de55edb9e31b03c029c98f78740a5f38e17fa2a69641e40d0a7aca21";

package/src/_dependencies/source/0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded/init.ts

@@ -0,0 +1,54 @@
+import * as authority from "./authority/structs";
+import * as balancePool from "./balance-pool/structs";
+import * as bigVector from "./big-vector/structs";
+import * as dutch from "./dutch/structs";
+import * as i64 from "./i64/structs";
+import * as linkedList from "./linked-list/structs";
+import * as vault from "./vault/structs";
+import {StructClassLoader} from "../../../_framework/loader";
+
+export function registerClasses(loader: StructClassLoader) { loader.register(bigVector.BigVector);
+loader.register(authority.Authority);
+loader.register(balancePool.BalanceInfo);
+loader.register(balancePool.BalancePool);
+loader.register(balancePool.SharedBalancePool);
+loader.register(vault.Activate);
+loader.register(vault.BidShare);
+loader.register(vault.BidVault);
+loader.register(vault.Claim);
+loader.register(vault.Compound);
+loader.register(vault.Delivery);
+loader.register(vault.Deposit);
+loader.register(vault.DepositShare);
+loader.register(vault.DepositVault);
+loader.register(vault.Exercise);
+loader.register(vault.Harvest);
+loader.register(vault.IncentiviseBidder);
+loader.register(vault.NewBidVault);
+loader.register(vault.NewDepositVault);
+loader.register(vault.NewRefundVault);
+loader.register(vault.Recoup);
+loader.register(vault.Redeem);
+loader.register(vault.RefundShare);
+loader.register(vault.RefundVault);
+loader.register(vault.Settle);
+loader.register(vault.Terminate);
+loader.register(vault.TypusBidReceipt);
+loader.register(vault.TypusDepositReceipt);
+loader.register(vault.Unsubscribe);
+loader.register(vault.UpdateFeeConfig);
+loader.register(vault.UpdateFeeShareConfig);
+loader.register(vault.VAULT);
+loader.register(vault.Withdraw);
+loader.register(i64.I64);
+loader.register(dutch.Delivery);
+loader.register(dutch.Terminate);
+loader.register(dutch.Auction);
+loader.register(dutch.Bid);
+loader.register(dutch.DUTCH);
+loader.register(dutch.NewBid);
+loader.register(dutch.RemoveBid);
+loader.register(dutch.UpdateAuctionConfig);
+loader.register(linkedList.Node);
+loader.register(linkedList.LinkedList);
+ }

package/src/_dependencies/source/0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded/linked-list/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 {ID} 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("0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::linked_list::Node<"); }
+
+export interface NodeFields<K extends TypeArgument, V extends TypeArgument> { value: ToField<V>; prev: ToField<Option<K>>; next: ToField<Option<K>>; exists: ToField<"bool"> }
+
+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 = "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::linked_list::Node"; static readonly $numTypeParams = 2;
+
+ readonly $typeName = Node.$typeName;
+
+ readonly $fullTypeName: `0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::linked_list::Node<${ToTypeStr<K>}, ${ToTypeStr<V>}>`;
+
+ readonly $typeArgs: [ToTypeStr<K>, ToTypeStr<V>];
+
+ readonly value: ToField<V>; readonly prev: ToField<Option<K>>; readonly next: ToField<Option<K>>; readonly exists: ToField<"bool">
+
+ private constructor(typeArgs: [ToTypeStr<K>, ToTypeStr<V>], fields: NodeFields<K, V>, ) { this.$fullTypeName = composeSuiType( Node.$typeName, ...typeArgs ) as `0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::linked_list::Node<${ToTypeStr<K>}, ${ToTypeStr<V>}>`; this.$typeArgs = typeArgs;
+
+ this.value = fields.value;; this.prev = fields.prev;; this.next = fields.next;; this.exists = fields.exists; }
+
+ 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 `0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::linked_list::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}>`, {
+
+ value: V, prev: Option.bcs(K), next: Option.bcs(K), exists: bcs.bool()
+
+}) };
+
+ 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( { value: decodeFromFields(typeArgs[1], fields.value), prev: decodeFromFields(Option.reified(typeArgs[0]), fields.prev), next: decodeFromFields(Option.reified(typeArgs[0]), fields.next), exists: decodeFromFields("bool", fields.exists) } ) }
+
+ 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( { value: decodeFromFieldsWithTypes(typeArgs[1], item.fields.value), prev: decodeFromFieldsWithTypes(Option.reified(typeArgs[0]), item.fields.prev), next: decodeFromFieldsWithTypes(Option.reified(typeArgs[0]), item.fields.next), exists: decodeFromFieldsWithTypes("bool", item.fields.exists) } ) }
+
+ 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 {
+
+ value: fieldToJSON<V>(this.$typeArgs[1], this.value),prev: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.prev),next: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.next),exists: this.exists,
+
+} }
+
+ 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( { value: decodeFromJSONField(typeArgs[1], field.value), prev: decodeFromJSONField(Option.reified(typeArgs[0]), field.prev), next: decodeFromJSONField(Option.reified(typeArgs[0]), field.next), exists: decodeFromJSONField("bool", field.exists) } ) }
+
+ 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) ); }
+
+ }
+
+/* ============================== LinkedList =============================== */
+
+export function isLinkedList(type: string): boolean { type = compressSuiType(type); return type.startsWith("0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::linked_list::LinkedList<"); }
+
+export interface LinkedListFields<K extends TypeArgument, V extends PhantomTypeArgument> { id: ToField<ID>; first: ToField<Option<K>>; last: ToField<Option<K>>; length: ToField<"u64"> }
+
+export type LinkedListReified<K extends TypeArgument, V extends PhantomTypeArgument> = Reified< LinkedList<K, V>, LinkedListFields<K, V> >;
+
+export class LinkedList<K extends TypeArgument, V extends PhantomTypeArgument> implements StructClass { static readonly $typeName = "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::linked_list::LinkedList"; static readonly $numTypeParams = 2;
+
+ readonly $typeName = LinkedList.$typeName;
+
+ readonly $fullTypeName: `0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::linked_list::LinkedList<${ToTypeStr<K>}, ${PhantomToTypeStr<V>}>`;
+
+ readonly $typeArgs: [ToTypeStr<K>, PhantomToTypeStr<V>];
+
+ readonly id: ToField<ID>; readonly first: ToField<Option<K>>; readonly last: ToField<Option<K>>; readonly length: ToField<"u64">
+
+ private constructor(typeArgs: [ToTypeStr<K>, PhantomToTypeStr<V>], fields: LinkedListFields<K, V>, ) { this.$fullTypeName = composeSuiType( LinkedList.$typeName, ...typeArgs ) as `0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::linked_list::LinkedList<${ToTypeStr<K>}, ${PhantomToTypeStr<V>}>`; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.first = fields.first;; this.last = fields.last;; this.length = fields.length; }
+
+ static reified<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( K: K, V: V ): LinkedListReified<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return { typeName: LinkedList.$typeName, fullTypeName: composeSuiType( LinkedList.$typeName, ...[extractType(K), extractType(V)] ) as `0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::linked_list::LinkedList<${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>) => LinkedList.fromFields( [K, V], fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => LinkedList.fromFieldsWithTypes( [K, V], item, ), fromBcs: (data: Uint8Array) => LinkedList.fromBcs( [K, V], data, ), bcs: LinkedList.bcs(toBcs(K)), fromJSONField: (field: any) => LinkedList.fromJSONField( [K, V], field, ), fromJSON: (json: Record<string, any>) => LinkedList.fromJSON( [K, V], json, ), fromSuiParsedData: (content: SuiParsedData) => LinkedList.fromSuiParsedData( [K, V], content, ), fetch: async (client: SuiClient, id: string) => LinkedList.fetch( client, [K, V], id, ), new: ( fields: LinkedListFields<ToTypeArgument<K>, ToPhantomTypeArgument<V>>, ) => { return new LinkedList( [extractType(K), extractType(V)], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return LinkedList.reified }
+
+ static phantom<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( K: K, V: V ): PhantomReified<ToTypeStr<LinkedList<ToTypeArgument<K>, ToPhantomTypeArgument<V>>>> { return phantom(LinkedList.reified( K, V )); } static get p() { return LinkedList.phantom }
+
+ static get bcs() { return <K extends BcsType<any>>(K: K) => bcs.struct(`LinkedList<${K.name}>`, {
+
+ id: ID.bcs, first: Option.bcs(K), last: Option.bcs(K), length: bcs.u64()
+
+}) };
+
+ static fromFields<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], fields: Record<string, any> ): LinkedList<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return LinkedList.reified( typeArgs[0], typeArgs[1], ).new( { id: decodeFromFields(ID.reified(), fields.id), first: decodeFromFields(Option.reified(typeArgs[0]), fields.first), last: decodeFromFields(Option.reified(typeArgs[0]), fields.last), length: decodeFromFields("u64", fields.length) } ) }
+
+ static fromFieldsWithTypes<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], item: FieldsWithTypes ): LinkedList<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { if (!isLinkedList(item.type)) { throw new Error("not a LinkedList type");
+
+ } assertFieldsWithTypesArgsMatch(item, typeArgs);
+
+ return LinkedList.reified( typeArgs[0], typeArgs[1], ).new( { id: decodeFromFieldsWithTypes(ID.reified(), item.fields.id), first: decodeFromFieldsWithTypes(Option.reified(typeArgs[0]), item.fields.first), last: decodeFromFieldsWithTypes(Option.reified(typeArgs[0]), item.fields.last), length: decodeFromFieldsWithTypes("u64", item.fields.length) } ) }
+
+ static fromBcs<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], data: Uint8Array ): LinkedList<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return LinkedList.fromFields( typeArgs, LinkedList.bcs( toBcs(typeArgs[0]) ).parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,first: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.first),last: fieldToJSON<Option<K>>(`0x1::option::Option<${this.$typeArgs[0]}>`, this.last),length: this.length.toString(),
+
+} }
+
+ 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 ): LinkedList<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { return LinkedList.reified( typeArgs[0], typeArgs[1], ).new( { id: decodeFromJSONField(ID.reified(), field.id), first: decodeFromJSONField(Option.reified(typeArgs[0]), field.first), last: decodeFromJSONField(Option.reified(typeArgs[0]), field.last), length: decodeFromJSONField("u64", field.length) } ) }
+
+ static fromJSON<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], json: Record<string, any> ): LinkedList<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { if (json.$typeName !== LinkedList.$typeName) { throw new Error("not a WithTwoGenerics json object") }; assertReifiedTypeArgsMatch( composeSuiType(LinkedList.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs, )
+
+ return LinkedList.fromJSONField( typeArgs, json, ) }
+
+ static fromSuiParsedData<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( typeArgs: [K, V], content: SuiParsedData ): LinkedList<ToTypeArgument<K>, ToPhantomTypeArgument<V>> { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isLinkedList(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a LinkedList object`); } return LinkedList.fromFieldsWithTypes( typeArgs, content ); }
+
+ static async fetch<K extends Reified<TypeArgument, any>, V extends PhantomReified<PhantomTypeArgument>>( client: SuiClient, typeArgs: [K, V], id: string ): Promise<LinkedList<ToTypeArgument<K>, ToPhantomTypeArgument<V>>> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching LinkedList object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isLinkedList(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a LinkedList object`); }
+ return LinkedList.fromBcs( typeArgs, fromB64(res.data.bcs.bcsBytes) ); }
+
+ }