@talismn/util 0.0.0-pr2091-20250715125148 → 0.0.0-pr2093-20250715143904

package/dist/declarations/src/blake2Concat.d.ts

@@ -0,0 +1 @@
+export declare function blake2Concat(input: Uint8Array): `0x${string}`;

package/dist/declarations/src/classNames.d.ts

@@ -1,2 +1 @@
 export declare const classNames: (...classLists: import("tailwind-merge").ClassNameValue[]) => string;
-export declare const cn: (...classLists: import("tailwind-merge").ClassNameValue[]) => string;

package/dist/declarations/src/convertAddress.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param address substrate SS58 address
+ * @param prefix prefix used to format the address
+ * @returns address encoded with supplied prefix
+ */
+export declare const convertAddress: (address: string, prefix: number | null) => string;

package/dist/declarations/src/decodeAnyAddress.d.ts

@@ -0,0 +1 @@
+export declare function decodeAnyAddress(encoded?: string | Uint8Array | null | undefined, ignoreChecksum?: boolean | undefined, ss58Format?: number | undefined): Uint8Array;

package/dist/declarations/src/decodeSs58Format.d.ts

@@ -0,0 +1 @@
+export declare const decodeSs58Format: (address?: string) => number | undefined;

package/dist/declarations/src/encodeAnyAddress.d.ts

@@ -0,0 +1 @@
+export declare function encodeAnyAddress(key: string | Uint8Array, ss58Format?: number | undefined): string;

package/dist/declarations/src/index.d.ts

@@ -1,7 +1,12 @@
 export * from "./addTrailingSlash";
 export * from "./BigMath";
+export * from "./blake2Concat";
 export * from "./classNames";
+export * from "./convertAddress";
+export * from "./decodeAnyAddress";
+export * from "./decodeSs58Format";
 export * from "./deferred";
+export * from "./encodeAnyAddress";
 export * from "./firstThenDebounce";
 export * from "./formatDecimals";
 export * from "./formatPrice";
@@ -10,11 +15,16 @@ export * from "./hasOwnProperty";
 export * from "./isArrayOf";
 export * from "./isBigInt";
 export * from "./isBooleanTrue";
+export * from "./isEthereumAddress";
+export * from "./isValidSubstrateAddress";
 export * from "./planckToTokens";
 export * from "./sleep";
 export * from "./throwAfter";
 export * from "./tokensToPlanck";
+export * from "./twox64Concat";
 export * from "./validateHexString";
+export * from "./normalizeAddress";
+export * from "./isAddressEqual";
 export * from "./isAscii";
 export * from "./isNotNil";
 export * from "./isTruthy";

package/dist/declarations/src/isAddressEqual.d.ts

@@ -0,0 +1 @@
+export declare const isAddressEqual: (address1: string, address2: string) => boolean;

package/dist/declarations/src/isEthereumAddress.d.ts

@@ -0,0 +1 @@
+export declare const isEthereumAddress: (address: string | undefined | null) => address is `0x${string}`;

package/dist/declarations/src/isValidSubstrateAddress.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Similar to isValidAddress but will not call isEthereumAddress under the hood
+ * @param address
+ * @param prefix if supplied, the method will also check the prefix
+ * @returns true if valid substrate (SS58) address, false otherwise
+ */
+export declare const isValidSubstrateAddress: (address: string, prefix?: number | null) => boolean;

package/dist/declarations/src/normalizeAddress.d.ts

@@ -0,0 +1 @@
+export declare const normalizeAddress: (address: string) => string;

package/dist/declarations/src/twox64Concat.d.ts

@@ -0,0 +1 @@
+export declare function twox64Concat(input: string | Buffer | Uint8Array): `0x${string}`;

package/dist/declarations/src/validateHexString.d.ts

@@ -1,11 +1,12 @@
+import { HexString } from "@polkadot/util/types";
 /**
  * @name validateHexString
  * @description Checks if a string is a hex string. Required to account for type differences between different polkadot libraries
  * @param {string} str - string to check
- * @returns {`0x${string}`} - boolean
+ * @returns {HexString} - boolean
  * @example
  * validateHexString("0x1234") // "0x1234"
  * validateHexString("1234") // Error: Expected a hex string
  * validateHexString(1234) // Error: Expected a string
  **/
