@dc3-network/dc3js 0.1.0 → 0.3.0

package/README.md

@@ -1 +1,19 @@
 # @dc3-network/dc3js
+
+Javascript SDK for the DC3 blockchain
+
+## Package Structure
+
+```text
+dc3js/          # main entry point
+ |- client/
+ |- config/     # import to customize chain configuration
+ |- query/      # import to access query message types and encoders
+ |- tx/         # import to access transaction message types and encoders
+```
+
+## License
+
+MIT
+
+See [LICENSE](LICENSE) file for details.

package/client/client.js

@@ -0,0 +1,62 @@
+'use strict';
+
+import {createCosmosQueryClient} from '@interchainjs/cosmos';
+import {getSigner} from 'interchainjs';
+import {valid as validWalletManager} from './walletManager.js';
+import {isArray} from 'lodash';
+import {default as tx} from '../tx/index.js';
+
+export const signingClient = async (walletManager, encoders = []) => {
+  if (!validWalletManager(walletManager)) {
+    throw new Error('Invalid wallet manager');
+  }
+
+  if (!encoders || !isArray(encoders) || encoders.length === 0) {
+    encoders = tx.encoders;
+  }
+
+  const {currentChainName, currentWalletName} = walletManager;
+
+  if (!currentChainName || !currentWalletName) {
+    throw new Error('wallet is not connected to a chain');
+  }
+
+  try {
+    const chain = walletManager.getChainByName(currentChainName);
+    const rpcEndpoint = await walletManager.getRpcEndpoint(currentWalletName, currentChainName);
+    const preferredSignType = walletManager.getPreferSignType(currentChainName);
+    const offlineSigner = (await walletManager.getOfflineSigner(currentWalletName, currentChainName));
+    const defaultSignerOptions = await walletManager.getSignerOptions(currentChainName);
+
+    const signerOptions = {
+      queryClient: await createCosmosQueryClient(rpcEndpoint),
+      addressPrefix: chain.bech32Prefix,
+      chainId: chain.chainId,
+      ...defaultSignerOptions.cosmosSignerConfig,
+    };
+
+    // prefer the sign type from the chain provider if it's set
+    if (preferredSignType && typeof preferredSignType === 'string') {
+      const signer = getSigner(offlineSigner, {
+        preferredSignType: preferredSignType,
+        signerOptions,
+      });
+
+      signer.addEncoders(encoders);
+
+      return signer;
+    }
+
+    // default to legacy 'amino' signing type
+    const signer = getSigner(offlineSigner, {
+      preferredSignType: 'amino',
+      signerOptions,
+    })
+
+    signer.addEncoders(encoders);
+
+    return signer;
+  } catch (e) {
+    throw new Error('failed to create signing client: ' + e.message);
+  }
+};

package/client/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+export * from './client.js';

package/client/walletManager.js

@@ -0,0 +1,32 @@
+'use strict';
+
+import {isFunction, isString} from 'lodash';
+import {isAsync} from '@smoxy-io/js-utils/lib';
+
+const requiredProps = {
+  // methods
+  getChainByName: isFunction,
+  getRpcEndpoint: isAsync,
+  getPreferSignType: isFunction,
+  getOfflineSigner: isAsync,
+  getSignerOptions: isAsync,
+
+  // members
+  currentChainName: isString,
+  currentWalletName: isString
+};
+
+export const valid = (walletManager) => {
+  if (!walletManager) {
+    return false;
+  }
+
+  // check for required methods/members
+  for (const member in requiredProps) {
+    if (!walletManager[member] || !requiredProps[member](walletManager[member])) {
+      return false;
+    }
+  }
+
+  return true;
+};

package/config/asset.js

