@dedot/contracts 0.0.1-alpha.33

package/utils.js

@@ -0,0 +1,99 @@
+import { stringCamelCase } from '@dedot/utils';
+export const extractContractTypes = (contractMetadata) => {
+    const { types } = contractMetadata;
+    return types.map(({ type, id }) => ({
+        id,
+        type: normalizeContractTypeDef(type.def),
+        params: [],
+        path: type?.path || [],
+        docs: [],
+    }));
+};
+export const normalizeContractTypeDef = (def) => {
+    let tag;
+    let value;
+    if (def.variant) {
+        tag = 'Enum';
+        value = {
+            members: def.variant.variants?.map((variant) => ({
+                fields: variant.fields?.map((fields) => ({ typeId: fields.type, typeName: fields.typeName })) || [],
+                index: variant.index,
+                name: variant.name,
+            })) || [],
+        };
+    }
+    else if (def.tuple) {
+        tag = 'Tuple';
+        value = {
+            fields: def.tuple,
+        };
+    }
+    else if (def.sequence) {
+        tag = 'Sequence';
+        value = {
+            typeParam: def.sequence.type,
+        };
+    }
+    else if (def.composite) {
+        tag = 'Struct';
+        value = {
+            fields: def.composite.fields.map((one) => ({
+                typeId: one.type,
+                name: one.name,
+                typeName: one.typeName,
+            })),
+        };
+    }
+    else if (def.primitive) {
+        tag = 'Primitive';
+        value = {
+            kind: def.primitive,
+        };
+    }
+    else if (def.array) {
+        tag = 'SizedVec';
+        value = {
+            len: def.array.len,
+            typeParam: def.array.type,
+        };
+    }
+    else {
+        throw Error(`Invalid contract type def: ${JSON.stringify(def)}`);
+    }
+    return { tag, value };
+};
+const UNSUPPORTED_VERSIONS = ['V3', 'V2', 'V1'];
+const SUPPORTED_VERSIONS = ['5', '4'];
+export const parseRawMetadata = (rawMetadata) => {
+    const metadata = JSON.parse(rawMetadata);
+    // This is for V1, V2, V3
+    const unsupportedVersion = UNSUPPORTED_VERSIONS.find((o) => metadata[o]);
+    if (unsupportedVersion) {
+        throw new Error(`Unsupported metadata version: ${unsupportedVersion}`);
+    }
+    // This is for V4, V5
+    if (!SUPPORTED_VERSIONS.includes(metadata.version)) {
+        throw new Error(`Unsupported metadata version: ${metadata.version}`);
+    }
+    return metadata;
+};
+export function newProxyChain(carrier) {
+    return new Proxy(carrier, {
+        get(target, property) {
+            return target.doExecute(property.toString());
+        },
+    });
+}
+export function ensureSupportContractsPallet(api) {
+    try {
+        !!api.call.contractsApi.call.meta && !!api.tx.contracts.call.meta;
+    }
+    catch {
+        throw new Error('Contracts pallet is not available');
+    }
+}
+export function normalizeLabel(label) {
+    if (!label)
+        return '';
+    return stringCamelCase(label.replaceAll('::', '_'));
+}