@galacticcouncil/common 0.1.0

package/build/index.cjs

@@ -0,0 +1 @@
+"use strict";var v=Object.create;var u=Object.defineProperty;var F=Object.getOwnPropertyDescriptor;var R=Object.getOwnPropertyNames;var w=Object.getPrototypeOf,U=Object.prototype.hasOwnProperty;var f=(t,r)=>{for(var e in r)u(t,e,{get:r[e],enumerable:!0})},I=(t,r,e,o)=>{if(r&&typeof r=="object"||typeof r=="function")for(let n of R(r))!U.call(t,n)&&n!==e&&u(t,n,{get:()=>r[n],enumerable:!(o=F(r,n))||o.enumerable});return t};var D=(t,r,e)=>(e=t!=null?v(w(t)):{},I(r||!t||!t.__esModule?u(e,"default",{value:t,enumerable:!0}):e,t)),T=t=>I(u({},"__esModule",{value:!0}),t);var X={};f(X,{HYDRATION_SS58_PREFIX:()=>a,RUNTIME_DECIMALS:()=>Y,big:()=>m,erc20:()=>l,h160:()=>y,version:()=>N,xc:()=>A});module.exports=T(X);var Y=18,a=63;var m={};f(m,{asBigInt:()=>_,toBigInt:()=>P,toDecimal:()=>H});var i=D(require("big.js"));i.default.NE=-18;function H(t,r,e=6,o){let n=(0,i.default)(t.toString()),d=(0,i.default)(10).pow(r);return n.div(d).round(e,o).toString()}function P(t,r){let e=(0,i.default)(10).pow(r),n=(0,i.default)(t).mul(e).toFixed(0,i.default.roundDown);return BigInt(n)}function _(t){return BigInt(t.round(0,i.default.roundDown).toFixed(0))}var l={};f(l,{ERC20:()=>x});var x=class{static fromAssetId(r){let e=Buffer.alloc(20,0);return e[15]=1,e.writeUInt32BE(r,16),"0x"+e.toString("hex")}static toAssetId(r){let e=Buffer.from(r.replace("0x",""),"hex");return e.length!==20||!this.isAssetAddress(r)?null:e.readUInt32BE(16)}static isAssetAddress(r){let e=Buffer.from("0000000000000000000000000000000100000000","hex"),o=Buffer.from(r.replace("0x",""),"hex");return o.length!==20?!1:o.subarray(0,16).equals(e.subarray(0,16))}};var y={};f(y,{H160:()=>B,isEvmAccount:()=>h,isEvmAddress:()=>b,isSs58Address:()=>E});var c=require("polkadot-api"),p=require("@polkadot-api/utils"),s=require("buffer");var g="ETH\0";function h(t){if(!t)return!1;try{let r=(0,c.AccountId)().enc(t),e=s.Buffer.from(g);return s.Buffer.from(r.subarray(0,e.length)).equals(e)}catch{return!1}}function b(t){return!!/^0x[a-fA-F0-9]{40}$/.test(t)}function E(t){try{return(0,c.AccountId)(63).enc(t),!0}catch{return!1}}var B=class t{static toAccount=r=>{let e=s.Buffer.from(r.slice(2),"hex"),o=s.Buffer.from(g),n=Uint8Array.from(s.Buffer.concat([o,e,s.Buffer.alloc(8)])),d=(0,p.toHex)(n);return(0,c.AccountId)(63).dec(d)};static fromAccount=r=>{let e=(0,c.AccountId)().enc(r),o=s.Buffer.from(g),n=e.slice(o.length,-8);return"0x"+s.Buffer.from(n).toString("hex")};static fromSS58=r=>{let o=(0,c.AccountId)().enc(r).slice(0,20);return(0,p.toHex)(o)};static fromAny=r=>{if(b(r))return r;if(h(r))return t.fromAccount(r);if(E(r))return t.fromSS58(r);throw new Error("Unknown address type")}};var A={};f(A,{convertToId:()=>M});var S=require("buffer");function M(t){let e=S.Buffer.from(t.replace("0x",""),"hex").subarray(16);return e.readUIntBE(0,e.length)}var N="0.1.0";0&&(module.exports={HYDRATION_SS58_PREFIX,RUNTIME_DECIMALS,big,erc20,h160,version,xc});

package/build/index.mjs

