sync gateway / gateway staging -> master for Hummingbot version 1.20.0

gateway-setup.sh

@@ -56,19 +56,28 @@ copy_certs () {
   read -p "Enter path to the Hummingbot certs folder >>> " CERTS_FROM_PATH
   if [ ! -d "$CERTS_FROM_PATH" ]; then
     echo "Error: $CERTS_FROM_PATH does not exist or is not a directory"
-    exit
+    exit 1
+  fi
+
+  # Check if there are any .pem files in the source directory
+  PEM_COUNT=$(find "$CERTS_FROM_PATH" -maxdepth 1 -name "*.pem" | wc -l)
+  if [ "$PEM_COUNT" -eq 0 ]; then
+    echo "Error: No .pem files found in $CERTS_FROM_PATH"
+    exit 1
   fi
- 
+
   # Make destination folder if needed
-  mkdir $CERTS_TO_PATH
+  mkdir -p $CERTS_TO_PATH
+
   # Copy all files in the source folder to the destination folder
   cp -r $CERTS_FROM_PATH/* $CERTS_TO_PATH/
+
   # Confirm that the files were copied
   if [ $? -eq 0 ]; then
     echo "Files successfully copied from $CERTS_FROM_PATH to $CERTS_TO_PATH"
   else
     echo "Error copying files from $CERTS_FROM_PATH to $CERTS_TO_PATH"
-    exit
+    exit 1
   fi
 }
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hummingbot-gateway",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "description": "Middleware that helps Hummingbot clients access standardized DEX API endpoints on different blockchain networks",
   "main": "index.js",
   "license": "Apache-2.0",
@@ -23,8 +23,8 @@
     "test:scripts": "jest -i --verbose ./test-scripts/*.test.ts"
   },
   "dependencies": {
-    "@cosmjs/proto-signing": "^0.28.10",
-    "@cosmjs/stargate": "^0.28.13",
+    "@cosmjs/proto-signing": "^0.30.1",
+    "@cosmjs/stargate": "^0.30.1",
     "@crocswap/sdk": "^2.4.5",
     "@ethersproject/abstract-provider": "5.7.0",
     "@ethersproject/address": "5.7.0",
@@ -77,7 +77,10 @@
     "express": "^4.17.1",
     "express-winston": "^4.1.0",
     "fs-extra": "^10.0.0",
+    "http-status-codes": "2.2.0",
+    "immutable": "^4.2.4",
     "js-yaml": "^4.1.0",
+    "kujira.js": "^0.8.145",
     "level": "^8.0.0",
     "lodash": "^4.17.21",
     "lru-cache": "^7.14.1",

src/app.ts

@@ -112,7 +112,7 @@ export const startSwagger = async () => {
 
 export const startGateway = async () => {
   const port = ConfigManagerV2.getInstance().get('server.port');
-  const gateway_version="1.19.0"; // gateway version
+  const gateway_version="1.20.0"; // gateway version
   if (!ConfigManagerV2.getInstance().get('server.id')) {
     ConfigManagerV2.getInstance().set(
       'server.id',

src/chains/kujira/kujira.ts

@@ -0,0 +1,231 @@
+import { KujiraModel } from '../../connectors/kujira/kujira.model';
+import { convertToGetTokensResponse } from '../../connectors/kujira/kujira.convertors';
+import { KujiraConfig } from '../../connectors/kujira/kujira.config';
+import {
+  Address,
+  GetCurrentBlockRequest,
+  GetCurrentBlockResponse,
+  Token,
+} from '../../connectors/kujira/kujira.types';
+import { TokenInfo } from '../ethereum/ethereum-base';
+import {
+  BalanceRequest,
+  PollRequest,
+  TokensRequest,
+  TokensResponse,
+} from '../../network/network.requests';
+import { Chain, CustomTransaction } from '../../services/common-interfaces';
+import {
+  AllowancesRequest,
+  ApproveRequest,
+  CancelRequest,
+  NonceRequest,
+  NonceResponse,
+} from '../chain.requests';
+import {
+  TransferRequest,
+  TransferResponse,
+} from '../injective/injective.requests';
+import { BigNumber } from 'bignumber.js';
+
+export class Kujira {
+  chain: string = 'kujira';
+  network: string;
+  controller: Kujira = this;
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  private kujira: KujiraModel;
+  storedTokenList: any;
+
+  private static _instances: { [name: string]: Kujira };
+
+  private constructor(network: string) {
+    this.network = network;
+  }
+
+  public static getInstance(chain: string): Kujira {
+    if (Kujira._instances === undefined) {
+      Kujira._instances = {};
+    }
+
+    const key = `${chain}`;
+
+    if (!(key in Kujira._instances)) {
+      Kujira._instances[key] = new Kujira(chain);
+    }
+
+    return Kujira._instances[key];
+  }
+
+  public static getConnectedInstances(): { [key: string]: Kujira } {
+    return Kujira._instances;
+  }
+
+  async init() {
+    this.kujira = KujiraModel.getInstance(this.chain, this.network);
+    await this.kujira.init();
+  }
+
+  ready(): boolean {
+    return this.kujira ? this.kujira.isReady : false;
+  }
+
+  async getWalletPublicKey(
+    mnemonic: string,
+    accountNumber: number | undefined
+  ): Promise<Address> {
+    return await this.kujira.getWalletPublicKey({
+      mnemonic: mnemonic,
+      accountNumber: accountNumber || KujiraConfig.config.accountNumber,
+    });
+  }
+
+  async encrypt(
+    mnemonic: string,
+    accountNumber: number,
+    publicKey: string
+  ): Promise<string> {
+    return await this.kujira.encryptWallet({
+      wallet: {
+        mnemonic,
+        accountNumber,
+        publicKey,
+      },
+    });
+  }
+
+  async getTokenForSymbol(symbol: string): Promise<TokenInfo> {
+    return convertToGetTokensResponse(await this.kujira.getToken({ symbol }));
+  }
+
+  async getCurrentBlockNumber(
+    _options: GetCurrentBlockRequest
+  ): Promise<GetCurrentBlockResponse> {
+    return await this.kujira.getCurrentBlock(_options);
+  }
+
+  async balances(
+    _chain: any,
+    req: BalanceRequest
+  ): Promise<{ balances: Record<string, string> }> {
+    let balances;
+    if (req.tokenSymbols && req.tokenSymbols.length) {
+      balances = await this.kujira.getBalances({
+        ownerAddress: req.address,
+        tokenSymbols: req.tokenSymbols,
+      });
+    } else {
+      balances = await this.kujira.getAllBalances({
+        ownerAddress: req.address,
+      });
+    }
+
+    const output: Record<string, string> = {};
+
+    for (const balance of balances.tokens.values()) {
+      output[(balance.token as Token).symbol] = balance.free.toString();
+    }
+
+    return { balances: output };
+  }
+
+  async poll(_chain: Chain, req: PollRequest): Promise<any> {
+    const currentBlock = await this.kujira.getCurrentBlock({});
+
+    const transaction = await this.kujira.getTransaction({
+      hash: req.txHash,
+    });
+
+    // noinspection UnnecessaryLocalVariableJS
+    const output = {
+      currentBlock: currentBlock,
+      txHash: transaction.hash,
+      txStatus: transaction.code,
+      txBlock: transaction.blockNumber,
+      txData: transaction.data,
+      txReceipt: undefined,
+    };
+
+    return output;
+  }
+
+  async getTokens(_chain: Chain, _req: TokensRequest): Promise<TokensResponse> {
+    const tokens = await this.kujira.getAllTokens({});
+
+    const output: {
+      tokens: any[];
+    } = {
+      tokens: [],
+    };
+
+    for (const token of tokens.values()) {
+      output.tokens.push({
+        chainId: this.kujira.chain,
+        address: token.id,
+        name: token.name,
+        symbol: token.symbol,
+        decimals: token.decimals,
+      });
+    }
+
+    return output;
+  }
+
+  async nextNonce(_chain: Chain, _req: NonceRequest): Promise<NonceResponse> {
+    // Not applicable.
+
+    return {
+      nonce: undefined as unknown as number,
+    };
+  }
+
+  async nonce(_chain: Chain, _req: NonceRequest): Promise<NonceResponse> {
+    // Not applicable.
+
+    return {
+      nonce: undefined as unknown as number,
+    };
+  }
+
+  async allowances(_chain: Chain, _req: AllowancesRequest): Promise<any> {
+    // Not applicable.
+
+    return {
+      spender: undefined as unknown as string,
+      approvals: {} as Record<string, string>,
+    };
+  }
+
+  async approve(_chain: Chain, _req: ApproveRequest): Promise<any> {
+    // Not applicable.
+
+    return {
+      tokenAddress: undefined as unknown as string,
+      spender: undefined as unknown as string,
+      amount: undefined as unknown as string,
+      nonce: undefined as unknown as number,
+      approval: undefined as unknown as CustomTransaction,
+    };
+  }
+
+  async cancel(_chain: Chain, _req: CancelRequest): Promise<any> {
+    // Not applicable.
+
+    return {
+      txHash: undefined as unknown as string,
+    };
+  }
+
+  async transfer(
+    _chain: Chain,
+    req: TransferRequest
+  ): Promise<TransferResponse> {
+    return this.kujira.transferFromTo({
+      from: req.from,
+      to: req.to,
+      tokenSymbol: req.token,
+      amount: BigNumber(req.amount),
+    });
+  }
+}

src/clob/clob.validators.ts

@@ -17,6 +17,7 @@ import {
   validateAmount,
   validateSide,
 } from '../amm/amm.validators';
+import { isValidKujiraPublicKey } from '../connectors/kujira/kujira.helpers';
 
 export const invalidMarketError: string =
   'The market param is not a valid market. Market should be in {base}-{quote} format.';
@@ -95,7 +96,10 @@ export const validateWallet: Validator = mkValidator(
   'address',
   invalidWalletError,
   (val) => {
-    return typeof val === 'string' && isAddress(val.slice(0, 42));
+    return (
+      typeof val === 'string' &&
+      (isAddress(val.slice(0, 42)) || isValidKujiraPublicKey(val))
+    );
   }
 );
 

src/connectors/connectors.routes.ts

@@ -20,6 +20,7 @@ import { ConnectorsResponse } from './connectors.request';
 import { DexalotCLOBConfig } from './dexalot/dexalot.clob.config';
 import { TinymanConfig } from './tinyman/tinyman.config';
 import { PlentyConfig } from './plenty/plenty.config';
+import { KujiraConfig } from './kujira/kujira.config';
 
 export namespace ConnectorsRoutes {
   export const router = Router();
@@ -157,7 +158,17 @@ export namespace ConnectorsRoutes {
             trading_type: PlentyConfig.config.tradingTypes,
             chain_type: PlentyConfig.config.chainType,
             available_networks: PlentyConfig.config.availableNetworks,
-          }
+          },
+          {
+            name: 'kujira',
+            trading_type: KujiraConfig.config.tradingTypes,
+            chain_type: KujiraConfig.config.chainType,
+            available_networks: KujiraConfig.config.availableNetworks,
+            additional_add_wallet_prompts: {
+              accountId:
+                'Enter your kujira account number (input 0 if unsure) >>> ',
+            },
+          },
         ],
       });
     })