@bitgo/sdk-coin-sui 2.0.1 → 3.0.0

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

@@ -0,0 +1,254 @@
+import { Infer } from 'superstruct';
+export declare type SuiMoveFunctionArgTypesResponse = Infer<typeof SuiMoveFunctionArgType>[];
+export declare const SuiMoveFunctionArgType: import("superstruct").Struct<string | {
+    Object: string;
+}, null>;
+export declare const SuiMoveFunctionArgTypes: import("superstruct").Struct<(string | {
+    Object: string;
+})[], import("superstruct").Struct<string | {
+    Object: string;
+}, null>>;
+export declare type SuiMoveFunctionArgTypes = Infer<typeof SuiMoveFunctionArgTypes>;
+export declare const SuiMoveModuleId: import("superstruct").Struct<{
+    address: string;
+    name: string;
+}, {
+    address: import("superstruct").Struct<string, null>;
+    name: import("superstruct").Struct<string, null>;
+}>;
+export declare type SuiMoveModuleId = Infer<typeof SuiMoveModuleId>;
+export declare const SuiMoveVisibility: import("superstruct").Struct<"Private" | "Public" | "Friend", null>;
+export declare type SuiMoveVisibility = Infer<typeof SuiMoveVisibility>;
+export declare const SuiMoveAbilitySet: import("superstruct").Struct<{
+    abilities: string[];
+}, {
+    abilities: import("superstruct").Struct<string[], import("superstruct").Struct<string, null>>;
+}>;
+export declare type SuiMoveAbilitySet = Infer<typeof SuiMoveAbilitySet>;
+export declare const SuiMoveStructTypeParameter: import("superstruct").Struct<{
+    constraints: {
+        abilities: string[];
+    };
+    isPhantom: boolean;
+}, {
+    constraints: import("superstruct").Struct<{
+        abilities: string[];
+    }, {
+        abilities: import("superstruct").Struct<string[], import("superstruct").Struct<string, null>>;
+    }>;
+    isPhantom: import("superstruct").Struct<boolean, null>;
+}>;
+export declare type SuiMoveStructTypeParameter = Infer<typeof SuiMoveStructTypeParameter>;
+export declare const SuiMoveNormalizedTypeParameterType: import("superstruct").Struct<{
+    TypeParameter: number;
+}, {
+    TypeParameter: import("superstruct").Struct<number, null>;
+}>;
+export declare type SuiMoveNormalizedTypeParameterType = Infer<typeof SuiMoveNormalizedTypeParameterType>;
+export declare type SuiMoveNormalizedType = string | SuiMoveNormalizedTypeParameterType | {
+    Reference: SuiMoveNormalizedType;
+} | {
+    MutableReference: SuiMoveNormalizedType;
+} | {
+    Vector: SuiMoveNormalizedType;
+} | SuiMoveNormalizedStructType;
+export declare const SuiMoveNormalizedType: import("superstruct").Struct<SuiMoveNormalizedType, null>;
+export declare type SuiMoveNormalizedStructType = {
+    Struct: {
+        address: string;
+        module: string;
+        name: string;
+        typeArguments: SuiMoveNormalizedType[];
+    };
+};
+export declare const SuiMoveNormalizedStructType: import("superstruct").Struct<SuiMoveNormalizedStructType, null>;
+export declare const SuiMoveNormalizedFunction: import("superstruct").Struct<{
+    visibility: "Private" | "Public" | "Friend";
+    isEntry: boolean;
+    typeParameters: {
+        abilities: string[];
+    }[];
+    parameters: SuiMoveNormalizedType[];
+    return: SuiMoveNormalizedType[];
+}, {
+    visibility: import("superstruct").Struct<"Private" | "Public" | "Friend", null>;
+    isEntry: import("superstruct").Struct<boolean, null>;
+    typeParameters: import("superstruct").Struct<{
+        abilities: string[];
+    }[], import("superstruct").Struct<{
+        abilities: string[];
+    }, {
+        abilities: import("superstruct").Struct<string[], import("superstruct").Struct<string, null>>;
+    }>>;
+    parameters: import("superstruct").Struct<SuiMoveNormalizedType[], import("superstruct").Struct<SuiMoveNormalizedType, null>>;
+    return: import("superstruct").Struct<SuiMoveNormalizedType[], import("superstruct").Struct<SuiMoveNormalizedType, null>>;
+}>;
+export declare type SuiMoveNormalizedFunction = Infer<typeof SuiMoveNormalizedFunction>;
+export declare const SuiMoveNormalizedField: import("superstruct").Struct<{
+    type: SuiMoveNormalizedType;
+    name: string;
+}, {
+    name: import("superstruct").Struct<string, null>;
+    type: import("superstruct").Struct<SuiMoveNormalizedType, null>;
+}>;
+export declare type SuiMoveNormalizedField = Infer<typeof SuiMoveNormalizedField>;
+export declare const SuiMoveNormalizedStruct: import("superstruct").Struct<{
+    fields: {
+        type: SuiMoveNormalizedType;
+        name: string;
+    }[];
+    abilities: {
+        abilities: string[];
+    };
+    typeParameters: {
+        constraints: {
+            abilities: string[];
+        };
+        isPhantom: boolean;
+    }[];
+}, {
+    abilities: import("superstruct").Struct<{
+        abilities: string[];
+    }, {
+        abilities: import("superstruct").Struct<string[], import("superstruct").Struct<string, null>>;
+    }>;
+    typeParameters: import("superstruct").Struct<{
+        constraints: {
+            abilities: string[];
+        };
+        isPhantom: boolean;
+    }[], import("superstruct").Struct<{
+        constraints: {
+            abilities: string[];
+        };
+        isPhantom: boolean;
+    }, {
+        constraints: import("superstruct").Struct<{
+            abilities: string[];
+        }, {
+            abilities: import("superstruct").Struct<string[], import("superstruct").Struct<string, null>>;
+        }>;
+        isPhantom: import("superstruct").Struct<boolean, null>;
+    }>>;
+    fields: import("superstruct").Struct<{
+        type: SuiMoveNormalizedType;
+        name: string;
+    }[], import("superstruct").Struct<{
+        type: SuiMoveNormalizedType;
+        name: string;
+    }, {
+        name: import("superstruct").Struct<string, null>;
+        type: import("superstruct").Struct<SuiMoveNormalizedType, null>;
+    }>>;
+}>;
+export declare type SuiMoveNormalizedStruct = Infer<typeof SuiMoveNormalizedStruct>;
+export declare const SuiMoveNormalizedModule: import("superstruct").Struct<{
+    address: string;
+    name: string;
+    fileFormatVersion: number;
+    friends: {
+        address: string;
+        name: string;
+    }[];
+    structs: Record<string, {
+        fields: {
+            type: SuiMoveNormalizedType;
+            name: string;
+        }[];
+        abilities: {
+            abilities: string[];
+        };
+        typeParameters: {
+            constraints: {
+                abilities: string[];
+            };
+            isPhantom: boolean;
+        }[];
+    }>;
+    exposedFunctions: Record<string, {
+        visibility: "Private" | "Public" | "Friend";
+        isEntry: boolean;
+        typeParameters: {
+            abilities: string[];
+        }[];
+        parameters: SuiMoveNormalizedType[];
+        return: SuiMoveNormalizedType[];
+    }>;
+}, {
+    fileFormatVersion: import("superstruct").Struct<number, null>;
+    address: import("superstruct").Struct<string, null>;
+    name: import("superstruct").Struct<string, null>;
+    friends: import("superstruct").Struct<{
+        address: string;
+        name: string;
+    }[], import("superstruct").Struct<{
+        address: string;
+        name: string;
+    }, {
+        address: import("superstruct").Struct<string, null>;
+        name: import("superstruct").Struct<string, null>;
+    }>>;
+    structs: import("superstruct").Struct<Record<string, {
+        fields: {
+            type: SuiMoveNormalizedType;
+            name: string;
+        }[];
+        abilities: {
+            abilities: string[];
+        };
+        typeParameters: {
+            constraints: {
+                abilities: string[];
+            };
+            isPhantom: boolean;
+        }[];
+    }>, null>;
+    exposedFunctions: import("superstruct").Struct<Record<string, {
+        visibility: "Private" | "Public" | "Friend";
+        isEntry: boolean;
+        typeParameters: {
+            abilities: string[];
+        }[];
+        parameters: SuiMoveNormalizedType[];
+        return: SuiMoveNormalizedType[];
+    }>, null>;
+}>;
+export declare type SuiMoveNormalizedModule = Infer<typeof SuiMoveNormalizedModule>;
+export declare const SuiMoveNormalizedModules: import("superstruct").Struct<Record<string, {
+    address: string;
+    name: string;
+    fileFormatVersion: number;
+    friends: {
+        address: string;
+        name: string;
+    }[];
+    structs: Record<string, {
+        fields: {
+            type: SuiMoveNormalizedType;
+            name: string;
+        }[];
+        abilities: {
+            abilities: string[];
+        };
+        typeParameters: {
+            constraints: {
+                abilities: string[];
+            };
+            isPhantom: boolean;
+        }[];
+    }>;
+    exposedFunctions: Record<string, {
+        visibility: "Private" | "Public" | "Friend";
+        isEntry: boolean;
+        typeParameters: {
+            abilities: string[];
+        }[];
+        parameters: SuiMoveNormalizedType[];
+        return: SuiMoveNormalizedType[];
+    }>;
+}>, null>;
+export declare type SuiMoveNormalizedModules = Infer<typeof SuiMoveNormalizedModules>;
+export declare function extractMutableReference(normalizedType: SuiMoveNormalizedType): SuiMoveNormalizedType | undefined;
+export declare function extractReference(normalizedType: SuiMoveNormalizedType): SuiMoveNormalizedType | undefined;
+export declare function extractStructTag(normalizedType: SuiMoveNormalizedType): SuiMoveNormalizedStructType | undefined;
+//# sourceMappingURL=normalized.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalized.d.ts","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/types/normalized.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAuE,MAAM,aAAa,CAAC;AAEhH,oBAAY,+BAA+B,GAAG,KAAK,CAAC,OAAO,sBAAsB,CAAC,EAAE,CAAC;AAErF,eAAO,MAAM,sBAAsB;;QAAkD,CAAC;AAEtF,eAAO,MAAM,uBAAuB;;;;SAAgC,CAAC;AACrE,oBAAY,uBAAuB,GAAG,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE5E,eAAO,MAAM,eAAe;;;;;;EAG1B,CAAC;AACH,oBAAY,eAAe,GAAG,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE5D,eAAO,MAAM,iBAAiB,qEAAoE,CAAC;AACnG,oBAAY,iBAAiB,GAAG,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEhE,eAAO,MAAM,iBAAiB;;;;EAE5B,CAAC;AACH,oBAAY,iBAAiB,GAAG,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEhE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EAGrC,CAAC;AACH,oBAAY,0BAA0B,GAAG,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAElF,eAAO,MAAM,kCAAkC;;;;EAE7C,CAAC;AACH,oBAAY,kCAAkC,GAAG,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAElG,oBAAY,qBAAqB,GAC7B,MAAM,GACN,kCAAkC,GAClC;IAAE,SAAS,EAAE,qBAAqB,CAAA;CAAE,GACpC;IAAE,gBAAgB,EAAE,qBAAqB,CAAA;CAAE,GAC3C;IAAE,MAAM,EAAE,qBAAqB,CAAA;CAAE,GACjC,2BAA2B,CAAC;AAgBhC,eAAO,MAAM,qBAAqB,2DAAkF,CAAC;AAErH,oBAAY,2BAA2B,GAAG;IACxC,MAAM,EAAE;QACN,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,aAAa,EAAE,qBAAqB,EAAE,CAAC;KACxC,CAAC;CACH,CAAC;AAuBF,eAAO,MAAM,2BAA2B,iEAGvC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;EAMpC,CAAC;AACH,oBAAY,yBAAyB,GAAG,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAEhF,eAAO,MAAM,sBAAsB;;;;;;EAGjC,CAAC;AACH,oBAAY,sBAAsB,GAAG,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE1E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIlC,CAAC;AACH,oBAAY,uBAAuB,GAAG,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE5E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlC,CAAC;AACH,oBAAY,uBAAuB,GAAG,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE5E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA4C,CAAC;AAClF,oBAAY,wBAAwB,GAAG,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE9E,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,qBAAqB,GAAG,qBAAqB,GAAG,SAAS,CAIhH;AAED,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,qBAAqB,GAAG,qBAAqB,GAAG,SAAS,CAEzG;AAED,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,qBAAqB,GAAG,2BAA2B,GAAG,SAAS,CAgB/G"}

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractStructTag = exports.extractReference = exports.extractMutableReference = exports.SuiMoveNormalizedModules = exports.SuiMoveNormalizedModule = exports.SuiMoveNormalizedStruct = exports.SuiMoveNormalizedField = exports.SuiMoveNormalizedFunction = exports.SuiMoveNormalizedStructType = exports.SuiMoveNormalizedType = exports.SuiMoveNormalizedTypeParameterType = exports.SuiMoveStructTypeParameter = exports.SuiMoveAbilitySet = exports.SuiMoveVisibility = exports.SuiMoveModuleId = exports.SuiMoveFunctionArgTypes = exports.SuiMoveFunctionArgType = void 0;
+const superstruct_1 = require("superstruct");
+exports.SuiMoveFunctionArgType = superstruct_1.union([superstruct_1.string(), superstruct_1.object({ Object: superstruct_1.string() })]);
+exports.SuiMoveFunctionArgTypes = superstruct_1.array(exports.SuiMoveFunctionArgType);
+exports.SuiMoveModuleId = superstruct_1.object({
+    address: superstruct_1.string(),
+    name: superstruct_1.string(),
+});
+exports.SuiMoveVisibility = superstruct_1.union([superstruct_1.literal('Private'), superstruct_1.literal('Public'), superstruct_1.literal('Friend')]);
+exports.SuiMoveAbilitySet = superstruct_1.object({
+    abilities: superstruct_1.array(superstruct_1.string()),
+});
+exports.SuiMoveStructTypeParameter = superstruct_1.object({
+    constraints: exports.SuiMoveAbilitySet,
+    isPhantom: superstruct_1.boolean(),
+});
+exports.SuiMoveNormalizedTypeParameterType = superstruct_1.object({
+    TypeParameter: superstruct_1.number(),
+});
+function isSuiMoveNormalizedType(value) {
+    if (!value)
+        return false;
+    if (typeof value === 'string')
+        return true;
+    if (superstruct_1.is(value, exports.SuiMoveNormalizedTypeParameterType))
+        return true;
+    if (isSuiMoveNormalizedStructType(value))
+        return true;
+    if (typeof value !== 'object')
+        return false;
+    const valueProperties = value;
+    if (superstruct_1.is(valueProperties.Reference, exports.SuiMoveNormalizedType))
+        return true;
+    if (superstruct_1.is(valueProperties.MutableReference, exports.SuiMoveNormalizedType))
+        return true;
+    if (superstruct_1.is(valueProperties.Vector, exports.SuiMoveNormalizedType))
+        return true;
+    return false;
+}
+exports.SuiMoveNormalizedType = superstruct_1.define('SuiMoveNormalizedType', isSuiMoveNormalizedType);
+function isSuiMoveNormalizedStructType(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const valueProperties = value;
+    if (!valueProperties.Struct || typeof valueProperties.Struct !== 'object')
+        return false;
+    const structProperties = valueProperties.Struct;
+    if (typeof structProperties.address !== 'string' ||
+        typeof structProperties.module !== 'string' ||
+        typeof structProperties.name !== 'string' ||
+        !Array.isArray(structProperties.typeArguments) ||
+        !structProperties.typeArguments.every((value) => isSuiMoveNormalizedType(value))) {
+        return false;
+    }
+    return true;
+}
+// NOTE: This type is recursive, so we need to manually implement it:
+exports.SuiMoveNormalizedStructType = superstruct_1.define('SuiMoveNormalizedStructType', isSuiMoveNormalizedStructType);
+exports.SuiMoveNormalizedFunction = superstruct_1.object({
+    visibility: exports.SuiMoveVisibility,
+    isEntry: superstruct_1.boolean(),
+    typeParameters: superstruct_1.array(exports.SuiMoveAbilitySet),
+    parameters: superstruct_1.array(exports.SuiMoveNormalizedType),
+    return: superstruct_1.array(exports.SuiMoveNormalizedType),
+});
+exports.SuiMoveNormalizedField = superstruct_1.object({
+    name: superstruct_1.string(),
+    type: exports.SuiMoveNormalizedType,
+});
+exports.SuiMoveNormalizedStruct = superstruct_1.object({
+    abilities: exports.SuiMoveAbilitySet,
+    typeParameters: superstruct_1.array(exports.SuiMoveStructTypeParameter),
+    fields: superstruct_1.array(exports.SuiMoveNormalizedField),
+});
+exports.SuiMoveNormalizedModule = superstruct_1.object({
+    fileFormatVersion: superstruct_1.number(),
+    address: superstruct_1.string(),
+    name: superstruct_1.string(),
+    friends: superstruct_1.array(exports.SuiMoveModuleId),
+    structs: superstruct_1.record(superstruct_1.string(), exports.SuiMoveNormalizedStruct),
+    exposedFunctions: superstruct_1.record(superstruct_1.string(), exports.SuiMoveNormalizedFunction),
+});
+exports.SuiMoveNormalizedModules = superstruct_1.record(superstruct_1.string(), exports.SuiMoveNormalizedModule);
+function extractMutableReference(normalizedType) {
+    return typeof normalizedType === 'object' && 'MutableReference' in normalizedType
+        ? normalizedType.MutableReference
+        : undefined;
+}
+exports.extractMutableReference = extractMutableReference;
+function extractReference(normalizedType) {
+    return typeof normalizedType === 'object' && 'Reference' in normalizedType ? normalizedType.Reference : undefined;
+}
+exports.extractReference = extractReference;
+function extractStructTag(normalizedType) {
+    if (typeof normalizedType === 'object' && 'Struct' in normalizedType) {
+        return normalizedType;
+    }
+    const ref = extractReference(normalizedType);
+    const mutRef = extractMutableReference(normalizedType);
+    if (typeof ref === 'object' && 'Struct' in ref) {
+        return ref;
+    }
+    if (typeof mutRef === 'object' && 'Struct' in mutRef) {
+        return mutRef;
+    }
+    return undefined;
+}
+exports.extractStructTag = extractStructTag;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"normalized.js","sourceRoot":"","sources":["../../../../../src/lib/mystenlab/types/normalized.ts"],"names":[],"mappings":"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","sourcesContent":["import { array, Infer, object, string, union, boolean, define, number, literal, record, is } from 'superstruct';\n\nexport type SuiMoveFunctionArgTypesResponse = Infer<typeof SuiMoveFunctionArgType>[];\n\nexport const SuiMoveFunctionArgType = union([string(), object({ Object: string() })]);\n\nexport const SuiMoveFunctionArgTypes = array(SuiMoveFunctionArgType);\nexport type SuiMoveFunctionArgTypes = Infer<typeof SuiMoveFunctionArgTypes>;\n\nexport const SuiMoveModuleId = object({\n  address: string(),\n  name: string(),\n});\nexport type SuiMoveModuleId = Infer<typeof SuiMoveModuleId>;\n\nexport const SuiMoveVisibility = union([literal('Private'), literal('Public'), literal('Friend')]);\nexport type SuiMoveVisibility = Infer<typeof SuiMoveVisibility>;\n\nexport const SuiMoveAbilitySet = object({\n  abilities: array(string()),\n});\nexport type SuiMoveAbilitySet = Infer<typeof SuiMoveAbilitySet>;\n\nexport const SuiMoveStructTypeParameter = object({\n  constraints: SuiMoveAbilitySet,\n  isPhantom: boolean(),\n});\nexport type SuiMoveStructTypeParameter = Infer<typeof SuiMoveStructTypeParameter>;\n\nexport const SuiMoveNormalizedTypeParameterType = object({\n  TypeParameter: number(),\n});\nexport type SuiMoveNormalizedTypeParameterType = Infer<typeof SuiMoveNormalizedTypeParameterType>;\n\nexport type SuiMoveNormalizedType =\n  | string\n  | SuiMoveNormalizedTypeParameterType\n  | { Reference: SuiMoveNormalizedType }\n  | { MutableReference: SuiMoveNormalizedType }\n  | { Vector: SuiMoveNormalizedType }\n  | SuiMoveNormalizedStructType;\n\nfunction isSuiMoveNormalizedType(value: unknown): value is SuiMoveNormalizedType {\n  if (!value) return false;\n  if (typeof value === 'string') return true;\n  if (is(value, SuiMoveNormalizedTypeParameterType)) return true;\n  if (isSuiMoveNormalizedStructType(value)) return true;\n  if (typeof value !== 'object') return false;\n\n  const valueProperties = value as Record<string, unknown>;\n  if (is(valueProperties.Reference, SuiMoveNormalizedType)) return true;\n  if (is(valueProperties.MutableReference, SuiMoveNormalizedType)) return true;\n  if (is(valueProperties.Vector, SuiMoveNormalizedType)) return true;\n  return false;\n}\n\nexport const SuiMoveNormalizedType = define<SuiMoveNormalizedType>('SuiMoveNormalizedType', isSuiMoveNormalizedType);\n\nexport type SuiMoveNormalizedStructType = {\n  Struct: {\n    address: string;\n    module: string;\n    name: string;\n    typeArguments: SuiMoveNormalizedType[];\n  };\n};\n\nfunction isSuiMoveNormalizedStructType(value: unknown): value is SuiMoveNormalizedStructType {\n  if (!value || typeof value !== 'object') return false;\n\n  const valueProperties = value as Record<string, unknown>;\n  if (!valueProperties.Struct || typeof valueProperties.Struct !== 'object') return false;\n\n  const structProperties = valueProperties.Struct as Record<string, unknown>;\n  if (\n    typeof structProperties.address !== 'string' ||\n    typeof structProperties.module !== 'string' ||\n    typeof structProperties.name !== 'string' ||\n    !Array.isArray(structProperties.typeArguments) ||\n    !structProperties.typeArguments.every((value) => isSuiMoveNormalizedType(value))\n  ) {\n    return false;\n  }\n\n  return true;\n}\n\n// NOTE: This type is recursive, so we need to manually implement it:\nexport const SuiMoveNormalizedStructType = define<SuiMoveNormalizedStructType>(\n  'SuiMoveNormalizedStructType',\n  isSuiMoveNormalizedStructType\n);\n\nexport const SuiMoveNormalizedFunction = object({\n  visibility: SuiMoveVisibility,\n  isEntry: boolean(),\n  typeParameters: array(SuiMoveAbilitySet),\n  parameters: array(SuiMoveNormalizedType),\n  return: array(SuiMoveNormalizedType),\n});\nexport type SuiMoveNormalizedFunction = Infer<typeof SuiMoveNormalizedFunction>;\n\nexport const SuiMoveNormalizedField = object({\n  name: string(),\n  type: SuiMoveNormalizedType,\n});\nexport type SuiMoveNormalizedField = Infer<typeof SuiMoveNormalizedField>;\n\nexport const SuiMoveNormalizedStruct = object({\n  abilities: SuiMoveAbilitySet,\n  typeParameters: array(SuiMoveStructTypeParameter),\n  fields: array(SuiMoveNormalizedField),\n});\nexport type SuiMoveNormalizedStruct = Infer<typeof SuiMoveNormalizedStruct>;\n\nexport const SuiMoveNormalizedModule = object({\n  fileFormatVersion: number(),\n  address: string(),\n  name: string(),\n  friends: array(SuiMoveModuleId),\n  structs: record(string(), SuiMoveNormalizedStruct),\n  exposedFunctions: record(string(), SuiMoveNormalizedFunction),\n});\nexport type SuiMoveNormalizedModule = Infer<typeof SuiMoveNormalizedModule>;\n\nexport const SuiMoveNormalizedModules = record(string(), SuiMoveNormalizedModule);\nexport type SuiMoveNormalizedModules = Infer<typeof SuiMoveNormalizedModules>;\n\nexport function extractMutableReference(normalizedType: SuiMoveNormalizedType): SuiMoveNormalizedType | undefined {\n  return typeof normalizedType === 'object' && 'MutableReference' in normalizedType\n    ? normalizedType.MutableReference\n    : undefined;\n}\n\nexport function extractReference(normalizedType: SuiMoveNormalizedType): SuiMoveNormalizedType | undefined {\n  return typeof normalizedType === 'object' && 'Reference' in normalizedType ? normalizedType.Reference : undefined;\n}\n\nexport function extractStructTag(normalizedType: SuiMoveNormalizedType): SuiMoveNormalizedStructType | undefined {\n  if (typeof normalizedType === 'object' && 'Struct' in normalizedType) {\n    return normalizedType;\n  }\n\n  const ref = extractReference(normalizedType);\n  const mutRef = extractMutableReference(normalizedType);\n\n  if (typeof ref === 'object' && 'Struct' in ref) {\n    return ref;\n  }\n\n  if (typeof mutRef === 'object' && 'Struct' in mutRef) {\n    return mutRef;\n  }\n  return undefined;\n}\n"]}