@talismn/scale 0.3.0 → 0.3.1

package/dist/index.d.ts

@@ -0,0 +1,927 @@
+import * as _polkadot_api_metadata_builders from '@polkadot-api/metadata-builders';
+import { getDynamicBuilder } from '@polkadot-api/metadata-builders';
+export { MetadataLookup, getDynamicBuilder, getLookupFn } from '@polkadot-api/metadata-builders';
+import * as _polkadot_api_substrate_bindings from '@polkadot-api/substrate-bindings';
+import { Metadata, UnifiedMetadata } from '@polkadot-api/substrate-bindings';
+export { Binary, Blake2128, Blake2128Concat, Blake2256, Blake3256, Blake3256Concat, Codec, FixedSizeBinary, Twox128, Twox256, Twox64Concat, UnifiedMetadata, decAnyMetadata, metadata, unifyMetadata } from '@polkadot-api/substrate-bindings';
+import * as scale_ts from 'scale-ts';
+export { fromHex, mergeUint8, toHex } from '@polkadot-api/utils';
+
+/** Constant: https://docs.substrate.io/build/application-development/#metadata-format */
+declare const magicNumber = 1635018093;
+type MetadataBuilder = ReturnType<typeof getDynamicBuilder>;
+
+type MetadataType = SupportedMetadata["lookup"][number];
+type MetadataPallet = SupportedMetadata["pallets"][number];
+type MetadataStorageItem = NonNullable<MetadataPallet["storage"]>["items"][number];
+type SupportedMetadata = Extract<Metadata["metadata"], {
+    tag: SupportedMetadataVersion;
+}>["value"];
+type SupportedMetadataVersion = "v14" | "v15" | "v16";
+/**
+ * Converts a `Metadata` into a `MiniMetadata`.
+ *
+ * A `MiniMetadata` only contains the types inside of its `lookup` which are relevant for
+ * the storage queries specified in `palletsAndItems`.
+ *
+ * E.g. if `palletsAndItems` is `{ pallet: "System", items: ["Account"] }`, then only the
+ * types used in the `System.Account` storage query will remain inside of metadata.lookups.
+ */
+declare const compactMetadata: (anyMetadata: Metadata, palletsAndItems?: Array<{
+    pallet: string;
+    constants?: string[];
+    items: string[];
+}>, runtimeApisAndMethods?: Array<{
+    runtimeApi: string;
+    methods: string[];
+}>, extraKeepTypes?: number[]) => void;
+
+type ScaleStorageCoder$1 = ReturnType<MetadataBuilder["buildStorage"]>;
+declare const decodeScale: <T>(scaleCoder: ScaleStorageCoder$1 | undefined, change: string | null, error?: string) => T | null;
+
+declare const encodeMetadata: (metadata: Metadata) => `0x${string}`;
+
+type ScaleStorageCoder = ReturnType<MetadataBuilder["buildStorage"]>;
+declare const encodeStateKey: (scaleCoder: ScaleStorageCoder | undefined, error?: string, ...args: unknown[]) => `0x${string}` | undefined;
+
+declare const getConstantValueFromMetadata: <T>(metadata: `0x${string}` | {
+    builder: MetadataBuilder;
+    unifiedMetadata: UnifiedMetadata;
+}, pallet: string, constant: string) => T;
+
+/**
+ * Extracts the `version` u8 from a SCALE-encoded metadata blob and returns it as a `number`.
+ *
+ * Only reads the first 40 bytes of the blob.
+ */
+declare const getMetadataVersion: (metadataRpc: string | Uint8Array | ArrayBuffer) => number;
+
+declare const getStorageKeyPrefix: (palletName: string, storageName: string) => string;
+
+declare const parseMetadataRpc: (metadataRpc: `0x${string}`) => {
+    metadata: {
+        magicNumber: number;
+        metadata: {
+            tag: "v0";
+            value: unknown;
+        } | {
+            tag: "v1";
+            value: unknown;
+        } | {
+            tag: "v2";
+            value: unknown;
+        } | {
+            tag: "v3";
+            value: unknown;
+        } | {
+            tag: "v4";
+            value: unknown;
+        } | {
+            tag: "v5";
+            value: unknown;
+        } | {
+            tag: "v6";
+            value: unknown;
+        } | {
+            tag: "v7";
+            value: unknown;
+        } | {
+            tag: "v8";
+            value: unknown;
+        } | {
+            tag: "v9";
+            value: unknown;
+        } | {
+            tag: "v10";
+            value: unknown;
+        } | {
+            tag: "v11";
+            value: unknown;
+        } | {
+            tag: "v12";
+            value: unknown;
+        } | {
+            tag: "v13";
+            value: unknown;
+        } | {
+            tag: "v14";
+            value: {
+                lookup: {
+                    id: number;
+                    path: string[];
+                    params: {
+                        name: string;
+                        type: number | undefined;
+                    }[];
+                    def: {
+                        tag: "composite";
+                        value: {
+                            name: string | undefined;
+                            type: number;
+                            typeName: string | undefined;
+                            docs: string[];
+                        }[];
+                    } | {
+                        tag: "variant";
+                        value: {
+                            name: string;
+                            fields: {
+                                name: string | undefined;
+                                type: number;
+                                typeName: string | undefined;
+                                docs: string[];
+                            }[];
+                            index: number;
+                            docs: string[];
+                        }[];
+                    } | {
+                        tag: "sequence";
+                        value: number;
+                    } | {
+                        tag: "array";
+                        value: {
+                            len: number;
+                            type: number;
+                        };
+                    } | {
+                        tag: "tuple";
+                        value: number[];
+                    } | {
+                        tag: "primitive";
+                        value: {
+                            tag: "bool";
+                            value: undefined;
+                        } | {
+                            tag: "char";
+                            value: undefined;
+                        } | {
+                            tag: "str";
+                            value: undefined;
+                        } | {
+                            tag: "u8";
+                            value: undefined;
+                        } | {
+                            tag: "u16";
+                            value: undefined;
+                        } | {
+                            tag: "u32";
+                            value: undefined;
+                        } | {
+                            tag: "u64";
+                            value: undefined;
+                        } | {
+                            tag: "u128";
+                            value: undefined;
+                        } | {
+                            tag: "u256";
+                            value: undefined;
+                        } | {
+                            tag: "i8";
+                            value: undefined;
+                        } | {
+                            tag: "i16";
+                            value: undefined;
+                        } | {
+                            tag: "i32";
+                            value: undefined;
+                        } | {
+                            tag: "i64";
+                            value: undefined;
+                        } | {
+                            tag: "i128";
+                            value: undefined;
+                        } | {
+                            tag: "i256";
+                            value: undefined;
+                        };
+                    } | {
+                        tag: "compact";
+                        value: number;
+                    } | {
+                        tag: "bitSequence";
+                        value: {
+                            bitStoreType: number;
+                            bitOrderType: number;
+                        };
+                    };
+                    docs: string[];
+                }[];
+                pallets: {
+                    docs: string[];
+                    name: string;
+                    storage: {
+                        prefix: string;
+                        items: {
+                            name: string;
+                            modifier: number;
+                            type: {
+                                tag: "map";
+                                value: {
+                                    hashers: ({
+                                        tag: "Blake2128";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Blake2256";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Blake2128Concat";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Twox128";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Twox256";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Twox64Concat";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Identity";
+                                        value: undefined;
+                                    })[];
+                                    key: number;
+                                    value: number;
+                                };
+                            } | {
+                                tag: "plain";
+                                value: number;
+                            };
+                            fallback: _polkadot_api_substrate_bindings.HexString;
+                            docs: string[];
+                        }[];
+                    } | undefined;
+                    calls: number | undefined;
+                    events: number | undefined;
+                    constants: {
+                        name: string;
+                        type: number;
+                        value: _polkadot_api_substrate_bindings.HexString;
+                        docs: string[];
+                    }[];
+                    errors: number | undefined;
+                    index: number;
+                }[];
+                extrinsic: {
+                    type: number;
+                    version: number;
+                    signedExtensions: {
+                        identifier: string;
+                        type: number;
+                        additionalSigned: number;
+                    }[];
+                };
+                type: number;
+                apis: {
+                    name: string;
+                    methods: {
+                        deprecationInfo: {
+                            tag: "NotDeprecated";
+                            value: undefined;
+                        } | {
+                            tag: "DeprecatedWithoutNote";
+                            value: undefined;
+                        } | {
+                            tag: "Deprecated";
+                            value: {
+                                note: string;
+                                since: string | undefined;
+                            };
+                        };
+                        name: string;
+                        inputs: {
+                            name: string;
+                            type: number;
+                        }[];
+                        output: number;
+                        docs: string[];
+                    }[];
+                    docs: string[];
+                    version: number;
+                    deprecationInfo: {
+                        tag: "NotDeprecated";
+                        value: undefined;
+                    } | {
+                        tag: "DeprecatedWithoutNote";
+                        value: undefined;
+                    } | {
+                        tag: "Deprecated";
+                        value: {
+                            note: string;
+                            since: string | undefined;
+                        };
+                    };
+                }[];
+            };
+        } | {
+            tag: "v15";
+            value: {
+                lookup: {
+                    id: number;
+                    path: string[];
+                    params: {
+                        name: string;
+                        type: number | undefined;
+                    }[];
+                    def: {
+                        tag: "composite";
+                        value: {
+                            name: string | undefined;
+                            type: number;
+                            typeName: string | undefined;
+                            docs: string[];
+                        }[];
+                    } | {
+                        tag: "variant";
+                        value: {
+                            name: string;
+                            fields: {
+                                name: string | undefined;
+                                type: number;
+                                typeName: string | undefined;
+                                docs: string[];
+                            }[];
+                            index: number;
+                            docs: string[];
+                        }[];
+                    } | {
+                        tag: "sequence";
+                        value: number;
+                    } | {
+                        tag: "array";
+                        value: {
+                            len: number;
+                            type: number;
+                        };
+                    } | {
+                        tag: "tuple";
+                        value: number[];
+                    } | {
+                        tag: "primitive";
+                        value: {
+                            tag: "bool";
+                            value: undefined;
+                        } | {
+                            tag: "char";
+                            value: undefined;
+                        } | {
+                            tag: "str";
+                            value: undefined;
+                        } | {
+                            tag: "u8";
+                            value: undefined;
+                        } | {
+                            tag: "u16";
+                            value: undefined;
+                        } | {
+                            tag: "u32";
+                            value: undefined;
+                        } | {
+                            tag: "u64";
+                            value: undefined;
+                        } | {
+                            tag: "u128";
+                            value: undefined;
+                        } | {
+                            tag: "u256";
+                            value: undefined;
+                        } | {
+                            tag: "i8";
+                            value: undefined;
+                        } | {
+                            tag: "i16";
+                            value: undefined;
+                        } | {
+                            tag: "i32";
+                            value: undefined;
+                        } | {
+                            tag: "i64";
+                            value: undefined;
+                        } | {
+                            tag: "i128";
+                            value: undefined;
+                        } | {
+                            tag: "i256";
+                            value: undefined;
+                        };
+                    } | {
+                        tag: "compact";
+                        value: number;
+                    } | {
+                        tag: "bitSequence";
+                        value: {
+                            bitStoreType: number;
+                            bitOrderType: number;
+                        };
+                    };
+                    docs: string[];
+                }[];
+                pallets: {
+                    docs: string[];
+                    name: string;
+                    storage: {
+                        prefix: string;
+                        items: {
+                            name: string;
+                            modifier: number;
+                            type: {
+                                tag: "map";
+                                value: {
+                                    hashers: ({
+                                        tag: "Blake2128";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Blake2256";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Blake2128Concat";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Twox128";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Twox256";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Twox64Concat";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Identity";
+                                        value: undefined;
+                                    })[];
+                                    key: number;
+                                    value: number;
+                                };
+                            } | {
+                                tag: "plain";
+                                value: number;
+                            };
+                            fallback: _polkadot_api_substrate_bindings.HexString;
+                            docs: string[];
+                        }[];
+                    } | undefined;
+                    calls: number | undefined;
+                    events: number | undefined;
+                    constants: {
+                        name: string;
+                        type: number;
+                        value: _polkadot_api_substrate_bindings.HexString;
+                        docs: string[];
+                    }[];
+                    errors: number | undefined;
+                    index: number;
+                }[];
+                extrinsic: {
+                    version: number;
+                    address: number;
+                    call: number;
+                    signature: number;
+                    extra: number;
+                    signedExtensions: {
+                        identifier: string;
+                        type: number;
+                        additionalSigned: number;
+                    }[];
+                };
+                type: number;
+                apis: {
+                    name: string;
+                    methods: {
+                        name: string;
+                        inputs: {
+                            name: string;
+                            type: number;
+                        }[];
+                        output: number;
+                        docs: string[];
+                    }[];
+                    docs: string[];
+                }[];
+                outerEnums: {
+                    call: number;
+                    event: number;
+                    error: number;
+                };
+                custom: [string, {
+                    type: number;
+                    value: _polkadot_api_substrate_bindings.HexString;
+                }][];
+            };
+        } | {
+            tag: "v16";
+            value: {
+                lookup: {
+                    id: number;
+                    path: string[];
+                    params: {
+                        name: string;
+                        type: number | undefined;
+                    }[];
+                    def: {
+                        tag: "composite";
+                        value: {
+                            name: string | undefined;
+                            type: number;
+                            typeName: string | undefined;
+                            docs: string[];
+                        }[];
+                    } | {
+                        tag: "variant";
+                        value: {
+                            name: string;
+                            fields: {
+                                name: string | undefined;
+                                type: number;
+                                typeName: string | undefined;
+                                docs: string[];
+                            }[];
+                            index: number;
+                            docs: string[];
+                        }[];
+                    } | {
+                        tag: "sequence";
+                        value: number;
+                    } | {
+                        tag: "array";
+                        value: {
+                            len: number;
+                            type: number;
+                        };
+                    } | {
+                        tag: "tuple";
+                        value: number[];
+                    } | {
+                        tag: "primitive";
+                        value: {
+                            tag: "bool";
+                            value: undefined;
+                        } | {
+                            tag: "char";
+                            value: undefined;
+                        } | {
+                            tag: "str";
+                            value: undefined;
+                        } | {
+                            tag: "u8";
+                            value: undefined;
+                        } | {
+                            tag: "u16";
+                            value: undefined;
+                        } | {
+                            tag: "u32";
+                            value: undefined;
+                        } | {
+                            tag: "u64";
+                            value: undefined;
+                        } | {
+                            tag: "u128";
+                            value: undefined;
+                        } | {
+                            tag: "u256";
+                            value: undefined;
+                        } | {
+                            tag: "i8";
+                            value: undefined;
+                        } | {
+                            tag: "i16";
+                            value: undefined;
+                        } | {
+                            tag: "i32";
+                            value: undefined;
+                        } | {
+                            tag: "i64";
+                            value: undefined;
+                        } | {
+                            tag: "i128";
+                            value: undefined;
+                        } | {
+                            tag: "i256";
+                            value: undefined;
+                        };
+                    } | {
+                        tag: "compact";
+                        value: number;
+                    } | {
+                        tag: "bitSequence";
+                        value: {
+                            bitStoreType: number;
+                            bitOrderType: number;
+                        };
+                    };
+                    docs: string[];
+                }[];
+                pallets: {
+                    name: string;
+                    storage: {
+                        prefix: string;
+                        items: {
+                            deprecationInfo: {
+                                tag: "NotDeprecated";
+                                value: undefined;
+                            } | {
+                                tag: "DeprecatedWithoutNote";
+                                value: undefined;
+                            } | {
+                                tag: "Deprecated";
+                                value: {
+                                    note: string;
+                                    since: string | undefined;
+                                };
+                            };
+                            name: string;
+                            modifier: number;
+                            type: {
+                                tag: "map";
+                                value: {
+                                    hashers: ({
+                                        tag: "Blake2128";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Blake2256";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Blake2128Concat";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Twox128";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Twox256";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Twox64Concat";
+                                        value: undefined;
+                                    } | {
+                                        tag: "Identity";
+                                        value: undefined;
+                                    })[];
+                                    key: number;
+                                    value: number;
+                                };
+                            } | {
+                                tag: "plain";
+                                value: number;
+                            };
+                            fallback: _polkadot_api_substrate_bindings.HexString;
+                            docs: string[];
+                        }[];
+                    } | undefined;
+                    calls: {
+                        type: number;
+                        deprecationInfo: {
+                            index: number;
+                            deprecation: {
+                                tag: "DeprecatedWithoutNote";
+                                value: undefined;
+                            } | {
+                                tag: "Deprecated";
+                                value: {
+                                    note: string;
+                                    since: string | undefined;
+                                };
+                            };
+                        }[];
+                    } | undefined;
+                    events: {
+                        type: number;
+                        deprecationInfo: {
+                            index: number;
+                            deprecation: {
+                                tag: "DeprecatedWithoutNote";
+                                value: undefined;
+                            } | {
+                                tag: "Deprecated";
+                                value: {
+                                    note: string;
+                                    since: string | undefined;
+                                };
+                            };
+                        }[];
+                    } | undefined;
+                    constants: {
+                        name: string;
+                        type: number;
+                        value: _polkadot_api_substrate_bindings.HexString;
+                        docs: string[];
+                        deprecationInfo: {
+                            tag: "NotDeprecated";
+                            value: undefined;
+                        } | {
+                            tag: "DeprecatedWithoutNote";
+                            value: undefined;
+                        } | {
+                            tag: "Deprecated";
+                            value: {
+                                note: string;
+                                since: string | undefined;
+                            };
+                        };
+                    }[];
+                    errors: {
+                        type: number;
+                        deprecationInfo: {
+                            index: number;
+                            deprecation: {
+                                tag: "DeprecatedWithoutNote";
+                                value: undefined;
+                            } | {
+                                tag: "Deprecated";
+                                value: {
+                                    note: string;
+                                    since: string | undefined;
+                                };
+                            };
+                        }[];
+                    } | undefined;
+                    associatedTypes: {
+                        name: string;
+                        type: number;
+                        docs: string[];
+                    }[];
+                    viewFns: {
+                        deprecationInfo: {
+                            tag: "NotDeprecated";
+                            value: undefined;
+                        } | {
+                            tag: "DeprecatedWithoutNote";
+                            value: undefined;
+                        } | {
+                            tag: "Deprecated";
+                            value: {
+                                note: string;
+                                since: string | undefined;
+                            };
+                        };
+                        name: string;
+                        inputs: {
+                            name: string;
+                            type: number;
+                        }[];
+                        output: number;
+                        docs: string[];
+                        id: _polkadot_api_substrate_bindings.HexString;
+                    }[];
+                    index: number;
+                    docs: string[];
+                    deprecationInfo: {
+                        tag: "NotDeprecated";
+                        value: undefined;
+                    } | {
+                        tag: "DeprecatedWithoutNote";
+                        value: undefined;
+                    } | {
+                        tag: "Deprecated";
+                        value: {
+                            note: string;
+                            since: string | undefined;
+                        };
+                    };
+                }[];
+                extrinsic: {
+                    version: number[];
+                    address: number;
+                    call: number;
+                    signature: number;
+                    signedExtensionsByVersion: [number, number[]][];
+                    signedExtensions: {
+                        identifier: string;
+                        type: number;
+                        additionalSigned: number;
+                    }[];
+                };
+                apis: {
+                    name: string;
+                    methods: {
+                        deprecationInfo: {
+                            tag: "NotDeprecated";
+                            value: undefined;
+                        } | {
+                            tag: "DeprecatedWithoutNote";
+                            value: undefined;
+                        } | {
+                            tag: "Deprecated";
+                            value: {
+                                note: string;
+                                since: string | undefined;
+                            };
+                        };
+                        name: string;
+                        inputs: {
+                            name: string;
+                            type: number;
+                        }[];
+                        output: number;
+                        docs: string[];
+                    }[];
+                    docs: string[];
+                    version: number;
+                    deprecationInfo: {
+                        tag: "NotDeprecated";
+                        value: undefined;
+                    } | {
+                        tag: "DeprecatedWithoutNote";
+                        value: undefined;
+                    } | {
+                        tag: "Deprecated";
+                        value: {
+                            note: string;
+                            since: string | undefined;
+                        };
+                    };
+                }[];
+                outerEnums: {
+                    call: number;
+                    event: number;
+                    error: number;
+                };
+                custom: [string, {
+                    type: number;
+                    value: _polkadot_api_substrate_bindings.HexString;
+                }][];
+            };
+        };
+    };
+    unifiedMetadata: _polkadot_api_substrate_bindings.UnifiedMetadata<14 | 15 | 16>;
+    lookupFn: _polkadot_api_metadata_builders.MetadataLookup;
+    builder: {
+        buildDefinition: (id: number) => scale_ts.Codec<any>;
+        buildStorage: (pallet: string, entry: string) => {
+            args: [scale_ts.Encoder<any[]>, scale_ts.Decoder<any[]>] & {
+                enc: scale_ts.Encoder<any[]>;
+                dec: scale_ts.Decoder<any[]>;
+            } & {
+                inner: scale_ts.Codec<any>[];
+            };
+            keys: {
+                enc: (...args: any[]) => string;
+                dec: (value: string) => any[];
+            };
+            value: scale_ts.Codec<any>;
+            len: number;
+            fallback: any;
+        };
+        buildEvent: (pallet: string, name: string) => {
+            codec: scale_ts.Codec<any>;
+            location: [number, number];
+        };
+        buildError: (pallet: string, name: string) => {
+            codec: scale_ts.Codec<any>;
+            location: [number, number];
+        };
+        buildViewFn: (pallet: string, entry: string) => {
+            args: [scale_ts.Encoder<any[]>, scale_ts.Decoder<any[]>] & {
+                enc: scale_ts.Encoder<any[]>;
+                dec: scale_ts.Decoder<any[]>;
+            } & {
+                inner: scale_ts.Codec<any>[];
+            };
+            value: scale_ts.Codec<any>;
+        };
+        buildRuntimeCall: (api: string, method: string) => {
+            args: [scale_ts.Encoder<any[]>, scale_ts.Decoder<any[]>] & {
+                enc: scale_ts.Encoder<any[]>;
+                dec: scale_ts.Decoder<any[]>;
+            } & {
+                inner: scale_ts.Codec<any>[];
+            };
+            value: scale_ts.Codec<any>;
+        };
+        buildCall: (pallet: string, name: string) => {
+            codec: scale_ts.Codec<any>;
+            location: [number, number];
+        };
+        buildConstant: (pallet: string, constantName: string) => scale_ts.Codec<any>;
+        ss58Prefix: number | undefined;
+    };
+};
+
+/**
+ * For the substrate-tokens (and other) modules, we configure the `onChainId` field in chaindata to tell the module how to query each token.
+ * These queries are made to the tokens pallet.
+ * E.g. api.query.Tokens.Account(accountAddress, papiParse(onChainId))
+ *
+ * The `onChainId` field on chaindata must be a JSON-parseable string, but for some SCALE types (especially the Binary type) we must
+ * use specific `polkadot-api` classes to handle SCALE-encoding the statekey.
+ *
+ * Some examples:
+ * Input: `5`
+ * Output: `5`
+ *
+ * Input: `{ type: "DexShare", value: [ { type: "Token", value: { type: "ACA" } }, { type: "Token", value: { type: "AUSD" } } ] }`
+ * Output: `Enum("DexShare", [Enum("Token", Enum("ACA")), Enum("Token", Enum("AUSD"))])`
+ *
+ * Input: `{ type: "LiquidCrowdloan", value: 13 }`
+ * Output: `Enum("LiquidCrowdloan", 13)`
+ *
+ * Input: `{ type: "NativeToken", value: "bigint:2" }`
+ * Output: `Enum("NativeToken", 2n)`
+ *
+ * Input: `{ type: "Erc20", value: "hex:0x07df96d1341a7d16ba1ad431e2c847d978bc2bce" }`
+ * Output: `Enum("Erc20", Binary.fromHex("0x07df96d1341a7d16ba1ad431e2c847d978bc2bce"))`
+ *
+ * Input: `{ type: "Stellar", value: { code: "bin:TZS", issuer: "hex:0x34c94b2a4ba9e8b57b22547dcbb30f443c4cb02da3829a89aa1bd4780e4466ba" } }`
+ * Output: `Enum("Stellar", { code: Binary.fromText("TZS"), issuer: Binary.fromHex("0x34c94b2a4ba9e8b57b22547dcbb30f443c4cb02da3829a89aa1bd4780e4466ba") })`
+ */
+declare const papiParse: <T = unknown>(text: string | T) => T;
+declare const papiStringify: (value: unknown, space?: string | number) => string;
+
+export { type MetadataBuilder, type MetadataPallet, type MetadataStorageItem, type MetadataType, type ScaleStorageCoder, compactMetadata, decodeScale, encodeMetadata, encodeStateKey, getConstantValueFromMetadata, getMetadataVersion, getStorageKeyPrefix, magicNumber, papiParse, papiStringify, parseMetadataRpc };