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

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

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

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

@@ -0,0 +1,3 @@
+import {StructClassLoader} from "../../../_framework/loader";
+
+export function registerClasses(loader: StructClassLoader) { }

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

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

package/src/_dependencies/source/0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded/balance-pool/structs.ts

@@ -0,0 +1,203 @@
+import * as reified from "../../../../_framework/reified";
+import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, Vector, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, fieldToJSON, phantom} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {TypeName} from "../../0x1/type-name/structs";
+import {UID} from "../../0x2/object/structs";
+import {Authority} from "../authority/structs";
+import {bcs, fromB64} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== BalanceInfo =============================== */
+
+export function isBalanceInfo(type: string): boolean { type = compressSuiType(type); return type === "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalanceInfo"; }
+
+export interface BalanceInfoFields { token: ToField<TypeName>; value: ToField<"u64"> }
+
+export type BalanceInfoReified = Reified< BalanceInfo, BalanceInfoFields >;
+
+export class BalanceInfo implements StructClass { static readonly $typeName = "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalanceInfo"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = BalanceInfo.$typeName;
+
+ readonly $fullTypeName: "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalanceInfo";
+
+ readonly $typeArgs: [];
+
+ readonly token: ToField<TypeName>; readonly value: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: BalanceInfoFields, ) { this.$fullTypeName = composeSuiType( BalanceInfo.$typeName, ...typeArgs ) as "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalanceInfo"; this.$typeArgs = typeArgs;
+
+ this.token = fields.token;; this.value = fields.value; }
+
+ static reified( ): BalanceInfoReified { return { typeName: BalanceInfo.$typeName, fullTypeName: composeSuiType( BalanceInfo.$typeName, ...[] ) as "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalanceInfo", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => BalanceInfo.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => BalanceInfo.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => BalanceInfo.fromBcs( data, ), bcs: BalanceInfo.bcs, fromJSONField: (field: any) => BalanceInfo.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => BalanceInfo.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => BalanceInfo.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => BalanceInfo.fetch( client, id, ), new: ( fields: BalanceInfoFields, ) => { return new BalanceInfo( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return BalanceInfo.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<BalanceInfo>> { return phantom(BalanceInfo.reified( )); } static get p() { return BalanceInfo.phantom() }
+
+ static get bcs() { return bcs.struct("BalanceInfo", {
+
+ token: TypeName.bcs, value: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): BalanceInfo { return BalanceInfo.reified( ).new( { token: decodeFromFields(TypeName.reified(), fields.token), value: decodeFromFields("u64", fields.value) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): BalanceInfo { if (!isBalanceInfo(item.type)) { throw new Error("not a BalanceInfo type");
+
+ }
+
+ return BalanceInfo.reified( ).new( { token: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.token), value: decodeFromFieldsWithTypes("u64", item.fields.value) } ) }
+
+ static fromBcs( data: Uint8Array ): BalanceInfo { return BalanceInfo.fromFields( BalanceInfo.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ token: this.token.toJSONField(),value: this.value.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): BalanceInfo { return BalanceInfo.reified( ).new( { token: decodeFromJSONField(TypeName.reified(), field.token), value: decodeFromJSONField("u64", field.value) } ) }
+
+ static fromJSON( json: Record<string, any> ): BalanceInfo { if (json.$typeName !== BalanceInfo.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return BalanceInfo.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): BalanceInfo { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isBalanceInfo(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a BalanceInfo object`); } return BalanceInfo.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<BalanceInfo> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching BalanceInfo object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isBalanceInfo(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a BalanceInfo object`); }
+ return BalanceInfo.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== BalancePool =============================== */
+
+export function isBalancePool(type: string): boolean { type = compressSuiType(type); return type === "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalancePool"; }
+
+export interface BalancePoolFields { id: ToField<UID>; balanceInfos: ToField<Vector<BalanceInfo>>; authority: ToField<Authority> }
+
+export type BalancePoolReified = Reified< BalancePool, BalancePoolFields >;
+
+export class BalancePool implements StructClass { static readonly $typeName = "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalancePool"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = BalancePool.$typeName;
+
+ readonly $fullTypeName: "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalancePool";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly balanceInfos: ToField<Vector<BalanceInfo>>; readonly authority: ToField<Authority>
+
+ private constructor(typeArgs: [], fields: BalancePoolFields, ) { this.$fullTypeName = composeSuiType( BalancePool.$typeName, ...typeArgs ) as "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalancePool"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.balanceInfos = fields.balanceInfos;; this.authority = fields.authority; }
+
+ static reified( ): BalancePoolReified { return { typeName: BalancePool.$typeName, fullTypeName: composeSuiType( BalancePool.$typeName, ...[] ) as "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalancePool", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => BalancePool.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => BalancePool.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => BalancePool.fromBcs( data, ), bcs: BalancePool.bcs, fromJSONField: (field: any) => BalancePool.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => BalancePool.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => BalancePool.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => BalancePool.fetch( client, id, ), new: ( fields: BalancePoolFields, ) => { return new BalancePool( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return BalancePool.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<BalancePool>> { return phantom(BalancePool.reified( )); } static get p() { return BalancePool.phantom() }
+
+ static get bcs() { return bcs.struct("BalancePool", {
+
+ id: UID.bcs, balance_infos: bcs.vector(BalanceInfo.bcs), authority: Authority.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): BalancePool { return BalancePool.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), balanceInfos: decodeFromFields(reified.vector(BalanceInfo.reified()), fields.balance_infos), authority: decodeFromFields(Authority.reified(), fields.authority) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): BalancePool { if (!isBalancePool(item.type)) { throw new Error("not a BalancePool type");
+
+ }
+
+ return BalancePool.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), balanceInfos: decodeFromFieldsWithTypes(reified.vector(BalanceInfo.reified()), item.fields.balance_infos), authority: decodeFromFieldsWithTypes(Authority.reified(), item.fields.authority) } ) }
+
+ static fromBcs( data: Uint8Array ): BalancePool { return BalancePool.fromFields( BalancePool.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,balanceInfos: fieldToJSON<Vector<BalanceInfo>>(`vector<0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalanceInfo>`, this.balanceInfos),authority: this.authority.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): BalancePool { return BalancePool.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), balanceInfos: decodeFromJSONField(reified.vector(BalanceInfo.reified()), field.balanceInfos), authority: decodeFromJSONField(Authority.reified(), field.authority) } ) }
+
+ static fromJSON( json: Record<string, any> ): BalancePool { if (json.$typeName !== BalancePool.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return BalancePool.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): BalancePool { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isBalancePool(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a BalancePool object`); } return BalancePool.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<BalancePool> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching BalancePool object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isBalancePool(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a BalancePool object`); }
+ return BalancePool.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== SharedBalancePool =============================== */
+
+export function isSharedBalancePool(type: string): boolean { type = compressSuiType(type); return type === "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::SharedBalancePool"; }
+
+export interface SharedBalancePoolFields { id: ToField<UID>; balanceInfos: ToField<Vector<BalanceInfo>>; authority: ToField<Authority> }
+
+export type SharedBalancePoolReified = Reified< SharedBalancePool, SharedBalancePoolFields >;
+
+export class SharedBalancePool implements StructClass { static readonly $typeName = "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::SharedBalancePool"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = SharedBalancePool.$typeName;
+
+ readonly $fullTypeName: "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::SharedBalancePool";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly balanceInfos: ToField<Vector<BalanceInfo>>; readonly authority: ToField<Authority>
+
+ private constructor(typeArgs: [], fields: SharedBalancePoolFields, ) { this.$fullTypeName = composeSuiType( SharedBalancePool.$typeName, ...typeArgs ) as "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::SharedBalancePool"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.balanceInfos = fields.balanceInfos;; this.authority = fields.authority; }
+
+ static reified( ): SharedBalancePoolReified { return { typeName: SharedBalancePool.$typeName, fullTypeName: composeSuiType( SharedBalancePool.$typeName, ...[] ) as "0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::SharedBalancePool", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => SharedBalancePool.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => SharedBalancePool.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => SharedBalancePool.fromBcs( data, ), bcs: SharedBalancePool.bcs, fromJSONField: (field: any) => SharedBalancePool.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => SharedBalancePool.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => SharedBalancePool.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => SharedBalancePool.fetch( client, id, ), new: ( fields: SharedBalancePoolFields, ) => { return new SharedBalancePool( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return SharedBalancePool.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<SharedBalancePool>> { return phantom(SharedBalancePool.reified( )); } static get p() { return SharedBalancePool.phantom() }
+
+ static get bcs() { return bcs.struct("SharedBalancePool", {
+
+ id: UID.bcs, balance_infos: bcs.vector(BalanceInfo.bcs), authority: Authority.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): SharedBalancePool { return SharedBalancePool.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), balanceInfos: decodeFromFields(reified.vector(BalanceInfo.reified()), fields.balance_infos), authority: decodeFromFields(Authority.reified(), fields.authority) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): SharedBalancePool { if (!isSharedBalancePool(item.type)) { throw new Error("not a SharedBalancePool type");
+
+ }
+
+ return SharedBalancePool.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), balanceInfos: decodeFromFieldsWithTypes(reified.vector(BalanceInfo.reified()), item.fields.balance_infos), authority: decodeFromFieldsWithTypes(Authority.reified(), item.fields.authority) } ) }
+
+ static fromBcs( data: Uint8Array ): SharedBalancePool { return SharedBalancePool.fromFields( SharedBalancePool.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,balanceInfos: fieldToJSON<Vector<BalanceInfo>>(`vector<0x908a10789a1a6953e0b73a997c10e3552f7ce4e2907afd00a334ed74bd973ded::balance_pool::BalanceInfo>`, this.balanceInfos),authority: this.authority.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): SharedBalancePool { return SharedBalancePool.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), balanceInfos: decodeFromJSONField(reified.vector(BalanceInfo.reified()), field.balanceInfos), authority: decodeFromJSONField(Authority.reified(), field.authority) } ) }
+
+ static fromJSON( json: Record<string, any> ): SharedBalancePool { if (json.$typeName !== SharedBalancePool.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return SharedBalancePool.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): SharedBalancePool { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isSharedBalancePool(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a SharedBalancePool object`); } return SharedBalancePool.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<SharedBalancePool> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching SharedBalancePool object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isSharedBalancePool(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a SharedBalancePool object`); }
+ return SharedBalancePool.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

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