@bitgo/sdk-coin-sui 2.0.1 → 3.0.1

package/dist/src/lib/mystenlab/types/objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/types/objects.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/mystenlab/types/objects.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginatedObjectsResponse = exports.CheckpointedObjectId = exports.getMovePackageContent = exports.hasPublicTransfer = exports.getMoveObject = exports.getObjectFields = exports.getMoveObjectType = exports.isImmutableObject = exports.isSharedObject = exports.getSharedObjectInitialVersion = exports.getObjectDisplay = exports.getObjectOwner = exports.getObjectPreviousTransactionDigest = exports.getObjectType = exports.isSuiObjectResponse = exports.getObjectVersion = exports.getObjectId = exports.getObjectReference = exports.getObjectNotExistsResponse = exports.getObjectDeletedResponse = exports.getSuiObjectData = exports.SuiObjectResponse = exports.SuiObjectResponseError = exports.GetOwnedObjectsResponse = exports.ObjectStatus = exports.SuiObjectDataOptions = exports.SuiObjectData = exports.ObjectDigest = exports.MIST_PER_SUI = exports.SuiRawData = exports.SuiRawMovePackage = exports.SuiRawMoveObject = exports.SuiParsedData = exports.SuiMovePackage = exports.SuiMoveObject = exports.MovePackageContent = exports.ObjectContentFields = exports.SuiObjectInfo = exports.SuiGasData = exports.SuiObjectRef = exports.ObjectType = void 0;
+const superstruct_1 = require("superstruct");
+const common_1 = require("./common");
+exports.ObjectType = superstruct_1.union([superstruct_1.string(), superstruct_1.literal('package')]);
+exports.SuiObjectRef = superstruct_1.object({
+    /** Base64 string representing the object digest */
+    digest: common_1.TransactionDigest,
+    /** Hex code as string representing the object id */
+    objectId: superstruct_1.string(),
+    /** Object version */
+    version: superstruct_1.union([superstruct_1.number(), superstruct_1.string()]),
+});
+exports.SuiGasData = superstruct_1.object({
+    payment: superstruct_1.array(exports.SuiObjectRef),
+    /** Gas Object's owner */
+    owner: superstruct_1.string(),
+    price: superstruct_1.number(),
+    budget: superstruct_1.number(),
+});
+exports.SuiObjectInfo = superstruct_1.assign(exports.SuiObjectRef, superstruct_1.object({
+    type: superstruct_1.string(),
+    owner: common_1.ObjectOwner,
+    previousTransaction: common_1.TransactionDigest,
+}));
+exports.ObjectContentFields = superstruct_1.record(superstruct_1.string(), superstruct_1.any());
+exports.MovePackageContent = superstruct_1.record(superstruct_1.string(), superstruct_1.string());
+exports.SuiMoveObject = superstruct_1.object({
+    /** Move type (e.g., "0x2::coin::Coin<0x2::sui::SUI>") */
+    type: superstruct_1.string(),
+    /** Fields and values stored inside the Move object */
+    fields: exports.ObjectContentFields,
+    hasPublicTransfer: superstruct_1.boolean(),
+});
+exports.SuiMovePackage = superstruct_1.object({
+    /** A mapping from module name to disassembled Move bytecode */
+    disassembled: exports.MovePackageContent,
+});
+exports.SuiParsedData = superstruct_1.union([
+    superstruct_1.assign(exports.SuiMoveObject, superstruct_1.object({ dataType: superstruct_1.literal('moveObject') })),
+    superstruct_1.assign(exports.SuiMovePackage, superstruct_1.object({ dataType: superstruct_1.literal('package') })),
+]);
+exports.SuiRawMoveObject = superstruct_1.object({
+    /** Move type (e.g., "0x2::coin::Coin<0x2::sui::SUI>") */
+    type: superstruct_1.string(),
+    hasPublicTransfer: superstruct_1.boolean(),
+    version: common_1.SequenceNumber,
+    bcsBytes: superstruct_1.array(superstruct_1.number()),
+});
+exports.SuiRawMovePackage = superstruct_1.object({
+    id: common_1.ObjectId,
+    /** A mapping from module name to Move bytecode enocded in base64*/
+    moduleMap: superstruct_1.record(superstruct_1.string(), superstruct_1.string()),
+});
+// TODO(chris): consolidate SuiRawParsedData and SuiRawObject using generics
+exports.SuiRawData = superstruct_1.union([
+    superstruct_1.assign(exports.SuiMoveObject, superstruct_1.object({ dataType: superstruct_1.literal('moveObject') })),
+    superstruct_1.assign(exports.SuiRawMovePackage, superstruct_1.object({ dataType: superstruct_1.literal('package') })),
+]);
+exports.MIST_PER_SUI = BigInt(1000000000);
+exports.ObjectDigest = superstruct_1.string();
+exports.SuiObjectData = superstruct_1.object({
+    objectId: common_1.ObjectId,
+    version: common_1.SequenceNumber,
+    digest: exports.ObjectDigest,
+    /**
+     * Type of the object, default to be undefined unless SuiObjectDataOptions.showType is set to true
+     */
+    type: superstruct_1.optional(superstruct_1.string()),
+    /**
+     * Move object content or package content, default to be undefined unless SuiObjectDataOptions.showContent is set to true
+     */
+    content: superstruct_1.optional(exports.SuiParsedData),
+    /**
+     * Move object content or package content in BCS bytes, default to be undefined unless SuiObjectDataOptions.showBcs is set to true
+     */
+    bcs: superstruct_1.optional(exports.SuiRawData),
+    /**
+     * The owner of this object. Default to be undefined unless SuiObjectDataOptions.showOwner is set to true
+     */
+    owner: superstruct_1.optional(common_1.ObjectOwner),
+    /**
+     * The digest of the transaction that created or last mutated this object.
+     * Default to be undefined unless SuiObjectDataOptions.showPreviousTransaction is set to true
+     */
+    previousTransaction: superstruct_1.optional(common_1.TransactionDigest),
+    /**
+     * The amount of SUI we would rebate if this object gets deleted.
+     * This number is re-calculated each time the object is mutated based on
+     * the present storage gas price.
+     * Default to be undefined unless SuiObjectDataOptions.showStorageRebate is set to true
+     */
+    storageRebate: superstruct_1.optional(superstruct_1.number()),
+    /**
+     * Display metadata for this object, default to be undefined unless SuiObjectDataOptions.showDisplay is set to true
+     * This can also be None if the struct type does not have Display defined
+     * See more details in https://forums.sui.io/t/nft-object-display-proposal/4872
+     */
+    display: superstruct_1.optional(superstruct_1.record(superstruct_1.string(), superstruct_1.string())),
+});
+/**
+ * Config for fetching object data
+ */
+exports.SuiObjectDataOptions = superstruct_1.object({
+    /* Whether to fetch the object type, default to be true */
+    showType: superstruct_1.optional(superstruct_1.boolean()),
+    /* Whether to fetch the object content, default to be false */
+    showContent: superstruct_1.optional(superstruct_1.boolean()),
+    /* Whether to fetch the object content in BCS bytes, default to be false */
+    showBcs: superstruct_1.optional(superstruct_1.boolean()),
+    /* Whether to fetch the object owner, default to be false */
+    showOwner: superstruct_1.optional(superstruct_1.boolean()),
+    /* Whether to fetch the previous transaction digest, default to be false */
+    showPreviousTransaction: superstruct_1.optional(superstruct_1.boolean()),
+    /* Whether to fetch the storage rebate, default to be false */
+    showStorageRebate: superstruct_1.optional(superstruct_1.boolean()),
+    /* Whether to fetch the display metadata, default to be false */
+    showDisplay: superstruct_1.optional(superstruct_1.boolean()),
+});
+exports.ObjectStatus = superstruct_1.union([superstruct_1.literal('Exists'), superstruct_1.literal('NotExists'), superstruct_1.literal('Deleted')]);
+exports.GetOwnedObjectsResponse = superstruct_1.array(exports.SuiObjectInfo);
+exports.SuiObjectResponseError = superstruct_1.object({
+    tag: superstruct_1.string(),
+    object_id: superstruct_1.optional(common_1.ObjectId),
+    version: superstruct_1.optional(common_1.SequenceNumber),
+    digest: superstruct_1.optional(exports.ObjectDigest),
+});
+exports.SuiObjectResponse = superstruct_1.object({
+    data: superstruct_1.optional(exports.SuiObjectData),
+    error: superstruct_1.optional(exports.SuiObjectResponseError),
+});
+/* -------------------------------------------------------------------------- */
+/*                              Helper functions                              */
+/* -------------------------------------------------------------------------- */
+/* -------------------------- SuiObjectResponse ------------------------- */
+function getSuiObjectData(resp) {
+    return resp.data;
+}
+exports.getSuiObjectData = getSuiObjectData;
+function getObjectDeletedResponse(resp) {
+    if (resp.error && 'object_id' in resp.error && 'version' in resp.error && 'digest' in resp.error) {
+        const error = resp.error;
+        return {
+            objectId: error.object_id,
+            version: error.version,
+            digest: error.digest,
+        };
+    }
+    return undefined;
+}
+exports.getObjectDeletedResponse = getObjectDeletedResponse;
+function getObjectNotExistsResponse(resp) {
+    if (resp.error && 'object_id' in resp.error && !('version' in resp.error) && !('digest' in resp.error)) {
+        return resp.error.object_id;
+    }
+    return undefined;
+}
+exports.getObjectNotExistsResponse = getObjectNotExistsResponse;
+function getObjectReference(resp) {
+    if ('reference' in resp) {
+        return resp.reference;
+    }
+    const exists = getSuiObjectData(resp);
+    if (exists) {
+        return {
+            objectId: exists.objectId,
+            version: exists.version,
+            digest: exists.digest,
+        };
+    }
+    return getObjectDeletedResponse(resp);
+}
+exports.getObjectReference = getObjectReference;
+/* ------------------------------ SuiObjectRef ------------------------------ */
+function getObjectId(data) {
+    var _a, _b;
+    if ('objectId' in data) {
+        return data.objectId;
+    }
+    return (_b = (_a = getObjectReference(data)) === null || _a === void 0 ? void 0 : _a.objectId) !== null && _b !== void 0 ? _b : getObjectNotExistsResponse(data);
+}
+exports.getObjectId = getObjectId;
+function getObjectVersion(data) {
+    var _a;
+    if ('version' in data) {
+        return data.version;
+    }
+    return (_a = getObjectReference(data)) === null || _a === void 0 ? void 0 : _a.version;
+}
+exports.getObjectVersion = getObjectVersion;
+/* -------------------------------- SuiObject ------------------------------- */
+function isSuiObjectResponse(resp) {
+    return resp.data !== undefined;
+}
+exports.isSuiObjectResponse = isSuiObjectResponse;
+/**
+ * Deriving the object type from the object response
+ * @returns 'package' if the object is a package, move object type(e.g., 0x2::coin::Coin<0x2::sui::SUI>)
+ * if the object is a move object
+ */
+function getObjectType(resp) {
+    var _a;
+    const data = isSuiObjectResponse(resp) ? resp.data : resp;
+    if (!(data === null || data === void 0 ? void 0 : data.type) && 'data' in resp) {
+        if (((_a = data === null || data === void 0 ? void 0 : data.content) === null || _a === void 0 ? void 0 : _a.dataType) === 'package') {
+            return 'package';
+        }
+        return getMoveObjectType(resp);
+    }
+    return data === null || data === void 0 ? void 0 : data.type;
+}
+exports.getObjectType = getObjectType;
+function getObjectPreviousTransactionDigest(resp) {
+    var _a;
+    return (_a = getSuiObjectData(resp)) === null || _a === void 0 ? void 0 : _a.previousTransaction;
+}
+exports.getObjectPreviousTransactionDigest = getObjectPreviousTransactionDigest;
+function getObjectOwner(resp) {
+    var _a;
+    if (superstruct_1.is(resp, common_1.ObjectOwner)) {
+        return resp;
+    }
+    return (_a = getSuiObjectData(resp)) === null || _a === void 0 ? void 0 : _a.owner;
+}
+exports.getObjectOwner = getObjectOwner;
+function getObjectDisplay(resp) {
+    var _a;
+    return (_a = getSuiObjectData(resp)) === null || _a === void 0 ? void 0 : _a.display;
+}
+exports.getObjectDisplay = getObjectDisplay;
+function getSharedObjectInitialVersion(resp) {
+    const owner = getObjectOwner(resp);
+    if (typeof owner === 'object' && 'Shared' in owner) {
+        return owner.Shared.initial_shared_version;
+    }
+    else {
+        return undefined;
+    }
+}
+exports.getSharedObjectInitialVersion = getSharedObjectInitialVersion;
+function isSharedObject(resp) {
+    const owner = getObjectOwner(resp);
+    return typeof owner === 'object' && 'Shared' in owner;
+}
+exports.isSharedObject = isSharedObject;
+function isImmutableObject(resp) {
+    const owner = getObjectOwner(resp);
+    return owner === 'Immutable';
+}
+exports.isImmutableObject = isImmutableObject;
+function getMoveObjectType(resp) {
+    var _a;
+    return (_a = getMoveObject(resp)) === null || _a === void 0 ? void 0 : _a.type;
+}
+exports.getMoveObjectType = getMoveObjectType;
+function getObjectFields(resp) {
+    var _a;
+    if ('fields' in resp) {
+        return resp.fields;
+    }
+    return (_a = getMoveObject(resp)) === null || _a === void 0 ? void 0 : _a.fields;
+}
+exports.getObjectFields = getObjectFields;
+function isSuiObjectDataWithContent(data) {
+    return data.content !== undefined;
+}
+function getMoveObject(data) {
+    const suiObject = 'data' in data ? getSuiObjectData(data) : data;
+    if (!suiObject || !isSuiObjectDataWithContent(suiObject) || suiObject.content.dataType !== 'moveObject') {
+        return undefined;
+    }
+    return suiObject.content;
+}
+exports.getMoveObject = getMoveObject;
+function hasPublicTransfer(data) {
+    var _a, _b;
+    return (_b = (_a = getMoveObject(data)) === null || _a === void 0 ? void 0 : _a.hasPublicTransfer) !== null && _b !== void 0 ? _b : false;
+}
+exports.hasPublicTransfer = hasPublicTransfer;
+function getMovePackageContent(data) {
+    var _a;
+    if ('disassembled' in data) {
+        return data.disassembled;
+    }
+    const suiObject = getSuiObjectData(data);
+    if (((_a = suiObject === null || suiObject === void 0 ? void 0 : suiObject.content) === null || _a === void 0 ? void 0 : _a.dataType) !== 'package') {
+        return undefined;
+    }
+    return suiObject.content.disassembled;
+}
+exports.getMovePackageContent = getMovePackageContent;
+exports.CheckpointedObjectId = superstruct_1.object({
+    objectId: common_1.ObjectId,
+    atCheckpoint: superstruct_1.optional(superstruct_1.number()),
+});
+exports.PaginatedObjectsResponse = superstruct_1.object({
+    data: superstruct_1.array(exports.SuiObjectResponse),
+    nextCursor: superstruct_1.optional(exports.CheckpointedObjectId),
+    hasNextPage: superstruct_1.boolean(),
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"objects.js","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/types/objects.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  any,\n  array,\n  assign,\n  boolean,\n  Infer,\n  literal,\n  number,\n  object,\n  optional,\n  record,\n  string,\n  union,\n  is,\n} from 'superstruct';\nimport { ObjectId, ObjectOwner, SequenceNumber, TransactionDigest } from './common';\nimport { OwnedObjectRef } from './transactions';\n\nexport const ObjectType = union([string(), literal('package')]);\nexport type ObjectType = Infer<typeof ObjectType>;\n\nexport const SuiObjectRef = object({\n  /** Base64 string representing the object digest */\n  digest: TransactionDigest,\n  /** Hex code as string representing the object id */\n  objectId: string(),\n  /** Object version */\n  version: union([number(), string()]),\n});\nexport type SuiObjectRef = Infer<typeof SuiObjectRef>;\n\nexport const SuiGasData = object({\n  payment: array(SuiObjectRef),\n  /** Gas Object's owner */\n  owner: string(),\n  price: number(),\n  budget: number(),\n});\nexport type SuiGasData = Infer<typeof SuiGasData>;\n\nexport const SuiObjectInfo = assign(\n  SuiObjectRef,\n  object({\n    type: string(),\n    owner: ObjectOwner,\n    previousTransaction: TransactionDigest,\n  })\n);\nexport type SuiObjectInfo = Infer<typeof SuiObjectInfo>;\n\nexport const ObjectContentFields = record(string(), any());\nexport type ObjectContentFields = Infer<typeof ObjectContentFields>;\n\nexport const MovePackageContent = record(string(), string());\nexport type MovePackageContent = Infer<typeof MovePackageContent>;\n\nexport const SuiMoveObject = object({\n  /** Move type (e.g., \"0x2::coin::Coin<0x2::sui::SUI>\") */\n  type: string(),\n  /** Fields and values stored inside the Move object */\n  fields: ObjectContentFields,\n  hasPublicTransfer: boolean(),\n});\nexport type SuiMoveObject = Infer<typeof SuiMoveObject>;\n\nexport const SuiMovePackage = object({\n  /** A mapping from module name to disassembled Move bytecode */\n  disassembled: MovePackageContent,\n});\nexport type SuiMovePackage = Infer<typeof SuiMovePackage>;\n\nexport const SuiParsedData = union([\n  assign(SuiMoveObject, object({ dataType: literal('moveObject') })),\n  assign(SuiMovePackage, object({ dataType: literal('package') })),\n]);\nexport type SuiParsedData = Infer<typeof SuiParsedData>;\n\nexport const SuiRawMoveObject = object({\n  /** Move type (e.g., \"0x2::coin::Coin<0x2::sui::SUI>\") */\n  type: string(),\n  hasPublicTransfer: boolean(),\n  version: SequenceNumber,\n  bcsBytes: array(number()),\n});\nexport type SuiRawMoveObject = Infer<typeof SuiRawMoveObject>;\n\nexport const SuiRawMovePackage = object({\n  id: ObjectId,\n  /** A mapping from module name to Move bytecode enocded in base64*/\n  moduleMap: record(string(), string()),\n});\nexport type SuiRawMovePackage = Infer<typeof SuiRawMovePackage>;\n\n// TODO(chris): consolidate SuiRawParsedData and SuiRawObject using generics\nexport const SuiRawData = union([\n  assign(SuiMoveObject, object({ dataType: literal('moveObject') })),\n  assign(SuiRawMovePackage, object({ dataType: literal('package') })),\n]);\nexport type SuiRawData = Infer<typeof SuiRawData>;\n\nexport const MIST_PER_SUI = BigInt(1000000000);\n\nexport const ObjectDigest = string();\nexport type ObjectDigest = Infer<typeof ObjectDigest>;\n\nexport const SuiObjectData = object({\n  objectId: ObjectId,\n  version: SequenceNumber,\n  digest: ObjectDigest,\n  /**\n   * Type of the object, default to be undefined unless SuiObjectDataOptions.showType is set to true\n   */\n  type: optional(string()),\n  /**\n   * Move object content or package content, default to be undefined unless SuiObjectDataOptions.showContent is set to true\n   */\n  content: optional(SuiParsedData),\n  /**\n   * Move object content or package content in BCS bytes, default to be undefined unless SuiObjectDataOptions.showBcs is set to true\n   */\n  bcs: optional(SuiRawData),\n  /**\n   * The owner of this object. Default to be undefined unless SuiObjectDataOptions.showOwner is set to true\n   */\n  owner: optional(ObjectOwner),\n  /**\n   * The digest of the transaction that created or last mutated this object.\n   * Default to be undefined unless SuiObjectDataOptions.showPreviousTransaction is set to true\n   */\n  previousTransaction: optional(TransactionDigest),\n  /**\n   * The amount of SUI we would rebate if this object gets deleted.\n   * This number is re-calculated each time the object is mutated based on\n   * the present storage gas price.\n   * Default to be undefined unless SuiObjectDataOptions.showStorageRebate is set to true\n   */\n  storageRebate: optional(number()),\n  /**\n   * Display metadata for this object, default to be undefined unless SuiObjectDataOptions.showDisplay is set to true\n   * This can also be None if the struct type does not have Display defined\n   * See more details in https://forums.sui.io/t/nft-object-display-proposal/4872\n   */\n  display: optional(record(string(), string())),\n});\nexport type SuiObjectData = Infer<typeof SuiObjectData>;\n\n/**\n * Config for fetching object data\n */\nexport const SuiObjectDataOptions = object({\n  /* Whether to fetch the object type, default to be true */\n  showType: optional(boolean()),\n  /* Whether to fetch the object content, default to be false */\n  showContent: optional(boolean()),\n  /* Whether to fetch the object content in BCS bytes, default to be false */\n  showBcs: optional(boolean()),\n  /* Whether to fetch the object owner, default to be false */\n  showOwner: optional(boolean()),\n  /* Whether to fetch the previous transaction digest, default to be false */\n  showPreviousTransaction: optional(boolean()),\n  /* Whether to fetch the storage rebate, default to be false */\n  showStorageRebate: optional(boolean()),\n  /* Whether to fetch the display metadata, default to be false */\n  showDisplay: optional(boolean()),\n});\nexport type SuiObjectDataOptions = Infer<typeof SuiObjectDataOptions>;\n\nexport const ObjectStatus = union([literal('Exists'), literal('NotExists'), literal('Deleted')]);\nexport type ObjectStatus = Infer<typeof ObjectStatus>;\n\nexport const GetOwnedObjectsResponse = array(SuiObjectInfo);\nexport type GetOwnedObjectsResponse = Infer<typeof GetOwnedObjectsResponse>;\n\nexport const SuiObjectResponseError = object({\n  tag: string(),\n  object_id: optional(ObjectId),\n  version: optional(SequenceNumber),\n  digest: optional(ObjectDigest),\n});\nexport type SuiObjectResponseError = Infer<typeof SuiObjectResponseError>;\n\nexport const SuiObjectResponse = object({\n  data: optional(SuiObjectData),\n  error: optional(SuiObjectResponseError),\n});\nexport type SuiObjectResponse = Infer<typeof SuiObjectResponse>;\n\nexport type Order = 'ascending' | 'descending';\n\n/* -------------------------------------------------------------------------- */\n/*                              Helper functions                              */\n/* -------------------------------------------------------------------------- */\n\n/* -------------------------- SuiObjectResponse ------------------------- */\n\nexport function getSuiObjectData(resp: SuiObjectResponse): SuiObjectData | undefined {\n  return resp.data;\n}\n\nexport function getObjectDeletedResponse(resp: SuiObjectResponse): SuiObjectRef | undefined {\n  if (resp.error && 'object_id' in resp.error && 'version' in resp.error && 'digest' in resp.error) {\n    const error = resp.error as SuiObjectResponseError;\n    return {\n      objectId: error.object_id,\n      version: error.version,\n      digest: error.digest,\n    } as SuiObjectRef;\n  }\n\n  return undefined;\n}\n\nexport function getObjectNotExistsResponse(resp: SuiObjectResponse): ObjectId | undefined {\n  if (resp.error && 'object_id' in resp.error && !('version' in resp.error) && !('digest' in resp.error)) {\n    return (resp.error as SuiObjectResponseError).object_id as ObjectId;\n  }\n\n  return undefined;\n}\n\nexport function getObjectReference(resp: SuiObjectResponse | OwnedObjectRef): SuiObjectRef | undefined {\n  if ('reference' in resp) {\n    return resp.reference;\n  }\n  const exists = getSuiObjectData(resp);\n  if (exists) {\n    return {\n      objectId: exists.objectId,\n      version: exists.version,\n      digest: exists.digest,\n    };\n  }\n  return getObjectDeletedResponse(resp);\n}\n\n/* ------------------------------ SuiObjectRef ------------------------------ */\n\nexport function getObjectId(data: SuiObjectResponse | SuiObjectRef | OwnedObjectRef): ObjectId {\n  if ('objectId' in data) {\n    return data.objectId;\n  }\n  return getObjectReference(data)?.objectId ?? getObjectNotExistsResponse(data as SuiObjectResponse)!;\n}\n\nexport function getObjectVersion(data: SuiObjectResponse | SuiObjectRef | SuiObjectData): string | number | undefined {\n  if ('version' in data) {\n    return data.version;\n  }\n  return getObjectReference(data)?.version;\n}\n\n/* -------------------------------- SuiObject ------------------------------- */\n\nexport function isSuiObjectResponse(resp: SuiObjectResponse | SuiObjectData): resp is SuiObjectResponse {\n  return (resp as SuiObjectResponse).data !== undefined;\n}\n\n/**\n * Deriving the object type from the object response\n * @returns 'package' if the object is a package, move object type(e.g., 0x2::coin::Coin<0x2::sui::SUI>)\n * if the object is a move object\n */\nexport function getObjectType(resp: SuiObjectResponse | SuiObjectData): ObjectType | undefined {\n  const data = isSuiObjectResponse(resp) ? resp.data : resp;\n\n  if (!data?.type && 'data' in resp) {\n    if (data?.content?.dataType === 'package') {\n      return 'package';\n    }\n    return getMoveObjectType(resp);\n  }\n  return data?.type;\n}\n\nexport function getObjectPreviousTransactionDigest(resp: SuiObjectResponse): TransactionDigest | undefined {\n  return getSuiObjectData(resp)?.previousTransaction;\n}\n\nexport function getObjectOwner(resp: SuiObjectResponse | ObjectOwner): ObjectOwner | undefined {\n  if (is(resp, ObjectOwner)) {\n    return resp;\n  }\n  return getSuiObjectData(resp)?.owner;\n}\n\nexport function getObjectDisplay(resp: SuiObjectResponse): Record<string, string> | undefined {\n  return getSuiObjectData(resp)?.display;\n}\n\nexport function getSharedObjectInitialVersion(resp: SuiObjectResponse | ObjectOwner): number | undefined {\n  const owner = getObjectOwner(resp);\n  if (typeof owner === 'object' && 'Shared' in owner) {\n    return owner.Shared.initial_shared_version;\n  } else {\n    return undefined;\n  }\n}\n\nexport function isSharedObject(resp: SuiObjectResponse | ObjectOwner): boolean {\n  const owner = getObjectOwner(resp);\n  return typeof owner === 'object' && 'Shared' in owner;\n}\n\nexport function isImmutableObject(resp: SuiObjectResponse | ObjectOwner): boolean {\n  const owner = getObjectOwner(resp);\n  return owner === 'Immutable';\n}\n\nexport function getMoveObjectType(resp: SuiObjectResponse): string | undefined {\n  return getMoveObject(resp)?.type;\n}\n\nexport function getObjectFields(\n  resp: SuiObjectResponse | SuiMoveObject | SuiObjectData\n): ObjectContentFields | undefined {\n  if ('fields' in resp) {\n    return resp.fields;\n  }\n  return getMoveObject(resp)?.fields;\n}\n\nexport interface SuiObjectDataWithContent extends SuiObjectData {\n  content: SuiParsedData;\n}\n\nfunction isSuiObjectDataWithContent(data: SuiObjectData): data is SuiObjectDataWithContent {\n  return data.content !== undefined;\n}\n\nexport function getMoveObject(data: SuiObjectResponse | SuiObjectData): SuiMoveObject | undefined {\n  const suiObject = 'data' in data ? getSuiObjectData(data) : (data as SuiObjectData);\n\n  if (!suiObject || !isSuiObjectDataWithContent(suiObject) || suiObject.content.dataType !== 'moveObject') {\n    return undefined;\n  }\n\n  return suiObject.content as SuiMoveObject;\n}\n\nexport function hasPublicTransfer(data: SuiObjectResponse | SuiObjectData): boolean {\n  return getMoveObject(data)?.hasPublicTransfer ?? false;\n}\n\nexport function getMovePackageContent(data: SuiObjectResponse | SuiMovePackage): MovePackageContent | undefined {\n  if ('disassembled' in data) {\n    return data.disassembled;\n  }\n  const suiObject = getSuiObjectData(data);\n  if (suiObject?.content?.dataType !== 'package') {\n    return undefined;\n  }\n  return (suiObject.content as SuiMovePackage).disassembled;\n}\n\nexport const CheckpointedObjectId = object({\n  objectId: ObjectId,\n  atCheckpoint: optional(number()),\n});\nexport type CheckpointedObjectId = Infer<typeof CheckpointedObjectId>;\n\nexport const PaginatedObjectsResponse = object({\n  data: array(SuiObjectResponse),\n  nextCursor: optional(CheckpointedObjectId),\n  hasNextPage: boolean(),\n});\nexport type PaginatedObjectsResponse = Infer<typeof PaginatedObjectsResponse>;\n\n// mirrors sui_json_rpc_types:: SuiObjectDataFilter\nexport type SuiObjectDataFilter =\n  | { Package: ObjectId }\n  | { MoveModule: { package: ObjectId; module: string } }\n  | { StructType: string };\n\nexport type SuiObjectResponseQuery = {\n  filter?: SuiObjectDataFilter;\n  options?: SuiObjectDataOptions;\n};\n"]}