@@ -0,0 +1 @@
+var b=Object.defineProperty;var f=(e,r)=>{for(var t in r)b(e,t,{get:r[t],enumerable:!0})};var D=18,d=63;var l={};f(l,{asBigInt:()=>v,toBigInt:()=>S,toDecimal:()=>E});import i from"big.js";i.NE=-18;function E(e,r,t=6,o){let s=i(e.toString()),u=i(10).pow(r);return s.div(u).round(t,o).toString()}function S(e,r){let t=i(10).pow(r),s=i(e).mul(t).toFixed(0,i.roundDown);return BigInt(s)}function v(e){return BigInt(e.round(0,i.roundDown).toFixed(0))}var p={};f(p,{ERC20:()=>a});var a=class{static fromAssetId(r){let t=Buffer.alloc(20,0);return t[15]=1,t.writeUInt32BE(r,16),"0x"+t.toString("hex")}static toAssetId(r){let t=Buffer.from(r.replace("0x",""),"hex");return t.length!==20||!this.isAssetAddress(r)?null:t.readUInt32BE(16)}static isAssetAddress(r){let t=Buffer.from("0000000000000000000000000000000100000000","hex"),o=Buffer.from(r.replace("0x",""),"hex");return o.length!==20?!1:o.subarray(0,16).equals(t.subarray(0,16))}};var I={};f(I,{H160:()=>x,isEvmAccount:()=>B,isEvmAddress:()=>y,isSs58Address:()=>A});import{AccountId as c}from"polkadot-api";import{toHex as g}from"@polkadot-api/utils";import{Buffer as n}from"buffer";var m="ETH\0";function B(e){if(!e)return!1;try{let r=c().enc(e),t=n.from(m);return n.from(r.subarray(0,t.length)).equals(t)}catch{return!1}}function y(e){return!!/^0x[a-fA-F0-9]{40}$/.test(e)}function A(e){try{return c(63).enc(e),!0}catch{return!1}}var x=class e{static toAccount=r=>{let t=n.from(r.slice(2),"hex"),o=n.from(m),s=Uint8Array.from(n.concat([o,t,n.alloc(8)])),u=g(s);return c(63).dec(u)};static fromAccount=r=>{let t=c().enc(r),o=n.from(m),s=t.slice(o.length,-8);return"0x"+n.from(s).toString("hex")};static fromSS58=r=>{let o=c().enc(r).slice(0,20);return g(o)};static fromAny=r=>{if(y(r))return r;if(B(r))return e.fromAccount(r);if(A(r))return e.fromSS58(r);throw new Error("Unknown address type")}};var h={};f(h,{convertToId:()=>R});import{Buffer as F}from"buffer";function R(e){let t=F.from(e.replace("0x",""),"hex").subarray(16);return t.readUIntBE(0,t.length)}var Y="0.1.0";export{d as HYDRATION_SS58_PREFIX,D as RUNTIME_DECIMALS,l as big,p as erc20,I as h160,Y as version,h as xc};

package/build/types/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const RUNTIME_DECIMALS = 18;
+export declare const HYDRATION_SS58_PREFIX = 63;

package/build/types/index.d.ts

@@ -0,0 +1,3 @@
+export declare const version = "0.1.0";
+export * from './consts';
+export * from './utils';

package/build/types/utils/big.d.ts

@@ -0,0 +1,4 @@
+import Big, { RoundingMode } from 'big.js';
+export declare function toDecimal(amount: bigint, decimals: number, maxDecimal?: number, roundType?: RoundingMode): string;
+export declare function toBigInt(amount: string | number, decimals: number): bigint;
+export declare function asBigInt(value: Big): bigint;

package/build/types/utils/erc20.d.ts

@@ -0,0 +1,5 @@
+export declare class ERC20 {
+    static fromAssetId(assetId: number): string;
+    static toAssetId(address: string): number | null;
+    static isAssetAddress(address: string): boolean;
+}

package/build/types/utils/h160.d.ts

@@ -0,0 +1,9 @@
+export declare function isEvmAccount(ss58addr: string): boolean;
+export declare function isEvmAddress(address: string): boolean;
+export declare function isSs58Address(address: string): boolean;
+export declare class H160 {
+    static toAccount: (address: string) => import("polkadot-api").SS58String;
+    static fromAccount: (address: string) => string;
+    static fromSS58: (address: string) => string;
+    static fromAny: (address: string) => string;
+}

package/build/types/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * as big from './big';
+export * as erc20 from './erc20';
+export * as h160 from './h160';
+export * as xc from './xc';

package/build/types/utils/xc.d.ts

