@suilend/sdk 12.7.0 → 13.0.0-next.g122801a

package/_generated/_dependencies/pyth-2/price-identifier/structs.d.ts

@@ -0,0 +1,46 @@
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from '../../../_framework/reified';
+import { FieldsWithTypes } from '../../../_framework/util';
+import { Vector } from '../../../_framework/vector';
+export declare function isPriceIdentifier(type: string): boolean;
+export interface PriceIdentifierFields {
+    bytes: ToField<Vector<'u8'>>;
+}
+export type PriceIdentifierReified = Reified<PriceIdentifier, PriceIdentifierFields>;
+export type PriceIdentifierJSONField = {
+    bytes: number[];
+};
+export type PriceIdentifierJSON = {
+    $typeName: typeof PriceIdentifier.$typeName;
+    $typeArgs: [];
+} & PriceIdentifierJSONField;
+export declare class PriceIdentifier implements StructClass {
+    __StructClass: true;
+    static get $typeName(): `${string}::price_identifier::PriceIdentifier`;
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName: typeof PriceIdentifier.$typeName;
+    readonly $fullTypeName: `${string}::price_identifier::PriceIdentifier`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: typeof PriceIdentifier.$isPhantom;
+    readonly bytes: ToField<Vector<'u8'>>;
+    private constructor();
+    static reified(): PriceIdentifierReified;
+    static get r(): PriceIdentifierReified;
+    static phantom(): PhantomReified<ToTypeStr<PriceIdentifier>>;
+    static get p(): PhantomReified<ToTypeStr<PriceIdentifier>>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof PriceIdentifier.instantiateBcs>;
+    static fromFields(fields: Record<string, any>): PriceIdentifier;
+    static fromFieldsWithTypes(item: FieldsWithTypes): PriceIdentifier;
+    static fromBcs(data: Uint8Array): PriceIdentifier;
+    toJSONField(): PriceIdentifierJSONField;
+    toJSON(): PriceIdentifierJSON;
+    static fromJSONField(field: any): PriceIdentifier;
+    static fromJSON(json: Record<string, any>): PriceIdentifier;
+    static fromCoreObject(obj: SuiClientTypes.Object<{
+        content: true;
+    }>): PriceIdentifier;
+    static fetch(client: ClientWithCoreApi, id: string): Promise<PriceIdentifier>;
+}

package/_generated/_dependencies/{source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e → pyth-2}/price-identifier/structs.js