package/dist/src/lib/mystenlab/types/option.d.ts

@@ -0,0 +1,8 @@
+export declare type Option<T> = T | {
+    fields: {
+        vec: '';
+    };
+    type: string;
+};
+export declare function getOption<T>(option: Option<T>): T | undefined;
+//# sourceMappingURL=option.d.ts.map

package/dist/src/lib/mystenlab/types/option.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"option.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/types/option.ts"],"names":[],"mappings":"AAAA,oBAAY,MAAM,CAAC,CAAC,IAChB,CAAC,GACD;IACE,MAAM,EAAE;QACN,GAAG,EAAE,EAAE,CAAC;KACT,CAAC;IACF,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEN,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAU7D"}

package/dist/src/lib/mystenlab/types/option.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOption = void 0;
+function getOption(option) {
+    if (typeof option === 'object' &&
+        option !== null &&
+        'type' in option &&
+        option.type.startsWith('0x1::option::Option<')) {
+        return undefined;
+    }
+    return option;
+}
+exports.getOption = getOption;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9teXN0ZW5sYWIvdHlwZXMvb3B0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVNBLFNBQWdCLFNBQVMsQ0FBSSxNQUFpQjtJQUM1QyxJQUNFLE9BQU8sTUFBTSxLQUFLLFFBQVE7UUFDMUIsTUFBTSxLQUFLLElBQUk7UUFDZixNQUFNLElBQUksTUFBTTtRQUNoQixNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxzQkFBc0IsQ0FBQyxFQUM5QztRQUNBLE9BQU8sU0FBUyxDQUFDO0tBQ2xCO0lBQ0QsT0FBTyxNQUFXLENBQUM7QUFDckIsQ0FBQztBQVZELDhCQVVDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgT3B0aW9uPFQ+ID1cbiAgfCBUXG4gIHwge1xuICAgICAgZmllbGRzOiB7XG4gICAgICAgIHZlYzogJyc7XG4gICAgICB9O1xuICAgICAgdHlwZTogc3RyaW5nO1xuICAgIH07XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRPcHRpb248VD4ob3B0aW9uOiBPcHRpb248VD4pOiBUIHwgdW5kZWZpbmVkIHtcbiAgaWYgKFxuICAgIHR5cGVvZiBvcHRpb24gPT09ICdvYmplY3QnICYmXG4gICAgb3B0aW9uICE9PSBudWxsICYmXG4gICAgJ3R5cGUnIGluIG9wdGlvbiAmJlxuICAgIG9wdGlvbi50eXBlLnN0YXJ0c1dpdGgoJzB4MTo6b3B0aW9uOjpPcHRpb248JylcbiAgKSB7XG4gICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgfVxuICByZXR1cm4gb3B0aW9uIGFzIFQ7XG59XG4iXX0=