@@ -0,0 +1 @@
+export declare function convertToId(xcAddress: string): number;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@galacticcouncil/common",
+  "version": "0.1.0",
+  "description": "Common utilities shared across Galactic SDK packages",
+  "author": "GalacticCouncil",
+  "repository": {
+    "directory": "packages/common",
+    "type": "git",
+    "url": "git+https://github.com/galacticcouncil/sdk.git"
+  },
+  "keywords": [
+    "hydration",
+    "utilities",
+    "common"
+  ],
+  "bugs": {
+    "url": "https://github.com/galacticcouncil/sdk/issues"
+  },
+  "files": [
+    "build",
+    "src"
+  ],
+  "main": "./build/index.cjs",
+  "module": "./build/index.mjs",
+  "types": "./build/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/types/index.d.ts",
+      "import": "./build/index.mjs",
+      "require": "./build/index.cjs",
+      "default": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && node ./esbuild.dist.mjs",
+    "build:watch": "node ./esbuild.dev.mjs",
+    "postbuild": "tsc --emitDeclarationOnly --outDir build/types/",
+    "clean": "rimraf build",
+    "link": "npm ln",
+    "test": "NODE_NO_WARNINGS=1 NODE_OPTIONS=--experimental-vm-modules jest"
+  },
+  "dependencies": {
+    "big.js": "^6.2.1"
+  },
+  "devDependencies": {
+    "@types/big.js": "^6.2.2"
+  },
+  "peerDependencies": {
+    "polkadot-api": "^1.20.0"
+  }
+}

package/src/consts.ts

@@ -0,0 +1,5 @@
+// Runtime
+export const RUNTIME_DECIMALS = 18;
+
+// Chain
+export const HYDRATION_SS58_PREFIX = 63;

package/src/index.ts

@@ -0,0 +1,8 @@
+// Common utilities shared across Galactic SDK packages
+export const version = '0.1.0';
+
+// Constants
+export * from './consts';
+
+// Utilities
+export * from './utils';

package/src/utils/big.spec.ts

@@ -0,0 +1,73 @@
+import Big from 'big.js';
+import { toBigInt, toDecimal } from './big';
+
+describe('Big utils', () => {
+  describe('toDecimals', () => {
+    it('should convert to decimals with 18 decimals', () => {
+      expect(toDecimal(1_678_578_001_143_648_100n, 18)).toBe('1.678578');
+      expect(toDecimal(4_778_448_942_696_649_000n, 18, 0)).toBe('5');
+      expect(toDecimal(9_277_414_529_928_219_000n, 18, 1)).toBe('9.3');
+      expect(toDecimal(1_489_926_767_190_488_000n, 18, 2)).toBe('1.49');
+      expect(toDecimal(7_111_587_933_365_016_000n, 18, 3)).toBe('7.112');
+      expect(toDecimal(7_111_587_933_365_016_000n, 18, 18)).toBe(
+        '7.111587933365016'
+      );
+      expect(toDecimal(4756503344577211177520n, 18, 18)).toBe(
+        '4756.50334457721117752'
+      );
+      expect(toDecimal(198_000_012_317_550_812n, 18, 18)).toBe(
+        '0.198000012317550812'
+      );
+    });
+
+    it('should convert to decimals with 12 decimals', () => {
+      expect(toDecimal(52_912_391_280_480n, 12)).toBe('52.912391');
+      expect(toDecimal(796_301_020_21449n, 12, 0)).toBe('80');
+      expect(toDecimal(370_024_965_982_774n, 12, 1)).toBe('370');
+      expect(toDecimal(776_879_141_948n, 12, 2)).toBe('0.78');
+      expect(toDecimal(372_209_875_392n, 12, 3)).toBe('0.372');
+      expect(toDecimal(372_209_875_392n, 12, 12)).toBe('0.372209875392');
+    });
+
+    it('should convert to decimals with the correct rounding types', () => {
+      expect(toDecimal(370_024_965_982_774n, 12, 1, Big.roundDown)).toBe('370');
+    });
+  });
+
+  describe('toBigInt', () => {
+    it('should convert to BigInt', () => {
+      expect(toBigInt('1.678578', 18)).toBe(1_678_578_000_000_000_000n);
+      expect(toBigInt('5', 18)).toBe(5_000_000_000_000_000_000n);
+      expect(toBigInt('9.3', 18)).toBe(9_300_000_000_000_000_000n);
+      expect(toBigInt('1.49', 18)).toBe(1_490_000_000_000_000_000n);
+      expect(toBigInt('7.112', 18)).toBe(7_112_000_000_000_000_000n);
+      expect(toBigInt('7.111587933365016', 18)).toBe(
+        7_111_587_933_365_016_000n
+      );
+    });
+
+    it('should convert to BigInt with 12 decimals', () => {
+      expect(toBigInt('52.912391', 12)).toBe(52_912_391_000_000n);
+      expect(toBigInt('80', 12)).toBe(80_000_000_000_000n);
+      expect(toBigInt('370', 12)).toBe(370_000_000_000_000n);
+      expect(toBigInt('0.78', 12)).toBe(780_000_000_000n);
+      expect(toBigInt('0.372', 12)).toBe(372_000_000_000n);
+      expect(toBigInt('0.372209875392', 12)).toBe(372_209_875_392n);
+    });
+
+    it('should convert to BigInt from number', () => {
+      expect(toBigInt(52.912391, 12)).toBe(52_912_391_000_000n);
+      expect(toBigInt(80, 12)).toBe(80_000_000_000_000n);
+      expect(toBigInt(370, 12)).toBe(370_000_000_000_000n);
+      expect(toBigInt(0.78, 12)).toBe(780_000_000_000n);
+      expect(toBigInt(0.372, 12)).toBe(372_000_000_000n);
+      expect(toBigInt(0.372209875392, 12)).toBe(372_209_875_392n);
+      expect(toBigInt('4756.50334457721117752', 18)).toBe(
+        4_756_503_344_577_211_177_520n
+      );
+      expect(toBigInt('66712.0367386073069948646', 18)).toBe(
+        66_712_036_738_607_306_994_864n
+      );
+    });
+  });
+});