@@ -0,0 +1,95 @@
+'use strict';
+
+import {isArray, isPlainObject, isString, merge} from 'lodash';
+import {plain} from '@smoxy-io/js-utils/lib';
+import {DenomUnit} from './denomUnit.js';
+
+export const assets = [dc3];
+
+export const dc3 = new  Asset({
+  base: 'udc3',
+  denomUnits: [
+    {
+      denom: 'udc3',
+      exponent: 0
+    },
+    {
+      denom: 'dc3',
+      exponent: 6
+    }
+  ],
+  description: 'The native token of the DC3 chain',
+  display: 'dc3',
+  name: 'dc3',
+  symbol: 'DC3',
+});
+
+export const tdc3 = new  Asset({
+  base: 'utdc3',
+  denomUnits: [
+    {
+      denom: 'utdc3',
+      exponent: 0
+    },
+    {
+      denom: 'tdc3',
+      exponent: 6
+    }
+  ],
+  description: 'The native token of the DC3 test chain',
+  display: 'tdc3',
+  name: 'tdc3',
+  symbol: 'tDC3',
+});
+
+const defaultOptions = {
+  base: '',
+  denomUnits: [],
+  description: '',
+  display: '',
+  name: '',
+  symbol: '',
+  typeAsset: 'sdk.coin'
+};
+
+export class Asset {
+  constructor(opts = {}) {
+    if (!isPlainObject(opts)) {
+      if (opts instanceof Asset) {
+        opts = plain(opts);
+      } else {
+        opts = {};
+      }
+    }
+
+    if (opts.denomUnits && isArray(opts.denomUnits) && opts.denomUnits.length !== 0) {
+      for (let i = 0; i < opts.denomUnits.length; i++) {
+        opts.denomUnits[i] = new DenomUnit(opts.denomUnits[i]);
+      }
+    }
+
+    merge(this, defaultOptions, opts);
+  }
+
+  hasDenom(denom) {
+    const index = this._getDenomIndex(denom);
+
+    return index !== -1;
+  }
+
+  getDenomUnit(denom) {
+    const index = this._getDenomIndex(denom);
+
+    return index !== -1 ? this.denomUnits[index] : null;
+  }
+
+  _getDenomIndex(denom) {
+    if (!denom || !isString(denom) || !this.denomUnits || !isArray(this.denomUnits) || this.denomUnits.length === 0) {
+      return -1;
+    }
+
+    return this.denomUnits.findIndex((d) => {
+      return d && d.denom === denom;
+    });
+  }
+}

package/config/assetList.js

@@ -0,0 +1,80 @@
+'use strict';
+
+import {isArray, isPlainObject, isString, merge} from 'lodash';
+import {plain} from '@smoxy-io/js-utils/lib';
+import {Asset, assets as defaultAssets} from './asset.js';
+
+const defaultOptions = {
+  $schema: '../assetlist.schema.json',
+  chainName: 'dc3',
+  assets: []
+};
+
+export class AssetList {
+  constructor(opts = {}) {
+    if (!isPlainObject(opts)) {
+      if (opts instanceof AssetList) {
+        opts = plain(opts);
+      } else {
+        opts = {};
+      }
+    }
+
+    if (opts.assets && isArray(opts.assets) && opts.assets.length !== 0) {
+      for (let i = 0; i < opts.assets.length; i++) {
+        opts.assets[i] = new Asset(opts.assets[i]);
+      }
+    }
+
+    merge(this, defaultOptions, opts);
+  }
+
+  hasAsset(denom) {
+    const index = this._getAssetIndex(denom);
+
+    return index !== -1;
+  }
+
+  getAsset(denom) {
+    const index = this._getAssetIndex(denom);
+
+    return index !== -1 ? this.assets[index] : null;
+  }
+
+  _getAssetIndex(denom) {
+    if (!denom || !isString(denom) || !this.assets || !isArray(this.assets) || this.assets.length === 0) {
+      return -1;
+    }
+
+    return this.assets.findIndex((a) => {
+      return a && a instanceof Asset && a.hasDenom(denom);
+    });
+  }
+}
+
+export const newAssetList = (chainName = '', assets = []) => {
+  if (!isArray(assets)) {
+    assets = defaultAssets;
+  }
+
+  if (isArray(chainName)) {
+    // assets are passed in as the first argument instead of chainName
+    assets = chainName.slice();
+  }
+
+  if (!isString(chainName)) {
+    chainName = '';
+  }
+
+  const opts = {};
+
+  if (chainName) {
+    opts.chainName = chainName;
+  }
+
+  if (assets.length !== 0) {
+    opts.assets = assets;
+  }
+
+  return new AssetList(opts);
+};

package/config/chain.js

@@ -1,109 +1,188 @@
 'use strict';
 
 import {merge, isPlainObject} from 'lodash';
+import {plain} from '@smoxy-io/js-utils/lib';
+import {newAssetList} from './assetList.js';
+import {dc3, tdc3} from './asset.js';
 