package/dist/src/lib/mystenlab/types/sui-bcs.d.ts

@@ -0,0 +1,111 @@
+import { BCS } from '@mysten/bcs';
+import { SuiObjectRef } from './objects';
+/**
+ * A reference to a shared object.
+ */
+export declare type SharedObjectRef = {
+    /** Hex code as string representing the object id */
+    objectId: string;
+    /** The version the object was shared at */
+    initialSharedVersion: number | string;
+    /** Whether reference is mutable */
+    mutable: boolean;
+};
+/**
+ * An object argument.
+ */
+export declare type ObjectArg = {
+    ImmOrOwned: SuiObjectRef;
+} | {
+    Shared: SharedObjectRef;
+};
+/**
+ * A pure argument.
+ */
+export declare type PureArg = {
+    Pure: ArrayLike<number>;
+};
+export declare function isPureArg(arg: any): arg is PureArg;
+/**
+ * An argument for the transaction. It is a 'meant' enum which expects to have
+ * one of the optional properties. If not, the BCS error will be thrown while
+ * attempting to form a transaction.
+ *
+ * Example:
+ * ```js
+ * let arg1: CallArg = { Object: { Shared: {
+ *   objectId: '5460cf92b5e3e7067aaace60d88324095fd22944',
+ *   initialSharedVersion: 1,
+ *   mutable: true,
+ * } } };
+ * let arg2: CallArg = { Pure: bcs.ser(BCS.STRING, 100000).toBytes() };
+ * let arg3: CallArg = { Object: { ImmOrOwned: {
+ *   objectId: '4047d2e25211d87922b6650233bd0503a6734279',
+ *   version: 1,
+ *   digest: 'bCiANCht4O9MEUhuYjdRCqRPZjr2rJ8MfqNiwyhmRgA='
+ * } } };
+ * ```
+ *
+ * For `Pure` arguments BCS is required. You must encode the values with BCS according
+ * to the type required by the called function. Pure accepts only serialized values
+ */
+export declare type CallArg = PureArg | {
+    Object: ObjectArg;
+};
+/**
+ * Kind of a TypeTag which is represented by a Move type identifier.
+ */
+export declare type StructTag = {
+    address: string;
+    module: string;
+    name: string;
+    typeParams: TypeTag[];
+};
+/**
+ * Sui TypeTag object. A decoupled `0x...::module::Type<???>` parameter.
+ */
+export declare type TypeTag = {
+    bool: null;
+} | {
+    u8: null;
+} | {
+    u64: null;
+} | {
+    u128: null;
+} | {
+    address: null;
+} | {
+    signer: null;
+} | {
+    vector: TypeTag;
+} | {
+    struct: StructTag;
+} | {
+    u16: null;
+} | {
+    u32: null;
+} | {
+    u256: null;
+};
+/**
+ * The GasData to be used in the transaction.
+ */
+export declare type GasData = {
+    payment: SuiObjectRef[];
+    owner: string;
+    price: number;
+    budget: number;
+};
+/**
+ * TransactionExpiration
+ *
+ * Indications the expiration time for a transaction.
+ */
+export declare type TransactionExpiration = {
+    None: null;
+} | {
+    Epoch: number;
+};
+declare const bcs: BCS;
+export { bcs };
+//# sourceMappingURL=sui-bcs.d.ts.map