-export declare const validateHexString: (str: string) => `0x${string}`;
+export declare const validateHexString: (str: string) => HexString;

package/dist/talismn-util.cjs.dev.js

@@ -1,6 +1,9 @@
 'use strict';
 
+var util = require('@polkadot/util');
+var utilCrypto = require('@polkadot/util-crypto');
 var tailwindMerge = require('tailwind-merge');
+var keyring = require('@polkadot/keyring');
 var rxjs = require('rxjs');
 var BigNumber = require('bignumber.js');
 
@@ -42,8 +45,54 @@ const BigMath = {
   }
 };
 
+const bitLength$1 = 128;
+function blake2Concat(input) {
+  return util.u8aToHex(util.u8aConcat(utilCrypto.blake2AsU8a(input, bitLength$1), util.u8aToU8a(input)));
+}
+
 const classNames = tailwindMerge.twMerge;
-const cn = tailwindMerge.twMerge;
+
+function encodeAnyAddress(key, ss58Format) {
+  try {
+    return keyring.encodeAddress(key, ss58Format);
+  } catch (error) {
+    if (typeof key !== "string") throw error;
+    if (!utilCrypto.isEthereumAddress(key)) throw error;
+    return utilCrypto.ethereumEncode(key);
+  }
+}
+
+/**
+ *
+ * @param address substrate SS58 address
+ * @param prefix prefix used to format the address
+ * @returns address encoded with supplied prefix
+ */
+const convertAddress = (address, prefix) => {
+  return encodeAnyAddress(address, prefix ?? undefined);
+};
+
+function decodeAnyAddress(encoded, ignoreChecksum, ss58Format) {
+  try {
+    return keyring.decodeAddress(encoded, ignoreChecksum, ss58Format);
+  } catch (error) {
+    if (typeof encoded !== "string") throw error;
+    if (!utilCrypto.isEthereumAddress(encoded)) throw error;
+    return util.hexToU8a(encoded.slice("0x".length));
+  }
+}
+
+const decodeSs58Format = address => {
+  if (!address) return;
+  try {
+    utilCrypto.decodeAddress(address);
+    const decoded = utilCrypto.base58Decode(address);
+    const [,,, ss58Format] = utilCrypto.checkAddressChecksum(decoded);
+    return ss58Format;
+  } catch {
+    return; // invalid address
+  }
+};
 
 /**
  * In TypeScript, a deferred promise refers to a pattern that involves creating a promise that can be
@@ -161,6 +210,30 @@ const isBigInt = value => typeof value === "bigint";
 
 const isBooleanTrue = x => !!x;
 
+const isEthereumAddress = address => !!address && address.startsWith("0x") && address.length === 42;
+
+/**
+ * Similar to isValidAddress but will not call isEthereumAddress under the hood
+ * @param address
+ * @param prefix if supplied, the method will also check the prefix
+ * @returns true if valid substrate (SS58) address, false otherwise
+ */
+const isValidSubstrateAddress = (address, prefix) => {
+  try {
+    // attempt to encode, it will throw an error if address is invalid
+    const encoded = keyring.encodeAddress(address, prefix ?? undefined);
+
+    //if a prefix is supplied, check that reencoding using this prefix matches the input address
+    if (prefix !== undefined) return address === encoded;
+
+    //if no prefix supplied, the fact that decoding + encoding succeded indicates that the address is valid
+    return true;
+  } catch (error) {
+    // input is not a substrate (SS58) address
+    return false;
+  }
+};
+
 function planckToTokens(planck, tokenDecimals) {
   if (typeof planck !== "string" || typeof tokenDecimals !== "number") return;
   const base = 10;
@@ -183,11 +256,17 @@ function tokensToPlanck(tokens, tokenDecimals) {
   return new BigNumber__default.default(tokens).multipliedBy(multiplier).toString(10);
 }
 
+const bitLength = 64;
+function twox64Concat(input) {
+  const inputAsU8a = typeof input === "string" ? input : new Uint8Array(input);
+  return util.u8aToHex(util.u8aConcat(utilCrypto.xxhashAsU8a(inputAsU8a, bitLength), util.u8aToU8a(inputAsU8a)));
+}
+
 /**
  * @name validateHexString
  * @description Checks if a string is a hex string. Required to account for type differences between different polkadot libraries
  * @param {string} str - string to check
- * @returns {`0x${string}`} - boolean
+ * @returns {HexString} - boolean
  * @example
  * validateHexString("0x1234") // "0x1234"
  * validateHexString("1234") // Error: Expected a hex string
@@ -203,6 +282,24 @@ const validateHexString = str => {
   throw new Error("Expected a hex string");
 };
 
+const CACHE$1 = new Map();
+
+// Normalize an address in a way that it can be compared to other addresses that have also been normalized
+const normalizeAddress = address => {
+  try {
+    if (!CACHE$1.has(address)) CACHE$1.set(address, encodeAnyAddress(address));
+    return CACHE$1.get(address);
+  } catch (cause) {
+    throw new Error(`Unable to normalize address: ${address}`, {
+      cause
+    });
+  }
+};
+
+const isAddressEqual = (address1, address2) => {
+  return normalizeAddress(address1) === normalizeAddress(address2);
+};
+
 const isAscii = str => {
   return [...str].every(char => char.charCodeAt(0) <= 127);
 };
@@ -286,23 +383,32 @@ exports.BigMath = BigMath;
 exports.Deferred = Deferred;
 exports.MAX_DECIMALS_FORMAT = MAX_DECIMALS_FORMAT;
 exports.addTrailingSlash = addTrailingSlash;
+exports.blake2Concat = blake2Concat;
 exports.classNames = classNames;
-exports.cn = cn;
+exports.convertAddress = convertAddress;
+exports.decodeAnyAddress = decodeAnyAddress;
+exports.decodeSs58Format = decodeSs58Format;
+exports.encodeAnyAddress = encodeAnyAddress;
 exports.firstThenDebounce = firstThenDebounce;
 exports.formatDecimals = formatDecimals;
 exports.formatPrice = formatPrice;
 exports.getSharedObservable = getSharedObservable;
 exports.hasOwnProperty = hasOwnProperty;
 exports.isAbortError = isAbortError;
+exports.isAddressEqual = isAddressEqual;
 exports.isArrayOf = isArrayOf;
 exports.isAscii = isAscii;
 exports.isBigInt = isBigInt;
 exports.isBooleanTrue = isBooleanTrue;
+exports.isEthereumAddress = isEthereumAddress;
 exports.isNotNil = isNotNil;
 exports.isTruthy = isTruthy;
+exports.isValidSubstrateAddress = isValidSubstrateAddress;
 exports.keepAlive = keepAlive;
+exports.normalizeAddress = normalizeAddress;
 exports.planckToTokens = planckToTokens;
 exports.sleep = sleep;
 exports.throwAfter = throwAfter;
 exports.tokensToPlanck = tokensToPlanck;
+exports.twox64Concat = twox64Concat;
 exports.validateHexString = validateHexString;

package/dist/talismn-util.cjs.prod.js

@@ -1,6 +1,9 @@
 'use strict';
 
+var util = require('@polkadot/util');
+var utilCrypto = require('@polkadot/util-crypto');
 var tailwindMerge = require('tailwind-merge');
+var keyring = require('@polkadot/keyring');
 var rxjs = require('rxjs');
 var BigNumber = require('bignumber.js');
 
@@ -42,8 +45,54 @@ const BigMath = {
   }
 };
 
+const bitLength$1 = 128;
+function blake2Concat(input) {
+  return util.u8aToHex(util.u8aConcat(utilCrypto.blake2AsU8a(input, bitLength$1), util.u8aToU8a(input)));
+}
+
 const classNames = tailwindMerge.twMerge;
-const cn = tailwindMerge.twMerge;
+
+function encodeAnyAddress(key, ss58Format) {
+  try {
+    return keyring.encodeAddress(key, ss58Format);
+  } catch (error) {
+    if (typeof key !== "string") throw error;
+    if (!utilCrypto.isEthereumAddress(key)) throw error;
+    return utilCrypto.ethereumEncode(key);
+  }
+}
+
+/**
+ *
+ * @param address substrate SS58 address
+ * @param prefix prefix used to format the address
+ * @returns address encoded with supplied prefix
+ */
+const convertAddress = (address, prefix) => {
+  return encodeAnyAddress(address, prefix ?? undefined);
+};
+
+function decodeAnyAddress(encoded, ignoreChecksum, ss58Format) {
+  try {
+    return keyring.decodeAddress(encoded, ignoreChecksum, ss58Format);
+  } catch (error) {
+    if (typeof encoded !== "string") throw error;
+    if (!utilCrypto.isEthereumAddress(encoded)) throw error;
+    return util.hexToU8a(encoded.slice("0x".length));
+  }
+}
+
+const decodeSs58Format = address => {
+  if (!address) return;
+  try {
+    utilCrypto.decodeAddress(address);
+    const decoded = utilCrypto.base58Decode(address);
+    const [,,, ss58Format] = utilCrypto.checkAddressChecksum(decoded);
+    return ss58Format;
+  } catch {
+    return; // invalid address
+  }
+};
 
 /**
  * In TypeScript, a deferred promise refers to a pattern that involves creating a promise that can be
@@ -161,6 +210,30 @@ const isBigInt = value => typeof value === "bigint";
 
 const isBooleanTrue = x => !!x;
 
+const isEthereumAddress = address => !!address && address.startsWith("0x") && address.length === 42;
+
+/**
+ * Similar to isValidAddress but will not call isEthereumAddress under the hood
+ * @param address
+ * @param prefix if supplied, the method will also check the prefix
+ * @returns true if valid substrate (SS58) address, false otherwise
+ */
+const isValidSubstrateAddress = (address, prefix) => {
+  try {
+    // attempt to encode, it will throw an error if address is invalid
+    const encoded = keyring.encodeAddress(address, prefix ?? undefined);
+
+    //if a prefix is supplied, check that reencoding using this prefix matches the input address
+    if (prefix !== undefined) return address === encoded;
+
+    //if no prefix supplied, the fact that decoding + encoding succeded indicates that the address is valid
+    return true;
+  } catch (error) {
+    // input is not a substrate (SS58) address
+    return false;
+  }
+};
+
 function planckToTokens(planck, tokenDecimals) {
   if (typeof planck !== "string" || typeof tokenDecimals !== "number") return;
   const base = 10;
@@ -183,11 +256,17 @@ function tokensToPlanck(tokens, tokenDecimals) {
   return new BigNumber__default.default(tokens).multipliedBy(multiplier).toString(10);
 }
 
+const bitLength = 64;
+function twox64Concat(input) {
+  const inputAsU8a = typeof input === "string" ? input : new Uint8Array(input);
+  return util.u8aToHex(util.u8aConcat(utilCrypto.xxhashAsU8a(inputAsU8a, bitLength), util.u8aToU8a(inputAsU8a)));
+}
+
 /**
  * @name validateHexString
  * @description Checks if a string is a hex string. Required to account for type differences between different polkadot libraries
  * @param {string} str - string to check
- * @returns {`0x${string}`} - boolean
+ * @returns {HexString} - boolean
  * @example
  * validateHexString("0x1234") // "0x1234"
  * validateHexString("1234") // Error: Expected a hex string
@@ -203,6 +282,24 @@ const validateHexString = str => {
   throw new Error("Expected a hex string");
 };
 
+const CACHE$1 = new Map();
+
+// Normalize an address in a way that it can be compared to other addresses that have also been normalized
+const normalizeAddress = address => {
+  try {
+    if (!CACHE$1.has(address)) CACHE$1.set(address, encodeAnyAddress(address));
+    return CACHE$1.get(address);
+  } catch (cause) {
+    throw new Error(`Unable to normalize address: ${address}`, {
+      cause
+    });
+  }
+};
+
+const isAddressEqual = (address1, address2) => {
+  return normalizeAddress(address1) === normalizeAddress(address2);
+};
+
 const isAscii = str => {
   return [...str].every(char => char.charCodeAt(0) <= 127);
 };
@@ -286,23 +383,32 @@ exports.BigMath = BigMath;
 exports.Deferred = Deferred;
 exports.MAX_DECIMALS_FORMAT = MAX_DECIMALS_FORMAT;
 exports.addTrailingSlash = addTrailingSlash;
+exports.blake2Concat = blake2Concat;
 exports.classNames = classNames;
-exports.cn = cn;
+exports.convertAddress = convertAddress;
+exports.decodeAnyAddress = decodeAnyAddress;
+exports.decodeSs58Format = decodeSs58Format;
+exports.encodeAnyAddress = encodeAnyAddress;
 exports.firstThenDebounce = firstThenDebounce;
 exports.formatDecimals = formatDecimals;
 exports.formatPrice = formatPrice;
 exports.getSharedObservable = getSharedObservable;
 exports.hasOwnProperty = hasOwnProperty;
 exports.isAbortError = isAbortError;
+exports.isAddressEqual = isAddressEqual;
 exports.isArrayOf = isArrayOf;
 exports.isAscii = isAscii;
 exports.isBigInt = isBigInt;
 exports.isBooleanTrue = isBooleanTrue;
+exports.isEthereumAddress = isEthereumAddress;
 exports.isNotNil = isNotNil;
 exports.isTruthy = isTruthy;
+exports.isValidSubstrateAddress = isValidSubstrateAddress;
 exports.keepAlive = keepAlive;
+exports.normalizeAddress = normalizeAddress;
 exports.planckToTokens = planckToTokens;
 exports.sleep = sleep;
 exports.throwAfter = throwAfter;
 exports.tokensToPlanck = tokensToPlanck;
+exports.twox64Concat = twox64Concat;
 exports.validateHexString = validateHexString;

package/dist/talismn-util.esm.js

@@ -1,4 +1,7 @@
+import { u8aToHex, u8aConcat, u8aToU8a, hexToU8a } from '@polkadot/util';
+import { blake2AsU8a, isEthereumAddress as isEthereumAddress$1, ethereumEncode, decodeAddress as decodeAddress$1, base58Decode, checkAddressChecksum, xxhashAsU8a } from '@polkadot/util-crypto';
 import { twMerge } from 'tailwind-merge';
+import { encodeAddress, decodeAddress } from '@polkadot/keyring';
 import { concat, take, skip, debounceTime, shareReplay, tap } from 'rxjs';
 import BigNumber from 'bignumber.js';
 
@@ -36,8 +39,54 @@ const BigMath = {
   }
 };
 
+const bitLength$1 = 128;
+function blake2Concat(input) {
+  return u8aToHex(u8aConcat(blake2AsU8a(input, bitLength$1), u8aToU8a(input)));
+}
+
 const classNames = twMerge;
-const cn = twMerge;
+
+function encodeAnyAddress(key, ss58Format) {
+  try {
+    return encodeAddress(key, ss58Format);
+  } catch (error) {
+    if (typeof key !== "string") throw error;
+    if (!isEthereumAddress$1(key)) throw error;
+    return ethereumEncode(key);
+  }
+}
+
+/**
+ *
+ * @param address substrate SS58 address
+ * @param prefix prefix used to format the address
+ * @returns address encoded with supplied prefix
+ */
+const convertAddress = (address, prefix) => {
+  return encodeAnyAddress(address, prefix ?? undefined);
+};
+
+function decodeAnyAddress(encoded, ignoreChecksum, ss58Format) {
+  try {
+    return decodeAddress(encoded, ignoreChecksum, ss58Format);
+  } catch (error) {
+    if (typeof encoded !== "string") throw error;
+    if (!isEthereumAddress$1(encoded)) throw error;
+    return hexToU8a(encoded.slice("0x".length));
+  }
+}
+
+const decodeSs58Format = address => {
+  if (!address) return;
+  try {
+    decodeAddress$1(address);
+    const decoded = base58Decode(address);
+    const [,,, ss58Format] = checkAddressChecksum(decoded);
+    return ss58Format;
+  } catch {
+    return; // invalid address
+  }
+};
 
 /**
  * In TypeScript, a deferred promise refers to a pattern that involves creating a promise that can be
@@ -155,6 +204,30 @@ const isBigInt = value => typeof value === "bigint";
 
 const isBooleanTrue = x => !!x;
 
+const isEthereumAddress = address => !!address && address.startsWith("0x") && address.length === 42;
+
+/**
+ * Similar to isValidAddress but will not call isEthereumAddress under the hood
+ * @param address
+ * @param prefix if supplied, the method will also check the prefix
+ * @returns true if valid substrate (SS58) address, false otherwise
+ */
+const isValidSubstrateAddress = (address, prefix) => {
+  try {
+    // attempt to encode, it will throw an error if address is invalid
+    const encoded = encodeAddress(address, prefix ?? undefined);
+
+    //if a prefix is supplied, check that reencoding using this prefix matches the input address
+    if (prefix !== undefined) return address === encoded;
+
+    //if no prefix supplied, the fact that decoding + encoding succeded indicates that the address is valid
+    return true;
+  } catch (error) {
+    // input is not a substrate (SS58) address
+    return false;
+  }
+};
+
 function planckToTokens(planck, tokenDecimals) {
   if (typeof planck !== "string" || typeof tokenDecimals !== "number") return;
   const base = 10;
@@ -177,11 +250,17 @@ function tokensToPlanck(tokens, tokenDecimals) {
   return new BigNumber(tokens).multipliedBy(multiplier).toString(10);
 }
 
+const bitLength = 64;
+function twox64Concat(input) {
+  const inputAsU8a = typeof input === "string" ? input : new Uint8Array(input);
+  return u8aToHex(u8aConcat(xxhashAsU8a(inputAsU8a, bitLength), u8aToU8a(inputAsU8a)));
+}
+
 /**
  * @name validateHexString
  * @description Checks if a string is a hex string. Required to account for type differences between different polkadot libraries
  * @param {string} str - string to check
- * @returns {`0x${string}`} - boolean
+ * @returns {HexString} - boolean
  * @example
  * validateHexString("0x1234") // "0x1234"
  * validateHexString("1234") // Error: Expected a hex string
@@ -197,6 +276,24 @@ const validateHexString = str => {
   throw new Error("Expected a hex string");
 };
 
+const CACHE$1 = new Map();
+
+// Normalize an address in a way that it can be compared to other addresses that have also been normalized
+const normalizeAddress = address => {
+  try {
+    if (!CACHE$1.has(address)) CACHE$1.set(address, encodeAnyAddress(address));
+    return CACHE$1.get(address);
+  } catch (cause) {
+    throw new Error(`Unable to normalize address: ${address}`, {
+      cause
+    });
+  }
+};
+
+const isAddressEqual = (address1, address2) => {
+  return normalizeAddress(address1) === normalizeAddress(address2);
+};
+
 const isAscii = str => {
   return [...str].every(char => char.charCodeAt(0) <= 127);
 };
@@ -276,4 +373,4 @@ const keepSourceSubscribed = (observable, ms) => {
   return () => setTimeout(() => sub.unsubscribe(), ms);
 };
 
-export { BigMath, Deferred, MAX_DECIMALS_FORMAT, addTrailingSlash, classNames, cn, firstThenDebounce, formatDecimals, formatPrice, getSharedObservable, hasOwnProperty, isAbortError, isArrayOf, isAscii, isBigInt, isBooleanTrue, isNotNil, isTruthy, keepAlive, planckToTokens, sleep, throwAfter, tokensToPlanck, validateHexString };
+export { BigMath, Deferred, MAX_DECIMALS_FORMAT, addTrailingSlash, blake2Concat, classNames, convertAddress, decodeAnyAddress, decodeSs58Format, encodeAnyAddress, firstThenDebounce, formatDecimals, formatPrice, getSharedObservable, hasOwnProperty, isAbortError, isAddressEqual, isArrayOf, isAscii, isBigInt, isBooleanTrue, isEthereumAddress, isNotNil, isTruthy, isValidSubstrateAddress, keepAlive, normalizeAddress, planckToTokens, sleep, throwAfter, tokensToPlanck, twox64Concat, validateHexString };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/util",
-  "version": "0.0.0-pr2091-20250715125148",
+  "version": "0.0.0-pr2093-20250715143904",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "GPL-3.0-or-later",
@@ -26,15 +26,21 @@
     "tailwind-merge": "^2.5.4"
   },
   "devDependencies": {
+    "@polkadot/keyring": "13.5.1",
+    "@polkadot/util": "13.5.1",
+    "@polkadot/util-crypto": "13.5.1",
     "@types/jest": "^29.5.14",
     "eslint": "^8.57.1",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "typescript": "^5.6.3",
-    "@talismn/eslint-config": "0.0.3",
-    "@talismn/tsconfig": "0.0.2"
+    "@talismn/tsconfig": "0.0.2",
+    "@talismn/eslint-config": "0.0.3"
   },
   "peerDependencies": {
+    "@polkadot/keyring": "*",
+    "@polkadot/util": "*",
+    "@polkadot/util-crypto": "*",
     "rxjs": ">= 7.8.1"
   },
   "eslintConfig": {