Add Ergo chain & Spectrum connector

package.json

@@ -38,6 +38,8 @@
     "@ethersproject/networks": "5.7.0",
     "@ethersproject/providers": "5.7.0",
     "@ethersproject/solidity": "5.7.0",
+    "@fleet-sdk/common": "^0.3.4",
+    "@fleet-sdk/core": "^0.5.0",
     "@harmony-js/core": "^0.1.57",
     "@harmony-js/utils": "^0.1.56",
     "@improbable-eng/grpc-web": "^0.13.0",
@@ -51,6 +53,9 @@
     "@pancakeswap/v3-periphery": "^1.0.2",
     "@pancakeswap/v3-sdk": "^3.7.0",
     "@pangolindex/sdk": "^1.1.0",
+    "@patternglobal/ergo-dex-sdk": "^1.0.1",
+    "@patternglobal/ergo-sdk": "^1.0.0",
+    "@perp/sdk-curie": "^1.16.0",
     "@sushiswap/sdk": "^5.0.0-canary.116",
     "@taquito/rpc": "^17.0.0",
     "@taquito/signer": "^17.0.0",
@@ -80,6 +85,7 @@
     "coinalpha-ref-sdk": "1.1.0",
     "dayjs": "^1.10.6",
     "decimal.js-light": "^2.5.1",
+    "ergo-lib-wasm-nodejs": "^0.22.0",
     "ethers": "^5.6.2",
     "ethers-xdc": "file:./vendor/ethers-xdc",
     "express": "^4.17.1",
@@ -167,4 +173,4 @@
   "resolutions": {
     "web3-utils": "1.7.3"
   }
-}
+}

src/amm/amm.controllers.ts

@@ -55,21 +55,24 @@ import { Tinyman } from '../connectors/tinyman/tinyman';
 import { Plenty } from '../connectors/plenty/plenty';
 import { Osmosis } from '../chains/osmosis/osmosis';
 import { Carbonamm } from '../connectors/carbon/carbonAMM';