package/dist/src/lib/mystenlab/types/sui-bcs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sui-bcs.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/types/sui-bcs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAA8D,MAAM,aAAa,CAAC;AAC9F,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAiBzC;;GAEG;AACH,oBAAY,eAAe,GAAG;IAC5B,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAC;IAEjB,2CAA2C;IAC3C,oBAAoB,EAAE,MAAM,GAAG,MAAM,CAAC;IAEtC,mCAAmC;IACnC,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,oBAAY,SAAS,GAAG;IAAE,UAAU,EAAE,YAAY,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,eAAe,CAAA;CAAE,CAAC;AAEnF;;GAEG;AACH,oBAAY,OAAO,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAElD,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,OAAO,CAElD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,oBAAY,OAAO,GAAG,OAAO,GAAG;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAC;AAEtD;;GAEG;AACH,oBAAY,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,oBAAY,OAAO,GACf;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GACd;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GACZ;IAAE,GAAG,EAAE,IAAI,CAAA;CAAE,GACb;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GACd;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,GACjB;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,GAChB;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GACnB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,GAAG,EAAE,IAAI,CAAA;CAAE,GACb;IAAE,GAAG,EAAE,IAAI,CAAA;CAAE,GACb;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC;AAInB;;GAEG;AACH,oBAAY,OAAO,GAAG;IACpB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AACH,oBAAY,qBAAqB,GAAG;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAkGvE,QAAA,MAAM,GAAG,KAAsD,CAAC;AAGhE,OAAO,EAAE,GAAG,EAAE,CAAC"}