@@ -1,16 +1,18 @@
-import * as reified from "../../../../_framework/reified.js";
-import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, fieldToJSON, phantom, } from "../../../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../../../_framework/util.js";
-import { PKG_V1 } from "../index.js";
-import { bcs } from "@mysten/sui/bcs";
+import { bcs } from '@mysten/sui/bcs';
+import { getTypeOrigin } from '../../../_envs/index.js';
+import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, fieldToJSON, phantom, vector, } from '../../../_framework/reified.js';
+import { composeSuiType, compressSuiType } from '../../../_framework/util.js';
 /* ============================== PriceIdentifier =============================== */
 export function isPriceIdentifier(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::price_identifier::PriceIdentifier`;
+    return type
+        === `${getTypeOrigin('pyth-2', 'price_identifier::PriceIdentifier')}::price_identifier::PriceIdentifier`;
 }
 export class PriceIdentifier {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::price_identifier::PriceIdentifier`;
+    static get $typeName() {
+        return `${getTypeOrigin('pyth-2', 'price_identifier::PriceIdentifier')}::price_identifier::PriceIdentifier`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = PriceIdentifier.$typeName;
@@ -24,23 +26,29 @@ export class PriceIdentifier {
         this.bytes = fields.bytes;
     }
     static reified() {
+        const reifiedBcs = PriceIdentifier.bcs;
         return {
-            typeName: PriceIdentifier.$typeName,
-            fullTypeName: composeSuiType(PriceIdentifier.$typeName, ...[]),
+            get typeName() {
+                return PriceIdentifier.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(PriceIdentifier.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: PriceIdentifier.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => PriceIdentifier.fromFields(fields),
             fromFieldsWithTypes: (item) => PriceIdentifier.fromFieldsWithTypes(item),
-            fromBcs: (data) => PriceIdentifier.fromBcs(data),
-            bcs: PriceIdentifier.bcs,
+            fromBcs: (data) => PriceIdentifier.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => PriceIdentifier.fromJSONField(field),
             fromJSON: (json) => PriceIdentifier.fromJSON(json),
+            fromCoreObject: (obj) => PriceIdentifier.fromCoreObject(obj),
             fetch: async (client, id) => PriceIdentifier.fetch(client, id),
             new: (fields) => {
                 return new PriceIdentifier([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -52,22 +60,29 @@ export class PriceIdentifier {
     static get p() {
         return PriceIdentifier.phantom();
     }
-    static get bcs() {
-        return bcs.struct("PriceIdentifier", {
+    static instantiateBcs() {
+        return bcs.struct('PriceIdentifier', {
             bytes: bcs.vector(bcs.u8()),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!PriceIdentifier.cachedBcs) {
+            PriceIdentifier.cachedBcs = PriceIdentifier.instantiateBcs();
+        }
+        return PriceIdentifier.cachedBcs;
+    }
     static fromFields(fields) {
         return PriceIdentifier.reified().new({
-            bytes: decodeFromFields(reified.vector("u8"), fields.bytes),
+            bytes: decodeFromFields(vector('u8'), fields.bytes),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isPriceIdentifier(item.type)) {
-            throw new Error("not a PriceIdentifier type");
+            throw new Error('not a PriceIdentifier type');
         }
         return PriceIdentifier.reified().new({
-            bytes: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.bytes),
+            bytes: decodeFromFieldsWithTypes(vector('u8'), item.fields.bytes),
         });
     }
     static fromBcs(data) {
@@ -79,25 +94,30 @@ export class PriceIdentifier {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return PriceIdentifier.reified().new({
-            bytes: decodeFromJSONField(reified.vector("u8"), field.bytes),
+            bytes: decodeFromJSONField(vector('u8'), field.bytes),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== PriceIdentifier.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a PriceIdentifier json object: expected '${PriceIdentifier.$typeName}' but got '${json.$typeName}'`);
         }
         return PriceIdentifier.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isPriceIdentifier(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a PriceIdentifier object`);
+        }
+        return PriceIdentifier.fromBcs(obj.content);
+    }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
         if (!isPriceIdentifier(object.type)) {
             throw new Error(`object at id ${id} is not a PriceIdentifier object`);
         }

package/_generated/_dependencies/std/ascii/structs.d.ts

@@ -0,0 +1,100 @@
+/**
+ * The `ASCII` module defines basic string and char newtypes in Move that verify
+ * that characters are valid ASCII, and that strings consist of only valid ASCII characters.
+ */
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from '../../../_framework/reified';
+import { FieldsWithTypes } from '../../../_framework/util';
+import { Vector } from '../../../_framework/vector';
+export declare function isString(type: string): boolean;
+export interface StringFields {
+    bytes: ToField<Vector<'u8'>>;
+}
+export type StringReified = Reified<String, StringFields>;
+export type StringJSONField = {
+    bytes: number[];
+};
+export type StringJSON = {
+    $typeName: typeof String.$typeName;
+    $typeArgs: [];
+} & StringJSONField;
+/**
+ * The `String` struct holds a vector of bytes that all represent
+ * valid ASCII characters. Note that these ASCII characters may not all
+ * be printable. To determine if a `String` contains only "printable"
+ * characters you should use the `all_characters_printable` predicate
+ * defined in this module.
+ */
+export declare class String implements StructClass {
+    __StructClass: true;
+    static readonly $typeName: `0x1::ascii::String`;
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName: typeof String.$typeName;
+    readonly $fullTypeName: `0x1::ascii::String`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: typeof String.$isPhantom;
+    readonly bytes: ToField<Vector<'u8'>>;
+    private constructor();
+    static reified(): StringReified;
+    static get r(): StringReified;
+    static phantom(): PhantomReified<ToTypeStr<String>>;
+    static get p(): PhantomReified<ToTypeStr<String>>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof String.instantiateBcs>;
+    static fromFields(fields: Record<string, any>): String;
+    static fromFieldsWithTypes(item: FieldsWithTypes): String;
+    static fromBcs(data: Uint8Array): String;
+    toJSONField(): StringJSONField;
+    toJSON(): StringJSON;
+    static fromJSONField(field: any): String;
+    static fromJSON(json: Record<string, any>): String;
+    static fromCoreObject(obj: SuiClientTypes.Object<{
+        content: true;
+    }>): String;
+    static fetch(client: ClientWithCoreApi, id: string): Promise<String>;
+}
+export declare function isChar(type: string): boolean;
+export interface CharFields {
+    byte: ToField<'u8'>;
+}
+export type CharReified = Reified<Char, CharFields>;
+export type CharJSONField = {
+    byte: number;
+};
+export type CharJSON = {
+    $typeName: typeof Char.$typeName;
+    $typeArgs: [];
+} & CharJSONField;
+/** An ASCII character. */
+export declare class Char implements StructClass {
+    __StructClass: true;
+    static readonly $typeName: `0x1::ascii::Char`;
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName: typeof Char.$typeName;
+    readonly $fullTypeName: `0x1::ascii::Char`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: typeof Char.$isPhantom;
+    readonly byte: ToField<'u8'>;
+    private constructor();
+    static reified(): CharReified;
+    static get r(): CharReified;
+    static phantom(): PhantomReified<ToTypeStr<Char>>;
+    static get p(): PhantomReified<ToTypeStr<Char>>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof Char.instantiateBcs>;
+    static fromFields(fields: Record<string, any>): Char;
+    static fromFieldsWithTypes(item: FieldsWithTypes): Char;
+    static fromBcs(data: Uint8Array): Char;
+    toJSONField(): CharJSONField;
+    toJSON(): CharJSON;
+    static fromJSONField(field: any): Char;
+    static fromJSON(json: Record<string, any>): Char;
+    static fromCoreObject(obj: SuiClientTypes.Object<{
+        content: true;
+    }>): Char;
+    static fetch(client: ClientWithCoreApi, id: string): Promise<Char>;
+}

package/_generated/_dependencies/{source/0x1 → std}/ascii/structs.js

@@ -1,203 +1,253 @@
-import * as reified from "../../../../_framework/reified.js";
-import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, fieldToJSON, phantom, } from "../../../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../../../_framework/util.js";
-import { PKG_V13 } from "../index.js";
-import { bcs } from "@mysten/sui/bcs";
-/* ============================== Char =============================== */
-export function isChar(type) {
+/**
+ * The `ASCII` module defines basic string and char newtypes in Move that verify
+ * that characters are valid ASCII, and that strings consist of only valid ASCII characters.
+ */
+import { bcs } from '@mysten/sui/bcs';
+import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, fieldToJSON, phantom, vector, } from '../../../_framework/reified.js';
+import { composeSuiType, compressSuiType } from '../../../_framework/util.js';
+/* ============================== String =============================== */
+export function isString(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V13}::ascii::Char`;
+    return type === `0x1::ascii::String`;
 }
-export class Char {
+/**
+ * The `String` struct holds a vector of bytes that all represent
+ * valid ASCII characters. Note that these ASCII characters may not all
+ * be printable. To determine if a `String` contains only "printable"
+ * characters you should use the `all_characters_printable` predicate
+ * defined in this module.
+ */
+export class String {
     __StructClass = true;
-    static $typeName = `${PKG_V13}::ascii::Char`;
+    static $typeName = `0x1::ascii::String`;
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = Char.$typeName;
+    $typeName = String.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = Char.$isPhantom;
-    byte;
+    $isPhantom = String.$isPhantom;
+    bytes;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(Char.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(String.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.byte = fields.byte;
+        this.bytes = fields.bytes;
     }
     static reified() {
+        const reifiedBcs = String.bcs;
         return {
-            typeName: Char.$typeName,
-            fullTypeName: composeSuiType(Char.$typeName, ...[]),
+            get typeName() {
+                return String.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(String.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: Char.$isPhantom,
+            isPhantom: String.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => Char.fromFields(fields),
-            fromFieldsWithTypes: (item) => Char.fromFieldsWithTypes(item),
-            fromBcs: (data) => Char.fromBcs(data),
-            bcs: Char.bcs,
-            fromJSONField: (field) => Char.fromJSONField(field),
-            fromJSON: (json) => Char.fromJSON(json),
-            fetch: async (client, id) => Char.fetch(client, id),
+            fromFields: (fields) => String.fromFields(fields),
+            fromFieldsWithTypes: (item) => String.fromFieldsWithTypes(item),
+            fromBcs: (data) => String.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => String.fromJSONField(field),
+            fromJSON: (json) => String.fromJSON(json),
+            fromCoreObject: (obj) => String.fromCoreObject(obj),
+            fetch: async (client, id) => String.fetch(client, id),
             new: (fields) => {
-                return new Char([], fields);
+                return new String([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return Char.reified();
+        return String.reified();
     }
     static phantom() {
-        return phantom(Char.reified());
+        return phantom(String.reified());
     }
     static get p() {
-        return Char.phantom();
+        return String.phantom();
     }
-    static get bcs() {
-        return bcs.struct("Char", {
-            byte: bcs.u8(),
+    static instantiateBcs() {
+        return bcs.struct('String', {
+            bytes: bcs.vector(bcs.u8()),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!String.cachedBcs) {
+            String.cachedBcs = String.instantiateBcs();
+        }
+        return String.cachedBcs;
+    }
     static fromFields(fields) {
-        return Char.reified().new({ byte: decodeFromFields("u8", fields.byte) });
+        return String.reified().new({
+            bytes: decodeFromFields(vector('u8'), fields.bytes),
+        });
     }
     static fromFieldsWithTypes(item) {
-        if (!isChar(item.type)) {
-            throw new Error("not a Char type");
+        if (!isString(item.type)) {
+            throw new Error('not a String type');
         }
-        return Char.reified().new({
-            byte: decodeFromFieldsWithTypes("u8", item.fields.byte),
+        return String.reified().new({
+            bytes: decodeFromFieldsWithTypes(vector('u8'), item.fields.bytes),
         });
     }
     static fromBcs(data) {
-        return Char.fromFields(Char.bcs.parse(data));
+        return String.fromFields(String.bcs.parse(data));
     }
     toJSONField() {
         return {
-            byte: this.byte,
+            bytes: fieldToJSON(`vector<u8>`, this.bytes),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return Char.reified().new({ byte: decodeFromJSONField("u8", field.byte) });
+        return String.reified().new({
+            bytes: decodeFromJSONField(vector('u8'), field.bytes),
+        });
     }
     static fromJSON(json) {
-        if (json.$typeName !== Char.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== String.$typeName) {
+            throw new Error(`not a String json object: expected '${String.$typeName}' but got '${json.$typeName}'`);
         }
-        return Char.fromJSONField(json);
+        return String.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isString(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a String object`);
+        }
+        return String.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isChar(object.type)) {
-            throw new Error(`object at id ${id} is not a Char object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isString(object.type)) {
+            throw new Error(`object at id ${id} is not a String object`);
         }
-        return Char.fromBcs(object.content);
+        return String.fromBcs(object.content);
     }
 }
-/* ============================== String =============================== */
-export function isString(type) {
+/* ============================== Char =============================== */
+export function isChar(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V13}::ascii::String`;
+    return type === `0x1::ascii::Char`;
 }
-export class String {
+/** An ASCII character. */
+export class Char {
     __StructClass = true;
-    static $typeName = `${PKG_V13}::ascii::String`;
+    static $typeName = `0x1::ascii::Char`;
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = String.$typeName;
+    $typeName = Char.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = String.$isPhantom;
-    bytes;
+    $isPhantom = Char.$isPhantom;
+    byte;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(String.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(Char.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.bytes = fields.bytes;
+        this.byte = fields.byte;
     }
     static reified() {
+        const reifiedBcs = Char.bcs;
         return {
-            typeName: String.$typeName,
-            fullTypeName: composeSuiType(String.$typeName, ...[]),
+            get typeName() {
+                return Char.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(Char.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: String.$isPhantom,
+            isPhantom: Char.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => String.fromFields(fields),
-            fromFieldsWithTypes: (item) => String.fromFieldsWithTypes(item),
-            fromBcs: (data) => String.fromBcs(data),
-            bcs: String.bcs,
-            fromJSONField: (field) => String.fromJSONField(field),
-            fromJSON: (json) => String.fromJSON(json),
-            fetch: async (client, id) => String.fetch(client, id),
+            fromFields: (fields) => Char.fromFields(fields),
+            fromFieldsWithTypes: (item) => Char.fromFieldsWithTypes(item),
+            fromBcs: (data) => Char.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => Char.fromJSONField(field),
+            fromJSON: (json) => Char.fromJSON(json),
+            fromCoreObject: (obj) => Char.fromCoreObject(obj),
+            fetch: async (client, id) => Char.fetch(client, id),
             new: (fields) => {
-                return new String([], fields);
+                return new Char([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return String.reified();
+        return Char.reified();
     }
     static phantom() {
-        return phantom(String.reified());
+        return phantom(Char.reified());
     }
     static get p() {
-        return String.phantom();
+        return Char.phantom();
     }
-    static get bcs() {
-        return bcs.struct("String", {
-            bytes: bcs.vector(bcs.u8()),
+    static instantiateBcs() {
+        return bcs.struct('Char', {
+            byte: bcs.u8(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!Char.cachedBcs) {
+            Char.cachedBcs = Char.instantiateBcs();
+        }
+        return Char.cachedBcs;
+    }
     static fromFields(fields) {
-        return String.reified().new({
-            bytes: decodeFromFields(reified.vector("u8"), fields.bytes),
+        return Char.reified().new({
+            byte: decodeFromFields('u8', fields.byte),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isString(item.type)) {
-            throw new Error("not a String type");
+        if (!isChar(item.type)) {
+            throw new Error('not a Char type');
         }
-        return String.reified().new({
-            bytes: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.bytes),
+        return Char.reified().new({
+            byte: decodeFromFieldsWithTypes('u8', item.fields.byte),
         });
     }
     static fromBcs(data) {
-        return String.fromFields(String.bcs.parse(data));
+        return Char.fromFields(Char.bcs.parse(data));
     }
     toJSONField() {
         return {
-            bytes: fieldToJSON(`vector<u8>`, this.bytes),
+            byte: this.byte,
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return String.reified().new({
-            bytes: decodeFromJSONField(reified.vector("u8"), field.bytes),
+        return Char.reified().new({
+            byte: decodeFromJSONField('u8', field.byte),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== String.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== Char.$typeName) {
+            throw new Error(`not a Char json object: expected '${Char.$typeName}' but got '${json.$typeName}'`);
         }
-        return String.fromJSONField(json);
+        return Char.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isChar(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a Char object`);
+        }
+        return Char.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isString(object.type)) {
-            throw new Error(`object at id ${id} is not a String object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isChar(object.type)) {
+            throw new Error(`object at id ${id} is not a Char object`);
         }
-        return String.fromBcs(object.content);
+        return Char.fromBcs(object.content);
     }
 }