package/src/utils/big.ts

@@ -0,0 +1,26 @@
+import Big, { RoundingMode } from 'big.js';
+
+Big.NE = -18;
+
+export function toDecimal(
+  amount: bigint,
+  decimals: number,
+  maxDecimal = 6,
+  roundType?: RoundingMode
+): string {
+  const dividend = Big(amount.toString());
+  const divisor = Big(10).pow(decimals);
+  const result = dividend.div(divisor).round(maxDecimal, roundType);
+  return result.toString();
+}
+
+export function toBigInt(amount: string | number, decimals: number): bigint {
+  const multiplier = Big(10).pow(decimals);
+  const result = Big(amount).mul(multiplier);
+  const fixedPoint = result.toFixed(0, Big.roundDown);
+  return BigInt(fixedPoint);
+}
+
+export function asBigInt(value: Big): bigint {
+  return BigInt(value.round(0, Big.roundDown).toFixed(0));
+}

package/src/utils/erc20.ts

@@ -0,0 +1,29 @@
+export class ERC20 {
+  static fromAssetId(assetId: number) {
+    const evmAddressBuffer = Buffer.alloc(20, 0);
+    evmAddressBuffer[15] = 1;
+    evmAddressBuffer.writeUInt32BE(assetId, 16);
+
+    return '0x' + evmAddressBuffer.toString('hex');
+  }
+
+  static toAssetId(address: string) {
+    const addressBuffer = Buffer.from(address.replace('0x', ''), 'hex');
+    if (addressBuffer.length !== 20 || !this.isAssetAddress(address)) {
+      return null;
+    }
+    return addressBuffer.readUInt32BE(16);
+  }
+
+  static isAssetAddress(address: string) {
+    const PREFIX_BUFFER = Buffer.from(
+      '0000000000000000000000000000000100000000',
+      'hex'
+    );
+    const addressBuffer = Buffer.from(address.replace('0x', ''), 'hex');
+    if (addressBuffer.length !== 20) {
+      return false;
+    }
+    return addressBuffer.subarray(0, 16).equals(PREFIX_BUFFER.subarray(0, 16));
+  }
+}

package/src/utils/h160.spec.ts