-const defaultEndpoints = Object.freeze({
-    rpc: 'http://localhost:26657',
-    rest: 'http://localhost:1317'
-});
-
-const localConfig = Object.freeze({
-    chainId: 'local'
-});
-
-const devConfig = Object.freeze({
-    chainId: 'devnet'
-});
-
-const testConfig = Object.freeze({
-    chainId: 'testnet'
-});
-
-const prodConfig = Object.freeze({
-    chainId: 'mainnet'
-});
-
-const baseConfig = Object.freeze({
-    chainId: '',
-    chainName: 'dc3',
-    rpc: '',
-    rest: '',
-    bip44: Object.freeze({
-        coinType: 118
-    }),
-    bech32Config: Object.freeze({
-        bech32PrefixAccAddr: 'dc3',
-        bech32PrefixAccPub: 'dc3pub',
-        bech32PrefixValAddr: 'dc3valoper',
-        bech32PrefixValPub: 'dc3valoperpub',
-        bech32PrefixConsAddr: 'dc3valcons',
-        bech32PrefixConsPub: 'dc3valconspub',
-    }),
-    currencies: Object.freeze([
-        Object.freeze({
-            coinDenom: 'DC3',
-            coinMinimalDenom: 'udc3',
-            coinDecimals: 6,
-            coinGeckoId: "dc3-identity-token"
-        })
-    ]),
-    feeCurrencies: Object.freeze([
-        Object.freeze({
-            coinDenom: 'DC3',
-            coinMinimalDenom: 'udc3',
-            coinDecimals: 6,
-            coinGeckoId: "dc3-identity-token",
-            gasPriceStep: {
-                low: 0.001,
-                average: 0.0015,
-                high: 0.002
-            }
-        })
-    ]),
-    stakeCurrency: Object.freeze({
-        coinDenom: 'DC3',
-        coinMinimalDenom: 'udc3',
-        coinDecimals: 6,
-        coinGeckoId: "dc3-identity-token"
-    }),
-    features: Object.freeze([
-        "ibc-go"
-    ])
-});
+const defaultOptions = {
+  $shema: '../chain.schema.json',
+  chainName: 'dc3',
+  chainId: 'dc3-1',
+  chainType: 'cosmos',
+  prettyName: 'dc3',
+  bech32Prefix: 'dc3',
+  bech32Config: {
+    bech32PrefixAccAddr: 'dc3',
+    bech32PrefixAccPub: 'dc3pub',
+    bech32PrefixValAddr: 'dc3valoper',
+    bech32PrefixValPub: 'dc3valoperpub',
+    bech32PrefixConsAddr: 'dc3valcons',
+    bech32PrefixConsPub: 'dc3valconspub',
+  },
+  networkType: 'mainnet',
+  slip44: 118,
+  codebase: {
+    cosmosSdkVersion: '0.53',
+    ibc: {
+      type: 'go'
+    }
+  },
+  apis: {
+    rpc: [{address: 'https://chain.dc3.network:26657'}],
+    rest: [{address: 'https://chain.dc3.network'}]
+  },
+  fees: {
+    feeTokens: [
+      {
+        denom: 'udc3',
+        fixedMinGasPrice: 1,
+        lowGasPrice: 1,
+        averageGasPrice: 1,
+        highGasPrice: 1
+      }
+    ]
+  },
+  keyAlgos: ['secp256k1'],
+  status: 'upcoming'
+};
+
+export class Chain {
+  constructor(opts = {}) {
+    if (!isPlainObject(opts)) {
+      if (opts instanceof Chain) {
+        opts = plain(opts);
+      } else {
+        opts = {};
+      }
+    }
+
+    merge(this, defaultOptions, opts);
+  }
+
+  isMainnet() {
+    return this.networkType === 'mainnet';
+  }
+
+  isTestnet() {
+    return this.networkType === 'testnet';
+  }
+
+  isDevnet() {
+    return this.networkType === 'devnet';
+  }
+
+  isLocalnet() {
+    return this.networkType === 'devnet' && this.prettyName === 'dc3-local';
+  }
+
+  assetLists() {
+    if (this.networkType === 'testnet') {
+      return [newAssetList(this.chainName, [tdc3])];
+    }
+
+    return [newAssetList(this.chainName)];
+  }
+
+  signerOptions() {
+    return {
+      preferredSignType: (chain) => {
+        switch (chain) {
+          case this.chainName:
+            return 'cosmos_direct';
+        }
+
+        return 'cosmos_amino';
+      },
+      signing: (chain) => {
+        switch (chain) {
+          case this.chainName:
+            return {
+              cosmosSignerConfig: {
+                gasPrice: '1udc3',
+                broadcast: {
+                  checkTx: true,
+                  deliverTx: true,
+                  timeoutMs: 60000
+                }
+              }
+            };
+        }
+
+        return undefined;
+      }
+    };
+  }
+
+  endpointOptions() {
+    return {
+      endpoints: {
+        [this.chainName]: this.apis
+      }
+    };
+  }
+}
 
 export const ChainTypeLocal = 'local';
 export const ChainTypeDev = 'dev';
 export const ChainTypeTest = 'test';
 export const ChainTypeProd = 'prod';
 
