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

package/src/_dependencies/source/0x98670585b87e06628ef2d7f7cb1e7bee8ada65b43b82997935225a7e6e21d18e/quote/structs.ts

@@ -0,0 +1,71 @@
+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 {UID} from "../../0x2/object/structs";
+import {bcs, fromB64, fromHEX, toHEX} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== Quote =============================== */
+
+export function isQuote(type: string): boolean { type = compressSuiType(type); return type === "0x98670585b87e06628ef2d7f7cb1e7bee8ada65b43b82997935225a7e6e21d18e::quote::Quote"; }
+
+export interface QuoteFields { id: ToField<UID>; nodeAddr: ToField<"address">; nodeAuthority: ToField<"address">; queueAddr: ToField<"address">; quoteBuffer: ToField<Vector<"u8">>; verificationStatus: ToField<"u8">; verificationTimestamp: ToField<"u64">; validUntil: ToField<"u64">; contentHashEnabled: ToField<"bool">; friendKey: ToField<Vector<"u8">>; version: ToField<"u64"> }
+
+export type QuoteReified = Reified< Quote, QuoteFields >;
+
+export class Quote implements StructClass { static readonly $typeName = "0x98670585b87e06628ef2d7f7cb1e7bee8ada65b43b82997935225a7e6e21d18e::quote::Quote"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Quote.$typeName;
+
+ readonly $fullTypeName: "0x98670585b87e06628ef2d7f7cb1e7bee8ada65b43b82997935225a7e6e21d18e::quote::Quote";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly nodeAddr: ToField<"address">; readonly nodeAuthority: ToField<"address">; readonly queueAddr: ToField<"address">; readonly quoteBuffer: ToField<Vector<"u8">>; readonly verificationStatus: ToField<"u8">; readonly verificationTimestamp: ToField<"u64">; readonly validUntil: ToField<"u64">; readonly contentHashEnabled: ToField<"bool">; readonly friendKey: ToField<Vector<"u8">>; readonly version: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: QuoteFields, ) { this.$fullTypeName = composeSuiType( Quote.$typeName, ...typeArgs ) as "0x98670585b87e06628ef2d7f7cb1e7bee8ada65b43b82997935225a7e6e21d18e::quote::Quote"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.nodeAddr = fields.nodeAddr;; this.nodeAuthority = fields.nodeAuthority;; this.queueAddr = fields.queueAddr;; this.quoteBuffer = fields.quoteBuffer;; this.verificationStatus = fields.verificationStatus;; this.verificationTimestamp = fields.verificationTimestamp;; this.validUntil = fields.validUntil;; this.contentHashEnabled = fields.contentHashEnabled;; this.friendKey = fields.friendKey;; this.version = fields.version; }
+
+ static reified( ): QuoteReified { return { typeName: Quote.$typeName, fullTypeName: composeSuiType( Quote.$typeName, ...[] ) as "0x98670585b87e06628ef2d7f7cb1e7bee8ada65b43b82997935225a7e6e21d18e::quote::Quote", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Quote.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Quote.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Quote.fromBcs( data, ), bcs: Quote.bcs, fromJSONField: (field: any) => Quote.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Quote.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Quote.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Quote.fetch( client, id, ), new: ( fields: QuoteFields, ) => { return new Quote( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Quote.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Quote>> { return phantom(Quote.reified( )); } static get p() { return Quote.phantom() }
+
+ static get bcs() { return bcs.struct("Quote", {
+
+ id: UID.bcs, node_addr: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), node_authority: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), queue_addr: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), quote_buffer: bcs.vector(bcs.u8()), verification_status: bcs.u8(), verification_timestamp: bcs.u64(), valid_until: bcs.u64(), content_hash_enabled: bcs.bool(), friend_key: bcs.vector(bcs.u8()), version: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Quote { return Quote.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), nodeAddr: decodeFromFields("address", fields.node_addr), nodeAuthority: decodeFromFields("address", fields.node_authority), queueAddr: decodeFromFields("address", fields.queue_addr), quoteBuffer: decodeFromFields(reified.vector("u8"), fields.quote_buffer), verificationStatus: decodeFromFields("u8", fields.verification_status), verificationTimestamp: decodeFromFields("u64", fields.verification_timestamp), validUntil: decodeFromFields("u64", fields.valid_until), contentHashEnabled: decodeFromFields("bool", fields.content_hash_enabled), friendKey: decodeFromFields(reified.vector("u8"), fields.friend_key), version: decodeFromFields("u64", fields.version) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Quote { if (!isQuote(item.type)) { throw new Error("not a Quote type");
+
+ }
+
+ return Quote.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), nodeAddr: decodeFromFieldsWithTypes("address", item.fields.node_addr), nodeAuthority: decodeFromFieldsWithTypes("address", item.fields.node_authority), queueAddr: decodeFromFieldsWithTypes("address", item.fields.queue_addr), quoteBuffer: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.quote_buffer), verificationStatus: decodeFromFieldsWithTypes("u8", item.fields.verification_status), verificationTimestamp: decodeFromFieldsWithTypes("u64", item.fields.verification_timestamp), validUntil: decodeFromFieldsWithTypes("u64", item.fields.valid_until), contentHashEnabled: decodeFromFieldsWithTypes("bool", item.fields.content_hash_enabled), friendKey: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.friend_key), version: decodeFromFieldsWithTypes("u64", item.fields.version) } ) }
+
+ static fromBcs( data: Uint8Array ): Quote { return Quote.fromFields( Quote.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,nodeAddr: this.nodeAddr,nodeAuthority: this.nodeAuthority,queueAddr: this.queueAddr,quoteBuffer: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.quoteBuffer),verificationStatus: this.verificationStatus,verificationTimestamp: this.verificationTimestamp.toString(),validUntil: this.validUntil.toString(),contentHashEnabled: this.contentHashEnabled,friendKey: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.friendKey),version: this.version.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Quote { return Quote.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), nodeAddr: decodeFromJSONField("address", field.nodeAddr), nodeAuthority: decodeFromJSONField("address", field.nodeAuthority), queueAddr: decodeFromJSONField("address", field.queueAddr), quoteBuffer: decodeFromJSONField(reified.vector("u8"), field.quoteBuffer), verificationStatus: decodeFromJSONField("u8", field.verificationStatus), verificationTimestamp: decodeFromJSONField("u64", field.verificationTimestamp), validUntil: decodeFromJSONField("u64", field.validUntil), contentHashEnabled: decodeFromJSONField("bool", field.contentHashEnabled), friendKey: decodeFromJSONField(reified.vector("u8"), field.friendKey), version: decodeFromJSONField("u64", field.version) } ) }
+
+ static fromJSON( json: Record<string, any> ): Quote { if (json.$typeName !== Quote.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Quote.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Quote { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isQuote(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Quote object`); } return Quote.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Quote> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Quote object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isQuote(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Quote object`); }
+ return Quote.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

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

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

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

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

@@ -0,0 +1,11 @@
+import * as kioskLockRule from "./kiosk-lock-rule/structs";
+import * as royaltyRule from "./royalty-rule/structs";
+import * as witnessRule from "./witness-rule/structs";
+import {StructClassLoader} from "../../../_framework/loader";
+
+export function registerClasses(loader: StructClassLoader) { loader.register(royaltyRule.Rule);
+loader.register(royaltyRule.Config);
+loader.register(kioskLockRule.Rule);
+loader.register(kioskLockRule.Config);
+loader.register(witnessRule.Rule);
+ }

package/src/_dependencies/source/0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585/kiosk-lock-rule/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} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== Rule =============================== */
+
+export function isRule(type: string): boolean { type = compressSuiType(type); return type === "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::kiosk_lock_rule::Rule"; }
+
+export interface RuleFields { dummyField: ToField<"bool"> }
+
+export type RuleReified = Reified< Rule, RuleFields >;
+
+export class Rule implements StructClass { static readonly $typeName = "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::kiosk_lock_rule::Rule"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Rule.$typeName;
+
+ readonly $fullTypeName: "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::kiosk_lock_rule::Rule";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: RuleFields, ) { this.$fullTypeName = composeSuiType( Rule.$typeName, ...typeArgs ) as "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::kiosk_lock_rule::Rule"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): RuleReified { return { typeName: Rule.$typeName, fullTypeName: composeSuiType( Rule.$typeName, ...[] ) as "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::kiosk_lock_rule::Rule", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Rule.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Rule.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Rule.fromBcs( data, ), bcs: Rule.bcs, fromJSONField: (field: any) => Rule.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Rule.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Rule.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Rule.fetch( client, id, ), new: ( fields: RuleFields, ) => { return new Rule( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Rule.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Rule>> { return phantom(Rule.reified( )); } static get p() { return Rule.phantom() }
+
+ static get bcs() { return bcs.struct("Rule", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Rule { return Rule.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Rule { if (!isRule(item.type)) { throw new Error("not a Rule type");
+
+ }
+
+ return Rule.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): Rule { return Rule.fromFields( Rule.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Rule { return Rule.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): Rule { if (json.$typeName !== Rule.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Rule.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Rule { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isRule(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Rule object`); } return Rule.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Rule> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Rule object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isRule(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Rule object`); }
+ return Rule.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== Config =============================== */
+
+export function isConfig(type: string): boolean { type = compressSuiType(type); return type === "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::kiosk_lock_rule::Config"; }
+
+export interface ConfigFields { dummyField: ToField<"bool"> }
+
+export type ConfigReified = Reified< Config, ConfigFields >;
+
+export class Config implements StructClass { static readonly $typeName = "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::kiosk_lock_rule::Config"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Config.$typeName;
+
+ readonly $fullTypeName: "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::kiosk_lock_rule::Config";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: ConfigFields, ) { this.$fullTypeName = composeSuiType( Config.$typeName, ...typeArgs ) as "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::kiosk_lock_rule::Config"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): ConfigReified { return { typeName: Config.$typeName, fullTypeName: composeSuiType( Config.$typeName, ...[] ) as "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::kiosk_lock_rule::Config", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Config.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Config.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Config.fromBcs( data, ), bcs: Config.bcs, fromJSONField: (field: any) => Config.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Config.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Config.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Config.fetch( client, id, ), new: ( fields: ConfigFields, ) => { return new Config( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Config.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Config>> { return phantom(Config.reified( )); } static get p() { return Config.phantom() }
+
+ static get bcs() { return bcs.struct("Config", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Config { return Config.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Config { if (!isConfig(item.type)) { throw new Error("not a Config type");
+
+ }
+
+ return Config.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): Config { return Config.fromFields( Config.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Config { return Config.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): Config { if (json.$typeName !== Config.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Config.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Config { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isConfig(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Config object`); } return Config.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Config> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Config object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isConfig(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Config object`); }
+ return Config.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585/royalty-rule/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} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== Rule =============================== */
+
+export function isRule(type: string): boolean { type = compressSuiType(type); return type === "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::royalty_rule::Rule"; }
+
+export interface RuleFields { dummyField: ToField<"bool"> }
+
+export type RuleReified = Reified< Rule, RuleFields >;
+
+export class Rule implements StructClass { static readonly $typeName = "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::royalty_rule::Rule"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Rule.$typeName;
+
+ readonly $fullTypeName: "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::royalty_rule::Rule";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: RuleFields, ) { this.$fullTypeName = composeSuiType( Rule.$typeName, ...typeArgs ) as "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::royalty_rule::Rule"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): RuleReified { return { typeName: Rule.$typeName, fullTypeName: composeSuiType( Rule.$typeName, ...[] ) as "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::royalty_rule::Rule", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Rule.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Rule.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Rule.fromBcs( data, ), bcs: Rule.bcs, fromJSONField: (field: any) => Rule.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Rule.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Rule.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Rule.fetch( client, id, ), new: ( fields: RuleFields, ) => { return new Rule( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Rule.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Rule>> { return phantom(Rule.reified( )); } static get p() { return Rule.phantom() }
+
+ static get bcs() { return bcs.struct("Rule", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Rule { return Rule.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Rule { if (!isRule(item.type)) { throw new Error("not a Rule type");
+
+ }
+
+ return Rule.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): Rule { return Rule.fromFields( Rule.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Rule { return Rule.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): Rule { if (json.$typeName !== Rule.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Rule.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Rule { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isRule(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Rule object`); } return Rule.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Rule> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Rule object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isRule(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Rule object`); }
+ return Rule.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== Config =============================== */
+
+export function isConfig(type: string): boolean { type = compressSuiType(type); return type === "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::royalty_rule::Config"; }
+
+export interface ConfigFields { amountBp: ToField<"u16">; minAmount: ToField<"u64"> }
+
+export type ConfigReified = Reified< Config, ConfigFields >;
+
+export class Config implements StructClass { static readonly $typeName = "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::royalty_rule::Config"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Config.$typeName;
+
+ readonly $fullTypeName: "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::royalty_rule::Config";
+
+ readonly $typeArgs: [];
+
+ readonly amountBp: ToField<"u16">; readonly minAmount: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: ConfigFields, ) { this.$fullTypeName = composeSuiType( Config.$typeName, ...typeArgs ) as "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::royalty_rule::Config"; this.$typeArgs = typeArgs;
+
+ this.amountBp = fields.amountBp;; this.minAmount = fields.minAmount; }
+
+ static reified( ): ConfigReified { return { typeName: Config.$typeName, fullTypeName: composeSuiType( Config.$typeName, ...[] ) as "0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585::royalty_rule::Config", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Config.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Config.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Config.fromBcs( data, ), bcs: Config.bcs, fromJSONField: (field: any) => Config.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Config.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Config.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Config.fetch( client, id, ), new: ( fields: ConfigFields, ) => { return new Config( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Config.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Config>> { return phantom(Config.reified( )); } static get p() { return Config.phantom() }
+
+ static get bcs() { return bcs.struct("Config", {
+
+ amount_bp: bcs.u16(), min_amount: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Config { return Config.reified( ).new( { amountBp: decodeFromFields("u16", fields.amount_bp), minAmount: decodeFromFields("u64", fields.min_amount) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Config { if (!isConfig(item.type)) { throw new Error("not a Config type");
+
+ }
+
+ return Config.reified( ).new( { amountBp: decodeFromFieldsWithTypes("u16", item.fields.amount_bp), minAmount: decodeFromFieldsWithTypes("u64", item.fields.min_amount) } ) }
+
+ static fromBcs( data: Uint8Array ): Config { return Config.fromFields( Config.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ amountBp: this.amountBp,minAmount: this.minAmount.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Config { return Config.reified( ).new( { amountBp: decodeFromJSONField("u16", field.amountBp), minAmount: decodeFromJSONField("u64", field.minAmount) } ) }
+
+ static fromJSON( json: Record<string, any> ): Config { if (json.$typeName !== Config.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Config.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Config { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isConfig(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Config object`); } return Config.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Config> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Config object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isConfig(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Config object`); }
+ return Config.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }

package/src/_dependencies/source/0xbd8fc1947cf119350184107a3087e2dc27efefa0dd82e25a1f699069fe81a585/witness-rule/structs.ts

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

package/src/_dependencies/source/0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e/bytes20/structs.ts

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