package/dist/src/lib/mystenlab/types/sui-bcs.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bcs = exports.isPureArg = void 0;
+const bcs_1 = require("@mysten/bcs");
+function registerUTF8String(bcs) {
+    bcs.registerType('utf8string', (writer, str) => {
+        const bytes = Array.from(new TextEncoder().encode(str));
+        return writer.writeVec(bytes, (writer, el) => writer.write8(el));
+    }, (reader) => {
+        let bytes = reader.readVec((reader) => reader.read8());
+        return new TextDecoder().decode(new Uint8Array(bytes));
+    });
+}
+function isPureArg(arg) {
+    return arg.Pure !== undefined;
+}
+exports.isPureArg = isPureArg;
+// Move name of the Vector type.
+const VECTOR = 'vector';
+const TransactionDataV1 = {
+    kind: 'TransactionKind',
+    sender: bcs_1.BCS.ADDRESS,
+    gasData: 'GasData',
+    expiration: 'TransactionExpiration',
+};
+const BCS_SPEC = {
+    enums: {
+        'Option<T>': {
+            None: null,
+            Some: 'T',
+        },
+        ObjectArg: {
+            ImmOrOwned: 'SuiObjectRef',
+            Shared: 'SharedObjectRef',
+        },
+        CallArg: {
+            Pure: [VECTOR, bcs_1.BCS.U8],
+            Object: 'ObjectArg',
+            ObjVec: [VECTOR, 'ObjectArg'],
+        },
+        TypeTag: {
+            bool: null,
+            u8: null,
+            u64: null,
+            u128: null,
+            address: null,
+            signer: null,
+            vector: 'TypeTag',
+            struct: 'StructTag',
+            u16: null,
+            u32: null,
+            u256: null,
+        },
+        TransactionKind: {
+            // can not be called from sui.js; dummy placement
+            // to set the enum counter right for ProgrammableTransact
+            ProgrammableTransaction: 'ProgrammableTransaction',
+            ChangeEpoch: null,
+            Genesis: null,
+            ConsensusCommitPrologue: null,
+        },
+        TransactionExpiration: {
+            None: null,
+            Epoch: bcs_1.BCS.U64,
+        },
+        TransactionData: {
+            V1: 'TransactionDataV1',
+        },
+    },
+    structs: {
+        SuiObjectRef: {
+            objectId: bcs_1.BCS.ADDRESS,
+            version: bcs_1.BCS.U64,
+            digest: 'ObjectDigest',
+        },
+        SharedObjectRef: {
+            objectId: bcs_1.BCS.ADDRESS,
+            initialSharedVersion: bcs_1.BCS.U64,
+            mutable: bcs_1.BCS.BOOL,
+        },
+        StructTag: {
+            address: bcs_1.BCS.ADDRESS,
+            module: bcs_1.BCS.STRING,
+            name: bcs_1.BCS.STRING,
+            typeParams: [VECTOR, 'TypeTag'],
+        },
+        GasData: {
+            payment: [VECTOR, 'SuiObjectRef'],
+            owner: bcs_1.BCS.ADDRESS,
+            price: bcs_1.BCS.U64,
+            budget: bcs_1.BCS.U64,
+        },
+        // Signed transaction data needed to generate transaction digest.
+        SenderSignedData: {
+            data: 'TransactionData',
+            txSignatures: [VECTOR, [VECTOR, bcs_1.BCS.U8]],
+        },
+        TransactionDataV1,
+    },
+    aliases: {
+        ObjectDigest: bcs_1.BCS.BASE58,
+    },
+};
+const bcs = new bcs_1.BCS({ ...bcs_1.getSuiMoveConfig(), types: BCS_SPEC });
+exports.bcs = bcs;
+registerUTF8String(bcs);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sui-bcs.js","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/types/sui-bcs.ts"],"names":[],"mappings":"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","sourcesContent":["import { BCS, EnumTypeDefinition, getSuiMoveConfig, StructTypeDefinition } from '@mysten/bcs';\nimport { SuiObjectRef } from './objects';\nimport { PureCallArg } from '../builder';\n\nfunction registerUTF8String(bcs: BCS) {\n  bcs.registerType(\n    'utf8string',\n    (writer, str) => {\n      const bytes = Array.from(new TextEncoder().encode(str));\n      return writer.writeVec(bytes, (writer, el) => writer.write8(el));\n    },\n    (reader) => {\n      let bytes = reader.readVec((reader) => reader.read8());\n      return new TextDecoder().decode(new Uint8Array(bytes));\n    }\n  );\n}\n\n/**\n * A reference to a shared object.\n */\nexport type SharedObjectRef = {\n  /** Hex code as string representing the object id */\n  objectId: string;\n\n  /** The version the object was shared at */\n  initialSharedVersion: number | string;\n\n  /** Whether reference is mutable */\n  mutable: boolean;\n};\n\n/**\n * An object argument.\n */\nexport type ObjectArg = { ImmOrOwned: SuiObjectRef } | { Shared: SharedObjectRef };\n\n/**\n * A pure argument.\n */\nexport type PureArg = { Pure: ArrayLike<number> };\n\nexport function isPureArg(arg: any): arg is PureArg {\n  return (arg as PureArg).Pure !== undefined;\n}\n\n/**\n * An argument for the transaction. It is a 'meant' enum which expects to have\n * one of the optional properties. If not, the BCS error will be thrown while\n * attempting to form a transaction.\n *\n * Example:\n * ```js\n * let arg1: CallArg = { Object: { Shared: {\n *   objectId: '5460cf92b5e3e7067aaace60d88324095fd22944',\n *   initialSharedVersion: 1,\n *   mutable: true,\n * } } };\n * let arg2: CallArg = { Pure: bcs.ser(BCS.STRING, 100000).toBytes() };\n * let arg3: CallArg = { Object: { ImmOrOwned: {\n *   objectId: '4047d2e25211d87922b6650233bd0503a6734279',\n *   version: 1,\n *   digest: 'bCiANCht4O9MEUhuYjdRCqRPZjr2rJ8MfqNiwyhmRgA='\n * } } };\n * ```\n *\n * For `Pure` arguments BCS is required. You must encode the values with BCS according\n * to the type required by the called function. Pure accepts only serialized values\n */\nexport type CallArg = PureArg | { Object: ObjectArg };\n\n/**\n * Kind of a TypeTag which is represented by a Move type identifier.\n */\nexport type StructTag = {\n  address: string;\n  module: string;\n  name: string;\n  typeParams: TypeTag[];\n};\n\n/**\n * Sui TypeTag object. A decoupled `0x...::module::Type<???>` parameter.\n */\nexport type TypeTag =\n  | { bool: null }\n  | { u8: null }\n  | { u64: null }\n  | { u128: null }\n  | { address: null }\n  | { signer: null }\n  | { vector: TypeTag }\n  | { struct: StructTag }\n  | { u16: null }\n  | { u32: null }\n  | { u256: null };\n\n// ========== TransactionData ===========\n\n/**\n * The GasData to be used in the transaction.\n */\nexport type GasData = {\n  payment: SuiObjectRef[];\n  owner: string; // Gas Object's owner\n  price: number;\n  budget: number;\n};\n\n/**\n * TransactionExpiration\n *\n * Indications the expiration time for a transaction.\n */\nexport type TransactionExpiration = { None: null } | { Epoch: number };\n\n// Move name of the Vector type.\nconst VECTOR = 'vector';\n\n// Imported to explicitly tell typescript that types match\ntype TypeSchema = {\n  structs?: { [key: string]: StructTypeDefinition };\n  enums?: { [key: string]: EnumTypeDefinition };\n  aliases?: { [key: string]: string };\n};\n\nconst TransactionDataV1 = {\n  kind: 'TransactionKind',\n  sender: BCS.ADDRESS,\n  gasData: 'GasData',\n  expiration: 'TransactionExpiration',\n};\n\nconst BCS_SPEC: TypeSchema = {\n  enums: {\n    'Option<T>': {\n      None: null,\n      Some: 'T',\n    },\n    ObjectArg: {\n      ImmOrOwned: 'SuiObjectRef',\n      Shared: 'SharedObjectRef',\n    },\n    CallArg: {\n      Pure: [VECTOR, BCS.U8],\n      Object: 'ObjectArg',\n      ObjVec: [VECTOR, 'ObjectArg'],\n    },\n    TypeTag: {\n      bool: null,\n      u8: null,\n      u64: null,\n      u128: null,\n      address: null,\n      signer: null,\n      vector: 'TypeTag',\n      struct: 'StructTag',\n      u16: null,\n      u32: null,\n      u256: null,\n    },\n    TransactionKind: {\n      // can not be called from sui.js; dummy placement\n      // to set the enum counter right for ProgrammableTransact\n      ProgrammableTransaction: 'ProgrammableTransaction',\n      ChangeEpoch: null,\n      Genesis: null,\n      ConsensusCommitPrologue: null,\n    },\n    TransactionExpiration: {\n      None: null,\n      Epoch: BCS.U64,\n    },\n    TransactionData: {\n      V1: 'TransactionDataV1',\n    },\n  },\n  structs: {\n    SuiObjectRef: {\n      objectId: BCS.ADDRESS,\n      version: BCS.U64,\n      digest: 'ObjectDigest',\n    },\n    SharedObjectRef: {\n      objectId: BCS.ADDRESS,\n      initialSharedVersion: BCS.U64,\n      mutable: BCS.BOOL,\n    },\n    StructTag: {\n      address: BCS.ADDRESS,\n      module: BCS.STRING,\n      name: BCS.STRING,\n      typeParams: [VECTOR, 'TypeTag'],\n    },\n    GasData: {\n      payment: [VECTOR, 'SuiObjectRef'],\n      owner: BCS.ADDRESS,\n      price: BCS.U64,\n      budget: BCS.U64,\n    },\n    // Signed transaction data needed to generate transaction digest.\n    SenderSignedData: {\n      data: 'TransactionData',\n      txSignatures: [VECTOR, [VECTOR, BCS.U8]],\n    },\n    TransactionDataV1,\n  },\n  aliases: {\n    ObjectDigest: BCS.BASE58,\n  },\n};\n\nconst bcs = new BCS({ ...getSuiMoveConfig(), types: BCS_SPEC });\nregisterUTF8String(bcs);\n\nexport { bcs };\n"]}