-export const getChainConfig = (type, endpoints = defaultEndpoints) => {
-    let conf = null;
+export const getChainConfig = (type, opts = {}) => {
+    let conf = {};
 
     switch (type) {
         case ChainTypeLocal:
-            conf = localConfig;
+            conf.prettyName = 'dc3-local';
+            conf.networkType = 'devnet';
+            conf.apis = {
+              rpc: [{address: 'http://localhost:26657'}],
+              rest: [{address: 'http://localhost:1317'}]
+            };
+
             break;
+
         case ChainTypeDev:
-            conf = devConfig;
+            conf.prettyName = 'dc3-dev';
+            conf.networkType = 'devnet';
+            conf.apis = {
+              rpc: [{address: 'https://dev.chain.dc3.network:26657'}],
+              rest: [{address: 'https://dev.chain.dc3.network:1317'}]
+            };
+
             break;
+
         case ChainTypeTest:
-            conf = testConfig;
+            conf.prettyName = 'dc3-test';
+            conf.networkType = 'testnet';
+            conf.apis = {
+              rpc: [{address: 'https://test.chain.dc3.network:26657'}],
+              rest: [{address: 'https://test.chain.dc3.network:1317'}]
+            };
+
             break;
+
+        // production config is the default config
         case ChainTypeProd:
-            conf = prodConfig;
-            break;
         default:
-            return null;
+            break;
     }
 
-    if (!isPlainObject(endpoints)) {
-        endpoints = {}
-    }
+    return new Chain(merge({}, conf, opts));
+};
+
+export const getChain = (opts = {}) => {
+  return getChainConfig(ChainTypeProd, opts);
+};
 
-    const ep = merge({}, defaultEndpoints, endpoints);
+export const getTestChain = (opts = {}) => {
+  return getChainConfig(ChainTypeTest, opts);
+}
 
-    conf.rpc = ep.rpc;
-    conf.rest = ep.rest;
+export const getChainDev = (opts = {}) => {
+  return getChainConfig(ChainTypeDev, opts);
+}
 
-    return merge({}, baseConfig, conf);
+export const getChainLocal = (opts = {}) => {
+  return getChainConfig(ChainTypeLocal, opts);
 };

package/config/denomUnit.js

@@ -0,0 +1,23 @@
+'use strict';
+
+import {isPlainObject} from 'lodash';
+import {plain} from '@smoxy-io/js-utils/lib';
+
+const defaultOptions = {
+  denom: '',
+  exponent: 0
+};
+
+export class DenomUnit {
+  constructor(opts = {}) {
+    if (!isPlainObject(opts)) {
+      if (opts instanceof DenomUnit) {
+        opts = plain(opts);
+      } else {
+        opts = {};
+      }
+    }
+
+    Object.assign(this, defaultOptions, opts);
+  }
+}

package/config/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+export * from './asset.js';
+export * from './assetList.js';
+export * from './chain.js';
+export * from './denomUnit.js';

package/index.js

@@ -1,5 +1,32 @@
 'use strict';
 
-import {getChainConfig} from './config/chain';
+import * as config from './config/index.js';
+import * as tx from './tx/index.js';
+import * as query from './query/index.js';
 
-export const chainConfig = getChainConfig;
+export {name, license, repository, version} from './package.json' with {type: 'json'};
+export * from './client/index.js';
+
+export const mainnet = config.getChain();
+export const testnet = config.getTestChain();
+export const devnet = config.getChainDev();
+
+export const chains = [mainnet];
+export const testChains = [testnet];
+export const devChains = [devnet];
+
+export const assetLists = mainnet.assetLists();
+export const testAssetLists = testnet.assetLists();
+export const devAssetLists = devnet.assetLists();
+
+export const encoders = [
+  ...query.encoders,
+  ...tx.encoders
+];
+
+export const versionedEncoders = {
+  v1: [
+    ...query.v1.encoders,
+    ...tx.v1.encoders
+  ]
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dc3-network/dc3js",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "DC3 blockchain sdk",
   "main": "index.js",
   "type": "module",
@@ -20,8 +20,12 @@
   },
   "homepage": "https://github.com/dc3-network/dc3js#readme",
   "dependencies": {
+    "@dc3-network/x-job-types": "^0.1.0",
     "@dc3-network/x-node-types": "^0.2.0",
     "@dc3-network/x-org-types": "^0.1.0",
+    "@interchainjs/cosmos": "^1.19.3",
+    "@smoxy-io/js-utils": "^1.2.5",
+    "interchainjs": "^1.19.3",
     "lodash": "^4.17.23"
   },
   "publishConfig": {
@@ -29,7 +33,9 @@
   },
   "exports": {
     ".": "./index.js",
-    "./tx": "./tx/index.js",
-    "./config": "./config/chain.js"
+    "./client": "./client/index.js",
+    "./config": "./config/index.js",
+    "./query": "./query/index.js",
+    "./tx": "./tx/index.js"
   }
 }