@@ -0,0 +1,39 @@
+import { H160, isEvmAddress } from './h160';
+
+const ALICE = '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY';
+const ALICE_H160 = '0xd43593c715fdd31c61141abd04a99fd6822c8558';
+
+const ALITH_H160 = '0x15fdd31c61141abd04a99fd6822c8558854ccde3';
+const ALITH_SS58 = '7KATdGaiYbPauPtFrTfRj7zMM8KHqLbkjfurUnX6F57aHHqq';
+
+describe('H160 Utils', () => {
+  it('Convert Alice (Substrate) SS85 => H160', () => {
+    const result = H160.fromSS58(ALICE);
+    expect(result).toStrictEqual(ALICE_H160);
+  });
+
+  it('Convert Alith (Evm) H160 => SS58', () => {
+    const result = H160.toAccount(ALITH_H160);
+    expect(result).toStrictEqual(ALITH_SS58);
+  });
+
+  it('Convert Alith (Evm) SS58 => H160', () => {
+    const result = H160.fromAccount(ALITH_SS58);
+    expect(result).toStrictEqual(ALITH_H160);
+  });
+
+  it('is ALICE_H160 valid h160', () => {
+    const result = isEvmAddress(ALICE_H160);
+    expect(result).toStrictEqual(true);
+  });
+
+  it('is ALITH_H160 valid h160', () => {
+    const result = isEvmAddress(ALITH_H160);
+    expect(result).toStrictEqual(true);
+  });
+
+  it('is ALITH_SS58 not valid h160', () => {
+    const result = isEvmAddress(ALITH_SS58);
+    expect(result).toStrictEqual(false);
+  });
+});

package/src/utils/h160.ts

@@ -0,0 +1,79 @@
+import { AccountId } from 'polkadot-api';
+import { toHex } from '@polkadot-api/utils';
+
+import { Buffer } from 'buffer';
+
+import { HYDRATION_SS58_PREFIX } from '../consts';
+
+const ETH_PREFIX = 'ETH\0';
+
+export function isEvmAccount(ss58addr: string) {
+  if (!ss58addr) return false;
+
+  try {
+    const addressBytes = AccountId().enc(ss58addr);
+    const prefixBytes = Buffer.from(ETH_PREFIX);
+    return Buffer.from(addressBytes.subarray(0, prefixBytes.length)).equals(
+      prefixBytes
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function isEvmAddress(address: string): boolean {
+  if (!/^0x[a-fA-F0-9]{40}$/.test(address)) {
+    return false;
+  }
+  return true;
+}
+
+export function isSs58Address(address: string): boolean {
+  try {
+    AccountId(HYDRATION_SS58_PREFIX).enc(address);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+export class H160 {
+  static toAccount = (address: string) => {
+    const addressBytes = Buffer.from(address.slice(2), 'hex');
+    const prefixBytes = Buffer.from(ETH_PREFIX);
+    const convertBytes = Uint8Array.from(
+      Buffer.concat([prefixBytes, addressBytes, Buffer.alloc(8)])
+    );
+    const addressHex = toHex(convertBytes);
+    return AccountId(HYDRATION_SS58_PREFIX).dec(addressHex);
+  };
+
+  static fromAccount = (address: string) => {
+    const decodedBytes = AccountId().enc(address);
+    const prefixBytes = Buffer.from(ETH_PREFIX);
+    const addressBytes = decodedBytes.slice(prefixBytes.length, -8);
+    return '0x' + Buffer.from(addressBytes).toString('hex');
+  };
+
+  static fromSS58 = (address: string) => {
+    const decodedBytes = AccountId().enc(address);
+    const slicedBytes = decodedBytes.slice(0, 20);
+    return toHex(slicedBytes);
+  };
+
+  static fromAny = (address: string) => {
+    if (isEvmAddress(address)) {
+      return address;
+    }
+
+    if (isEvmAccount(address)) {
+      return H160.fromAccount(address);
+    }
+
+    if (isSs58Address(address)) {
+      return H160.fromSS58(address);
+    }
+
+    throw new Error('Unknown address type');
+  };
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * as big from './big';
+export * as erc20 from './erc20';
+export * as h160 from './h160';
+export * as xc from './xc';

package/src/utils/xc.spec.ts

@@ -0,0 +1,8 @@
+import { convertToId } from './xc';
+
+describe('Xc Utils', () => {
+  it('Convert Xc address should result in 10', () => {
+    const result = convertToId('0x000000000000000000000000000000010000000A');
+    expect(result).toStrictEqual(10);
+  });
+});

package/src/utils/xc.ts

@@ -0,0 +1,7 @@
+import { Buffer } from 'buffer';
+
+export function convertToId(xcAddress: string): number {
+  const addressBuffer = Buffer.from(xcAddress.replace('0x', ''), 'hex');
+  const assetIdBuffer = addressBuffer.subarray(16);
+  return assetIdBuffer.readUIntBE(0, assetIdBuffer.length);
+}