feat(sdk-coin-cronos): add SDK support for Cronos

TICKET: COIN-4022

Author: baltiyal

modules/sdk-coin-cronos/package.json

@@ -43,7 +43,11 @@
     "@bitgo/abstract-cosmos": "^11.7.2",
     "@bitgo/sdk-core": "^33.1.0",
     "@bitgo/statics": "^52.1.0",
-    "@cosmjs/stargate": "^0.29.5"
+    "@cosmjs/stargate": "^0.29.5",
+    "@cosmjs/amino": "^0.29.5",
+    "@cosmjs/encoding": "^0.29.5",
+    "@cosmjs/stargate": "^0.29.5",
+    "bignumber.js": "^9.1.1"
   },
   "devDependencies": {
     "@bitgo/sdk-api": "^1.62.2",

modules/sdk-coin-cronos/src/cronos.ts

@@ -1,9 +1,19 @@
-import { BaseCoin, BitGoBase } from '@bitgo/sdk-core';
-import { BaseCoin as StaticsBaseCoin } from '@bitgo/statics';
+import { BaseCoin, BitGoBase, Environments } from '@bitgo/sdk-core';
+import { BaseUnit, BaseCoin as StaticsBaseCoin, coins } from '@bitgo/statics';
 import { CosmosCoin, CosmosKeyPair, GasAmountDetails } from '@bitgo/abstract-cosmos';
-import { TransactionBuilderFactory } from './lib';
+import { KeyPair, TransactionBuilderFactory } from './lib';
+import { GAS_AMOUNT, GAS_LIMIT } from './lib/constants';
+import { Utils } from './lib/utils';
 
+/**
+ *
+ * Full Name: Cronos
+ * Website: https://cronos-pos.org/
+ * Docs: https://docs.cronos-pos.org/
+ * GitHub : https://github.com/crypto-org-chain/chain-main
+ */
 export class Cronos extends CosmosCoin {
+  protected readonly _utils: Utils;
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
 
   protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {
@@ -14,6 +24,7 @@ export class Cronos extends CosmosCoin {
     }
 
     this._staticsCoin = staticsCoin;
+    this._utils = new Utils();
   }
 
   static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {
@@ -27,36 +38,39 @@ export class Cronos extends CosmosCoin {
 
   /** @inheritDoc **/
   getBuilder(): TransactionBuilderFactory {
-    throw new Error('Method not implemented.');
+    return new TransactionBuilderFactory(coins.get(this.getChain()));
   }
 
   /** @inheritDoc **/
   isValidAddress(address: string): boolean {
-    throw new Error('Method not implemented.');
+    return this._utils.isValidAddress(address) || this._utils.isValidValidatorAddress(address);
   }
 
   /** @inheritDoc **/
   getDenomination(): string {
-    throw new Error('Method not implemented');
+    return BaseUnit.CRONOS;
   }
 
   /** @inheritDoc **/
   getGasAmountDetails(): GasAmountDetails {
-    throw new Error('Method not implemented');
+    return {
+      gasAmount: GAS_AMOUNT,
+      gasLimit: GAS_LIMIT,
+    };
   }
 
   /** @inheritDoc **/
   getKeyPair(publicKey: string): CosmosKeyPair {
-    throw new Error('Method not implemented');
+    return new KeyPair({ pub: publicKey });
   }
 
   /** @inheritDoc **/
   protected getPublicNodeUrl(): string {
-    throw new Error('Method not implemented');
+    return Environments[this.bitgo.getEnv()].cronosNodeUrl;
   }
 
   /** @inheritDoc **/
   getAddressFromPublicKey(pubKey: string): string {
-    throw new Error('Method not implemented');
+    return new KeyPair({ pub: pubKey }).getAddress();
   }
 }

modules/sdk-coin-cronos/src/lib/constants.ts

@@ -0,0 +1,14 @@
+export const validDenoms = ['cro', 'tcro', 'basecro', 'basetcro'];
+
+export const mainnetAccountAddressRegex = /^(cro)1(['qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38})$/;
+export const mainnetValidatorAddressRegex = /^(crocncl)1(['qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38})$/;
+export const mainnetContractAddressRegex = /^(cro)1(['qpzry9x8gf2tvdw0s3jn54khce6mua7l]+)$/;
+export const MAINNET_ADDRESS_PREFIX = 'cro';
+
+export const testnetAccountAddressRegex = /^(tcro)1(['qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38})$/;
+export const testnetValidatorAddressRegex = /^(tcrocncl)1(['qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38})$/;
+export const testnetContractAddressRegex = /^(tcro)1(['qpzry9x8gf2tvdw0s3jn54khce6mua7l]+)$/;
+export const TESTNET_ADDRESS_PREFIX = 'tcro';
+
+export const GAS_AMOUNT = '30000';
+export const GAS_LIMIT = 500000;

modules/sdk-coin-cronos/src/lib/keyPair.ts

@@ -1,5 +1,8 @@
-import { KeyPairOptions } from '@bitgo/sdk-core';
+import { AddressFormat, KeyPairOptions } from '@bitgo/sdk-core';
+import { pubkeyToAddress } from '@cosmjs/amino';
+
 import { CosmosKeyPair } from '@bitgo/abstract-cosmos';
+import { MAINNET_ADDRESS_PREFIX, TESTNET_ADDRESS_PREFIX } from './constants';
 
 /**
  * Cronos keys and address management.
@@ -10,7 +13,15 @@ export class KeyPair extends CosmosKeyPair {
   }
 
   /** @inheritdoc */
-  getAddress(): string {
-    throw new Error('Method not implemented.');
+  getAddress(format: AddressFormat = AddressFormat.mainnet): string {
+    const base64String = Buffer.from(this.getKeys().pub.slice(0, 66), 'hex').toString('base64');
+    const address_prefix = format === AddressFormat.testnet ? TESTNET_ADDRESS_PREFIX : MAINNET_ADDRESS_PREFIX;
+    return pubkeyToAddress(
+      {
+        type: 'tendermint/PubKeySecp256k1',
+        value: base64String,
+      },
+      address_prefix
+    );
   }
 }

modules/sdk-coin-cronos/src/lib/transactionBuilderFactory.ts

@@ -10,7 +10,7 @@ import {
 } from '@bitgo/abstract-cosmos';
 import { BaseTransactionBuilderFactory, InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import utils from './utils';
+import { Utils } from './utils';
 
 export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
   constructor(_coinConfig: Readonly<CoinConfig>) {
@@ -19,7 +19,7 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
 
   /** @inheritdoc */
   from(raw: string): CosmosTransactionBuilder {
-    const tx = new CosmosTransaction(this._coinConfig, utils);
+    const tx = new CosmosTransaction(this._coinConfig, new Utils(this._coinConfig.network.type));
     tx.enrichTransactionDetailsFromRawTransaction(raw);
     try {
       switch (tx.type) {
@@ -45,27 +45,45 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
 
   /** @inheritdoc */
   getTransferBuilder(tx?: CosmosTransaction): CosmosTransferBuilder {
-    return this.initializeBuilder(tx, new CosmosTransferBuilder(this._coinConfig, utils));
+    return this.initializeBuilder(
+      tx,
+      new CosmosTransferBuilder(this._coinConfig, new Utils(this._coinConfig.network.type))
+    );
   }
   /** @inheritdoc */
   getStakingActivateBuilder(tx?: CosmosTransaction): StakingActivateBuilder {
-    return this.initializeBuilder(tx, new StakingActivateBuilder(this._coinConfig, utils));
+    return this.initializeBuilder(
+      tx,
+      new StakingActivateBuilder(this._coinConfig, new Utils(this._coinConfig.network.type))
+    );
   }
   /** @inheritdoc */
   getStakingDeactivateBuilder(tx?: CosmosTransaction): StakingDeactivateBuilder {
-    return this.initializeBuilder(tx, new StakingDeactivateBuilder(this._coinConfig, utils));
+    return this.initializeBuilder(
+      tx,
+      new StakingDeactivateBuilder(this._coinConfig, new Utils(this._coinConfig.network.type))
+    );
   }
   /** @inheritdoc */
   getStakingWithdrawRewardsBuilder(tx?: CosmosTransaction): StakingWithdrawRewardsBuilder {
-    return this.initializeBuilder(tx, new StakingWithdrawRewardsBuilder(this._coinConfig, utils));
+    return this.initializeBuilder(
+      tx,
+      new StakingWithdrawRewardsBuilder(this._coinConfig, new Utils(this._coinConfig.network.type))
+    );
   }
 
   getContractCallBuilder(tx?: CosmosTransaction): ContractCallBuilder {
-    return this.initializeBuilder(tx, new ContractCallBuilder(this._coinConfig, utils));
+    return this.initializeBuilder(
+      tx,
+      new ContractCallBuilder(this._coinConfig, new Utils(this._coinConfig.network.type))
+    );
   }
 
   getStakingRedelegateBuilder(tx?: CosmosTransaction): StakingRedelegateBuilder {
-    return this.initializeBuilder(tx, new StakingRedelegateBuilder(this._coinConfig, utils));
+    return this.initializeBuilder(
+      tx,
+      new StakingRedelegateBuilder(this._coinConfig, new Utils(this._coinConfig.network.type))
+    );
   }
 
   /** @inheritdoc */

modules/sdk-coin-cronos/src/lib/utils.ts

@@ -1,25 +1,50 @@
 import { CosmosUtils } from '@bitgo/abstract-cosmos';
+import { InvalidTransactionError } from '@bitgo/sdk-core';
 import { Coin } from '@cosmjs/stargate';
+import BigNumber from 'bignumber.js';
+import * as constants from './constants';
+import { NetworkType } from '@bitgo/statics';
 
 export class Utils extends CosmosUtils {
+  private networkType: NetworkType;
+  constructor(networkType: NetworkType = NetworkType.MAINNET) {
+    super();
+    this.networkType = networkType;
+  }
+
   /** @inheritdoc */
   isValidAddress(address: string): boolean {
-    throw new Error('Method not implemented.');
+    if (this.networkType === NetworkType.TESTNET) {
+      return this.isValidCosmosLikeAddressWithMemoId(address, constants.testnetAccountAddressRegex);
+    }
+    return this.isValidCosmosLikeAddressWithMemoId(address, constants.mainnetAccountAddressRegex);
   }
 
   /** @inheritdoc */
   isValidValidatorAddress(address: string): boolean {
-    throw new Error('Method not implemented.');
+    if (this.networkType === NetworkType.TESTNET) {
+      return this.isValidBech32AddressMatchingRegex(address, constants.testnetValidatorAddressRegex);
+    }
+    return this.isValidBech32AddressMatchingRegex(address, constants.mainnetValidatorAddressRegex);
   }
 
   /** @inheritdoc */
   isValidContractAddress(address: string): boolean {
-    throw new Error('Method not implemented.');
+    if (this.networkType === NetworkType.TESTNET) {
+      return this.isValidBech32AddressMatchingRegex(address, constants.testnetContractAddressRegex);
+    }
+    return this.isValidBech32AddressMatchingRegex(address, constants.mainnetContractAddressRegex);
   }
 
   /** @inheritdoc */
   validateAmount(amount: Coin): void {
-    throw new Error('Method not implemented.');
+    const amountBig = BigNumber(amount.amount);
+    if (amountBig.isLessThanOrEqualTo(0)) {
+      throw new InvalidTransactionError('transactionBuilder: validateAmount: Invalid amount: ' + amount.amount);
+    }
+    if (!constants.validDenoms.find((denom) => denom === amount.denom)) {
+      throw new InvalidTransactionError('transactionBuilder: validateAmount: Invalid denom: ' + amount.denom);
+    }
   }
 }
 

modules/sdk-coin-cronos/src/tcronos.ts

@@ -1,8 +1,11 @@
-import { BaseCoin, BitGoBase } from '@bitgo/sdk-core';
-import { BaseCoin as StaticsBaseCoin } from '@bitgo/statics';
+import { AddressFormat, BaseCoin, BitGoBase } from '@bitgo/sdk-core';
+import { BaseCoin as StaticsBaseCoin, NetworkType } from '@bitgo/statics';
 import { Cronos } from './cronos';
+import { Utils } from './lib/utils';
+import { KeyPair } from './lib/keyPair';
 
 export class Tcronos extends Cronos {
+  protected readonly _utils: Utils;
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
   protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {
     super(bitgo, staticsCoin);
@@ -12,9 +15,15 @@ export class Tcronos extends Cronos {
     }
 
     this._staticsCoin = staticsCoin;
+    this._utils = new Utils(NetworkType.TESTNET);
   }
 
   static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {
     return new Tcronos(bitgo, staticsCoin);
   }
+
+  /** @inheritDoc **/
+  getAddressFromPublicKey(publicKey: string): string {
+    return new KeyPair({ pub: publicKey }).getAddress(AddressFormat.testnet);
+  }
 }