package/query/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+import * as v1 from './v1/index.js';
+
+// export default version
+export * from './v1/index.js';
+
+// export all versions
+export {
+  v1
+};

package/query/v1/index.js

@@ -0,0 +1,41 @@
+'use strict';
+
+import {forEach} from 'lodash';
+
+// import all dc3 chain messages
+import * as nodeMsgPkg from '@dc3-network/x-node-types/v1/query';
+import * as orgMsgPkg from '@dc3-network/x-org-types/v1/query';
+import * as jobMsgPkg from '@dc3-network/x-job-types/v1/query';
+
+// export all dc3 chain messages
+export * from '@dc3-network/x-node-types/v1/query';
+export * from '@dc3-network/x-org-types/v1/query';
+export * from '@dc3-network/x-job-types/v1/query';
+
+export const encoders = [];
+
+const registerEncoders = (pkg) => {
+  if (!pkg || !pkg.protobufPackage) {
+    return;
+  }
+
+  const protoPkg = pkg.protobufPackage;
+
+  if (!protoPkg) {
+    return;
+  }
+
+  forEach(pkg, (v, k) => {
+    if (k.substring(-7) !== 'Request' && k.substring(-8) !== 'Response') {
+      return;
+    }
+
+    if (!v.typeUrl) {
+      v.typeUrl = '/' + protoPkg + '.' + k;
+    }
+
+    encoders.push(v);
+  });
+};
+
+forEach([nodeMsgPkg, orgMsgPkg, jobMsgPkg], registerEncoders);

package/tx/index.js

@@ -1,3 +1,11 @@
 'use strict';
 
-export * from './v1';
+import * as v1 from './v1/index.js';
+
+// export default version
+export * from './v1/index.js';
+
+// export all versions
+export {
+  v1
+};

package/tx/v1/index.js

@@ -5,10 +5,16 @@ import {forEach} from 'lodash';
 // import all dc3 chain messages
 import * as nodeMsgPkg from '@dc3-network/x-node-types/v1/tx';
 import * as orgMsgPkg from '@dc3-network/x-org-types/v1/tx';
+import * as jobMsgPkg from '@dc3-network/x-job-types/v1/tx';
 
-const messages = [];
+// export all dc3 chain messages
+export * from '@dc3-network/x-node-types/v1/tx';
+export * from '@dc3-network/x-org-types/v1/tx';
+export * from '@dc3-network/x-job-types/v1/tx';
 
-const registerMessages = (pkg) => {
+export const encoders = [];
+
+const registerEncoders = (pkg) => {
   if (!pkg || !pkg.protobufPackage) {
     return;
   }
@@ -20,7 +26,7 @@ const registerMessages = (pkg) => {
   }
 
   forEach(pkg, (v, k) => {
-    if (k.substring(0, 3) !== 'Msg' || k.substring(0, 10) === 'MsgService' || k.substring(0, 9) === 'MsgClient') {
+    if (k.substring(-7) !== 'Request' && k.substring(-8) !== 'Response') {
       return;
     }
 
@@ -28,12 +34,8 @@ const registerMessages = (pkg) => {
       v.typeUrl = '/' + protoPkg + '.' + k;
     }
 
-    messages.push(v);
+    encoders.push(v);
   });
 };
 
-forEach([nodeMsgPkg, orgMsgPkg], registerMessages);
-
-export const getMessages = () => {
-  return messages;
-};
+forEach([nodeMsgPkg, orgMsgPkg, jobMsgPkg], registerEncoders);