+import { Spectrum } from '../connectors/spectrum/spectrum';
+import { Ergo } from '../chains/ergo/ergo';
 
 export async function price(req: PriceRequest): Promise<PriceResponse> {
   const chain = await getInitializedChain<
-    Algorand | Ethereumish | Tezosish | Osmosis
+    Algorand | Ethereumish | Tezosish | Osmosis | Ergo
   >(req.chain, req.network);
-  if (chain instanceof Osmosis){
+  if (chain instanceof Osmosis) {
     return chain.controller.price(chain as unknown as Osmosis, req);
   }
 
-  const connector: Uniswapish | Tinyman | Plenty  =
-    await getConnector<Uniswapish | Tinyman | Plenty>(
-      req.chain,
-      req.network,
-      req.connector
-    );
+  const connector:
+    | Uniswapish
+    | Tinyman
+    | Plenty
+    | Spectrum = await getConnector<
+      Uniswapish | Tinyman | Plenty | Spectrum
+    >(req.chain, req.network, req.connector);
 
   if (connector instanceof Plenty) {
     return plentyPrice(<Tezosish>chain, connector, req);
@@ -78,128 +81,147 @@ export async function price(req: PriceRequest): Promise<PriceResponse> {
   } else if ('routerAbi' in connector) {
     // we currently use the presence of routerAbi to distinguish Uniswapish from RefAMMish
     return uniswapPrice(<Ethereumish>chain, connector, req);
+  } else if (connector instanceof Spectrum) {
+    return connector.estimateTrade(req);
   } else return tinymanPrice(chain as unknown as Algorand, connector, req);
-
 }
 
 export async function trade(req: TradeRequest): Promise<TradeResponse> {
   const chain = await getInitializedChain<
-    Algorand | Ethereumish | Tezosish | Osmosis
+    Algorand | Ethereumish | Tezosish | Osmosis | Ergo
   >(req.chain, req.network);
-  if (chain instanceof Osmosis){
+  if (chain instanceof Osmosis) {
     return chain.controller.trade(chain as unknown as Osmosis, req);
   }
 
-  const connector: Uniswapish | Tinyman | Plenty =
-    await getConnector<Uniswapish | Tinyman | Plenty>(
-      req.chain,
-      req.network,
-      req.connector
-    );
+  const connector:
+    | Uniswapish
+    | Tinyman
+    | Plenty
+    | Spectrum = await getConnector<
+      Uniswapish | Tinyman | Plenty | Spectrum
+    >(req.chain, req.network, req.connector);
 
   if (connector instanceof Plenty) {
     return plentyTrade(<Tezosish>chain, connector, req);
   } else if (connector instanceof Carbonamm) {
     return carbonTrade(<Ethereumish>chain, connector, req);
   } else if ('routerAbi' in connector) {
     return uniswapTrade(<Ethereumish>chain, connector, req);
+  } else if (connector instanceof Spectrum) {
+    return connector.executeTrade(req);
   } else {
     return tinymanTrade(chain as unknown as Algorand, connector, req);
   }
 }
 
 export async function addLiquidity(
-  req: AddLiquidityRequest
+  req: AddLiquidityRequest,
 ): Promise<AddLiquidityResponse> {
-  const chain = await getInitializedChain<Ethereumish | Osmosis>(req.chain, req.network);
-  if (chain instanceof Osmosis){
+  const chain = await getInitializedChain<Ethereumish | Osmosis>(
+    req.chain,
+    req.network,
+  );
+  if (chain instanceof Osmosis) {
     return chain.controller.addLiquidity(chain as unknown as Osmosis, req);
   }
   const connector: UniswapLPish = await getConnector<UniswapLPish>(
     req.chain,
     req.network,
-    req.connector
+    req.connector,
   );
 
   return uniswapV3AddLiquidity(chain, connector, req);
 }
 
 export async function reduceLiquidity(
-  req: RemoveLiquidityRequest
+  req: RemoveLiquidityRequest,
 ): Promise<RemoveLiquidityResponse> {
-  const chain = await getInitializedChain<Ethereumish | Osmosis>(req.chain, req.network);
-  if (chain instanceof Osmosis){
+  const chain = await getInitializedChain<Ethereumish | Osmosis>(
+    req.chain,
+    req.network,
+  );
+  if (chain instanceof Osmosis) {
     return chain.controller.removeLiquidity(chain as unknown as Osmosis, req);
   }
   const connector: UniswapLPish = await getConnector<UniswapLPish>(
     req.chain,
     req.network,
-    req.connector
+    req.connector,
   );
 
   return uniswapV3RemoveLiquidity(chain, connector, req);
 }
 
 export async function collectFees(
-  req: CollectEarnedFeesRequest
+  req: CollectEarnedFeesRequest,
 ): Promise<RemoveLiquidityResponse> {
-  const chain = await getInitializedChain<Ethereumish | Osmosis>(req.chain, req.network);
-  if (chain instanceof Osmosis){
+  const chain = await getInitializedChain<Ethereumish | Osmosis>(
+    req.chain,
+    req.network,
+  );
+  if (chain instanceof Osmosis) {
     return chain.controller.collectFees(chain as unknown as Osmosis, req);
   }
   const connector: UniswapLPish = await getConnector<UniswapLPish>(
     req.chain,
     req.network,
-    req.connector
+    req.connector,
   );
   return uniswapV3CollectEarnedFees(chain, connector, req);
 }
 
 export async function positionInfo(
-  req: PositionRequest
+  req: PositionRequest,
 ): Promise<PositionResponse> {
-  const chain = await getInitializedChain<Ethereumish | Osmosis>(req.chain, req.network);
-  if (chain instanceof Osmosis){
+  const chain = await getInitializedChain<Ethereumish | Osmosis>(
+    req.chain,
+    req.network,
+  );
+  if (chain instanceof Osmosis) {
     return chain.controller.poolPositions(chain as unknown as Osmosis, req);
   }
   const connector: UniswapLPish = await getConnector<UniswapLPish>(
     req.chain,
     req.network,
-    req.connector
+    req.connector,
   );
   return uniswapV3PositionInfo(chain, connector, req);
 }
 
 export async function poolPrice(
-  req: PoolPriceRequest
+  req: PoolPriceRequest,
 ): Promise<PoolPriceResponse> {
-  const chain = await getInitializedChain<Ethereumish | Osmosis>(req.chain, req.network);
-  if (chain instanceof Osmosis){
+  const chain = await getInitializedChain<Ethereumish | Osmosis>(
+    req.chain,
+    req.network,
+  );
+  if (chain instanceof Osmosis) {
     return chain.controller.poolPrice(chain as unknown as Osmosis, req);
   }
   const connector: UniswapLPish = await getConnector<UniswapLPish>(
     req.chain,
     req.network,
-    req.connector
+    req.connector,
   );
   return uniswapV3PoolPrice(chain, connector, req);
 }
 
 export async function estimateGas(
-  req: NetworkSelectionRequest
+  req: NetworkSelectionRequest,
 ): Promise<EstimateGasResponse> {
   const chain = await getInitializedChain<
     Algorand | Ethereumish | Tezosish | Osmosis
   >(req.chain, req.network);
-  if (chain instanceof Osmosis){
+  if (chain instanceof Osmosis) {
     return chain.controller.estimateGas(chain as unknown as Osmosis);
   }
-  
+
   const connector: Uniswapish | Tinyman | Plenty =
     await getConnector<Uniswapish | Tinyman | Plenty>(
       req.chain,
       req.network,
-      req.connector
+      req.connector,
     );
 
   if (connector instanceof Plenty) {

src/amm/amm.requests.ts

@@ -1,4 +1,8 @@
-import { CoinAndSymbol, SerializableExtendedPool as CosmosSerializableExtendedPool } from '../chains/osmosis/osmosis.types';
+import {
+  CoinAndSymbol,
+  SerializableExtendedPool as CosmosSerializableExtendedPool,
+} from '../chains/osmosis/osmosis.types';
+// import { PerpPosition } from '../connectors/perp/perp';
 import {
   NetworkSelectionRequest,
   PositionInfo as LPPositionInfo,
@@ -36,7 +40,7 @@ export interface PriceResponse {
 export interface PoolPriceRequest extends NetworkSelectionRequest {
   token0: string;
   token1: string;
-  address?: string
+  address?: string;
   fee?: string;
   period?: number;
   interval?: number;
@@ -68,6 +72,7 @@ export interface TradeRequest extends NetworkSelectionRequest {
   maxPriorityFeePerGas?: string;
   allowedSlippage?: string;
   poolId?: string;
+  mnemonic?: string;
 }
 
 export interface TradeResponse {
@@ -81,8 +86,8 @@ export interface TradeResponse {
   rawAmount: string;
   finalAmountReceived_basetoken?: string; // Cosmos
   expectedIn?: string;
-  expectedOut?: string;  // Cosmos: expectedAmountReceived
-  expectedPrice?: string;  // Cosmos
+  expectedOut?: string; // Cosmos: expectedAmountReceived
+  expectedPrice?: string; // Cosmos
   price: string; // Cosmos: finalPrice
   gasPrice: number;
   gasPriceToken: string;
@@ -93,14 +98,15 @@ export interface TradeResponse {
   txHash: string | any | undefined;
 }
 
-export interface AddLiquidityRequest extends NetworkSelectionRequest { // now also cosmos add swap position OR cosmos add LP position
+export interface AddLiquidityRequest extends NetworkSelectionRequest {
+  // now also cosmos add swap position OR cosmos add LP position
   address: string;
   token0: string;
   token1: string;
   amount0: string;
   amount1: string;
   fee?: string;
-  lowerPrice?: string; // integer as string  // COSMOS - using this != undefined then call addpositionLP(), else: addposition() 
+  lowerPrice?: string; // integer as string  // COSMOS - using this != undefined then call addpositionLP(), else: addposition()
   upperPrice?: string; // integer as string
   tokenId?: number; // COSMOS: poolId - will select one for you if not provided
   nonce?: number;

src/chains/ergo/dex.service.ts

@@ -0,0 +1,42 @@
+import axios from 'axios';
+import { DEXTokensResponse } from './interfaces/dex.interface';
+
+/**
+ * This class allows you to access elements of a DEX
+ * @class
+ * @param {string} dexURL - The DEX's base URL
+ * @param {number} [timeout=5000] - Timeout
+ */
+export class DexService {
+  constructor(
+    private dexURL: string,
+    private timeout: number = 5000,
+  ) {}
+
+  private async request<ResponseBlock = any>(
+    method: 'POST' | 'GET' | 'HEAD' = 'GET',
+    url: string,
+    headers?: Record<string, string>,
+    body?: Record<string, string>,
+  ) {
+    const response = await axios<ResponseBlock>({
+      baseURL: this.dexURL,
+      url,
+      method,
+      headers: headers,
+      timeout: this.timeout,
+      ...(method === 'POST' ? { body: body } : null),
+    });
+
+    return response.data;
+  }
+
+  /**
+   *  This function allow you to get Ergo's token list from DEX
+   * @function
+   * @async
+   */
+  async getTokens() {
+    return this.request<DEXTokensResponse>('GET', '/ergo-token-list.json');
+  }
+}

src/chains/ergo/ergo.config.ts

@@ -0,0 +1,45 @@
+import { ConfigManagerV2 } from '../../services/config-manager-v2';
+import { NetworkPrefix } from 'ergo-lib-wasm-nodejs';
+import { ErgoConfig } from './interfaces/ergo.interface';
+import { ErgoNetwork } from './types/ergo.type';
+import { BigNumber } from 'bignumber.js';
+
+/**
+ *  This function return configuration for Ergo
+ * @param {string} network - mainnet or testnet
+ * @returns ErgoConfig
+ * @function
+ */
+export function getErgoConfig(network: ErgoNetwork): ErgoConfig {
+  const configManager = ConfigManagerV2.getInstance();
+
+  return {
+    network: {
+      name: network,
+      nodeURL: configManager.get(`ergo.networks.${network}.nodeURL`),
+      explorerURL: configManager.get(`ergo.networks.${network}.explorerURL`),
+      explorerDEXURL: configManager.get(
+        `ergo.networks.${network}.explorerDEXURL`,
+      ),
+      timeOut: configManager.get(`ergo.networks.${network}.timeOut`),
+      networkPrefix:
+        network === 'mainnet' ? NetworkPrefix.Mainnet : NetworkPrefix.Testnet,
+      minTxFee: configManager.get(`ergo.networks.${network}.minTxFee`),
+      maxLRUCacheInstances: configManager.get(
+        `ergo.networks.${network}.maxLRUCacheInstances`,
+      ),
+      utxosLimit: configManager.get(`ergo.networks.${network}.utxosLimit`),
+      poolLimit: configManager.get(`ergo.networks.${network}.poolLimit`),
+      defaultSlippage: configManager.get(
+        `ergo.networks.${network}.defaultSlippage`,
+      ),
+      defaultMinerFee: BigNumber(
+        configManager.get(`ergo.networks.${network}.defaultMinerFee`),
+      ),
+      minNitro: configManager.get(`ergo.networks.${network}.minNitro`),
+      minBoxValue: BigNumber(
+        configManager.get(`ergo.networks.${network}.minBoxValue`),
+      ),
+    },
+  };
+}