Bit.Country Pioneer integration with Moonbase (#39)

* initial pioneer configuration

* WIP neer config and balance interface change

* adapt neer config to interface

* add initial bit configuration

* fix and remove unnecessary test

* small adjustments and remove obsolete snapshots

* add enum constant

* add enum constant when missing

* add tokens function for each type to avoid clustering configs

* fix tests and add new

* Update packages/config/src/balance/balance.ts

Co-authored-by: Elmar Kenigs <elmar@purestake.com>

* improve typing on AssetSymbols

* implement the functionality to transfer multiple assets in Withdraw with transferMultiCurrencies from the precompiles

* update snapshot

* move precompile function call to Contract handler

* consideration of min amount of auxiliar that pays for fees

* pass origin account to sdk and do balance calculations inside

* Update packages/config/src/config/moonbase/assets/bit.ts

Co-authored-by: Elmar Kenigs <elmar@purestake.com>

* return 2 different mins from withdraw and make origin account optional

* return origin balance and not calculations for enough balance

* update simple example

* change origin account param to have no breaking changes

* go back to returning min in withdraw to avoid having breaking changes

* remove originAccount param

* update example

Co-authored-by: Elmar Kenigs <elmar@purestake.com>

Author: mmaurello

packages/config/src/balance/__snapshots__/balance.test.ts.snap

@@ -75,11 +75,39 @@ exports[`balance tokens should be correct balance config 1`] = `
 }
 `;
 
+exports[`balance tokens should be correct balance config foreignAsset 1`] = `
+{
+  "calc": [Function],
+  "function": "accounts",
+  "getParams": [Function],
+  "pallet": "tokens",
+  "path": [],
+}
+`;
+
 exports[`balance tokens should be correct params with ForeignAsset 1`] = `
 [
   "<ACCOUNT>",
   {
-    "ForeignAsset": 5,
+    "ForeignAsset": 0,
+  },
+]
+`;
+
+exports[`balance tokens should be correct params with FungibleToken 1`] = `
+[
+  "<ACCOUNT>",
+  {
+    "FungibleToken": 0,
+  },
+]
+`;
+
+exports[`balance tokens should be correct params with MiningResource 1`] = `
+[
+  "<ACCOUNT>",
+  {
+    "MiningResource": 0,
   },
 ]
 `;

packages/config/src/balance/balance.constants.ts

@@ -13,3 +13,12 @@ export enum BalanceFunction {
   AssetMetadatas = 'assetMetadatas',
   CurrencyMetadatas = 'currencyMetadatas',
 }
+
+export enum BalanceCurrencyTypes {
+  Token = 'Token',
+  Token2 = 'Token2',
+  ForeignAsset = 'ForeignAsset',
+  NativeToken = 'NativeToken',
+  MiningResource = 'MiningResource',
+  FungibleToken = 'FungibleToken',
+}

packages/config/src/balance/balance.interfaces.ts

@@ -2,7 +2,11 @@ import { u128 } from '@polkadot/types';
 import { PalletBalancesAccountData } from '@polkadot/types/lookup';
 import { AssetSymbol } from '../constants';
 import { AssetId } from '../interfaces';
-import { BalanceFunction, BalancePallet } from './balance.constants';
+import {
+  BalanceCurrencyTypes,
+  BalanceFunction,
+  BalancePallet,
+} from './balance.constants';
 
 export type BalanceConfig<Symbols extends AssetSymbol = AssetSymbol> =
   | SystemBalanceConfig
@@ -46,19 +50,20 @@ export interface TokensBalanceConfig<
   pallet: BalancePallet.Tokens;
   function: BalanceFunction.Accounts;
   path: [];
-  getParams: (account: string) => [
-    string,
-    (
-      | {
-          Token: Symbols | 'MOVR' | 'KUSD';
-        }
-      | { ForeignAsset: AssetId }
-      | { Token2: AssetId }
-    ),
-  ];
+  getParams: (account: string) => [string, TokensBalanceParamAsset<Symbols>];
   calc: (data: TokensPalletAccountData) => bigint;
 }
 
+export type TokensBalanceParamAsset<Symbols extends AssetSymbol = AssetSymbol> =
+
+    | {
+        [BalanceCurrencyTypes.Token]: Symbols | AssetSymbol.KUSD;
+      }
+    | { [BalanceCurrencyTypes.ForeignAsset]: AssetId }
+    | { [BalanceCurrencyTypes.MiningResource]: AssetId }
+    | { [BalanceCurrencyTypes.FungibleToken]: AssetId }
+    | { [BalanceCurrencyTypes.Token2]: AssetId };
+
 export type MinBalanceConfig =
   | MinBalanceAssetsConfig
   | MinBalanceAssetRegistryConfig;

packages/config/src/balance/balance.test.ts

@@ -1,3 +1,4 @@
+import { AssetSymbol } from '../constants';
 import { createBalanceBuilder } from './balance';
 
 describe('balance', () => {
@@ -39,7 +40,7 @@ describe('balance', () => {
   });
 
   describe('tokens', () => {
-    const cfg = balance.tokens('MOVR');
+    const cfg = balance.tokens().token(AssetSymbol.MOVR);
 
     it('should be correct balance config', () => {
       expect(cfg).toMatchSnapshot();
@@ -49,16 +50,32 @@ describe('balance', () => {
       expect(cfg.getParams(account)).toMatchSnapshot();
     });
 
-    it('should be correct params with ForeignAsset', () => {
-      const cfg2 = balance.tokens(5);
+    const cfg2 = balance.tokens().foreignAsset(0);
+
+    it('should be correct balance config foreignAsset', () => {
+      expect(cfg2).toMatchSnapshot();
+    });
 
+    it('should be correct params with ForeignAsset', () => {
       expect(cfg2.getParams(account)).toMatchSnapshot();
     });
 
+    const cfg3 = balance.tokens().miningResource(0);
+
+    it('should be correct params with MiningResource', () => {
+      expect(cfg3.getParams(account)).toMatchSnapshot();
+    });
+
+    const cfg4 = balance.tokens().fungibleToken(0);
+
+    it('should be correct params with FungibleToken', () => {
+      expect(cfg4.getParams(account)).toMatchSnapshot();
+    });
+
     it('should be correct params with Token2', () => {
-      const cfg2 = balance.tokens2(1);
+      const cfg5 = balance.tokens().token2(1);
 
-      expect(cfg2.getParams(account)).toMatchSnapshot();
+      expect(cfg5.getParams(account)).toMatchSnapshot();
     });
   });
 });

packages/config/src/balance/balance.ts

@@ -4,14 +4,19 @@ import { u128 } from '@polkadot/types';
 import { PalletBalancesAccountData } from '@polkadot/types/lookup';
 import { AssetSymbol } from '../constants';
 import { AssetId } from '../interfaces';
-import { BalanceFunction, BalancePallet } from './balance.constants';
+import {
+  BalanceCurrencyTypes,
+  BalanceFunction,
+  BalancePallet,
+} from './balance.constants';
 import {
   AssetsBalanceConfig,
   MinBalanceAssetRegistryConfig,
   MinBalanceAssetsConfig,
   OrmlTokensBalanceConfig,
   SystemBalanceConfig,
   TokensBalanceConfig,
+  TokensBalanceParamAsset,
   TokensPalletAccountData,
 } from './balance.interfaces';
 
@@ -26,9 +31,7 @@ export function createBalanceBuilder<
     minCurrencyMetadata,
     ormlTokens,
     system,
-    tokens: (asset: number | bigint | Symbols | 'MOVR' | 'KUSD' | 'AUSD') =>
-      tokens<Symbols>(asset),
-    tokens2: (asset: AssetId) => tokens2<Symbols>(asset),
+    tokens: () => tokens<Symbols>(),
   };
 }
 
@@ -91,35 +94,30 @@ function system(): SystemBalanceConfig {
   };
 }
 
-function calcTokensBalance({ free, frozen }: TokensPalletAccountData): bigint {
-  return BigInt(free.sub(frozen).toString());
-}
-
-function tokens<Symbols extends AssetSymbol = AssetSymbol>(
-  asset: number | bigint | Symbols | 'MOVR' | 'KUSD' | 'AUSD',
-): TokensBalanceConfig<Symbols> {
+function tokens<Symbols extends AssetSymbol = AssetSymbol>() {
   return {
-    pallet: BalancePallet.Tokens,
-    function: BalanceFunction.Accounts,
-    path: [],
-    getParams: (account: string) => [
-      account,
-      Number.isInteger(asset)
-        ? { ForeignAsset: asset as number }
-        : { Token: asset as Symbols },
-    ],
-    calc: calcTokensBalance,
+    foreignAsset: (asset: AssetId | Symbols) =>
+      tokensBase<Symbols>({ [BalanceCurrencyTypes.ForeignAsset]: asset }),
+    fungibleToken: (asset: AssetId) =>
+      tokensBase<Symbols>({ [BalanceCurrencyTypes.FungibleToken]: asset }),
+    miningResource: (asset: AssetId) =>
+      tokensBase<Symbols>({ [BalanceCurrencyTypes.MiningResource]: asset }),
+    token: (asset: Symbols | AssetSymbol.KUSD) =>
+      tokensBase<Symbols>({ [BalanceCurrencyTypes.Token]: asset }),
+    token2: (asset: AssetId) =>
+      tokensBase<Symbols>({ [BalanceCurrencyTypes.Token2]: asset }),
   };
 }
 
-function tokens2<Symbols extends AssetSymbol = AssetSymbol>(
-  asset: AssetId,
+function tokensBase<Symbols extends AssetSymbol = AssetSymbol>(
+  asset: TokensBalanceParamAsset<Symbols>,
 ): TokensBalanceConfig<Symbols> {
   return {
     pallet: BalancePallet.Tokens,
     function: BalanceFunction.Accounts,
     path: [],
-    getParams: (account: string) => [account, { Token2: asset }],
-    calc: calcTokensBalance,
+    getParams: (account: string) => [account, asset],
+    calc: ({ free, frozen }: TokensPalletAccountData) =>
+      BigInt(free.sub(frozen).toString()),
   };
 }

packages/config/src/config/moonbase/assets/bit.ts

@@ -0,0 +1,66 @@
+import { AssetSymbol, ChainKey } from '../../../constants';
+import {
+  XTokensExtrinsicCurrencyTypes,
+  XTokensExtrinsicSuccessEvent,
+} from '../../../extrinsic';
+import { WithdrawConfig } from '../../../withdraw';
+import {
+  assets,
+  balance,
+  chains,
+  extrinsic,
+  withdraw,
+} from '../moonbase.common';
+import { MoonbaseXcmConfig } from '../moonbase.interfaces';
+import { NEER } from './neer';
+
+const asset = assets[AssetSymbol.BIT];
+const feeAsset = assets[AssetSymbol.NEER];
+const origin = chains[ChainKey.BitCountryPioneer];
+const neerWithdrawConfig = NEER.withdraw[
+  origin.key
+] as WithdrawConfig<AssetSymbol.NEER>;
+
+export const BIT: MoonbaseXcmConfig = {
+  asset,
+  origin,
+  deposit: {
+    [origin.key]: {
+      source: origin,
+      balance: balance.tokens().miningResource(0),
+      sourceFeeBalance: balance.system(),
+      xcmFeeAsset: {
+        asset: feeAsset,
+        balance: balance.system(),
+      },
+      extrinsic: extrinsic
+        .xTokens()
+        .transferMultiCurrencies()
+        .successEvent(XTokensExtrinsicSuccessEvent.TransferredMultiAssets)
+        .origin(origin)
+        .assets(
+          {
+            [XTokensExtrinsicCurrencyTypes.MiningResource]: 0,
+          },
+          {
+            [XTokensExtrinsicCurrencyTypes.NativeToken]: 0,
+          },
+        ),
+    },
+  },
+  withdraw: {
+    [origin.key]: withdraw.xTokens({
+      balance: balance.tokens().miningResource(0),
+      destination: origin,
+      feePerWeight: neerWithdrawConfig.feePerWeight,
+      weight: neerWithdrawConfig.weight,
+      xcmFeeAsset: {
+        asset: feeAsset,
+        balance: {
+          destination: balance.system(),
+          origin: balance.assets(feeAsset.id),
+        },
+      },
+    }),
+  },
+};

packages/config/src/config/moonbase/assets/dev.ts

@@ -16,8 +16,10 @@ import { MoonbaseXcmConfig } from '../moonbase.interfaces';
 
 const asset = assets[AssetSymbol.DEV];
 const clover = chains[ChainKey.CloverAlphanet];
+const pioneer = chains[ChainKey.BitCountryPioneer];
 
 const cloverDevId = getMoonAssetId(clover);
+const pioneerDevId = getMoonAssetId(pioneer);
 
 export const DEV: MoonbaseXcmConfig = {
   asset,
@@ -36,12 +38,28 @@ export const DEV: MoonbaseXcmConfig = {
           [XTokensExtrinsicCurrencyTypes.OtherReserve]: cloverDevId,
         }),
     },
+    [pioneer.key]: {
+      source: pioneer,
+      balance: balance.tokens().fungibleToken(pioneerDevId),
+      sourceFeeBalance: balance.system(),
+      extrinsic: extrinsic
+        .xTokens()
+        .transfer()
+        .successEvent(XTokensExtrinsicSuccessEvent.TransferredMultiAssets)
+        .origin(pioneer)
+        .asset({ [XTokensExtrinsicCurrencyTypes.FungibleToken]: pioneerDevId }),
+    },
   },
   withdraw: {
     [clover.key]: withdraw.xTokens({
       balance: balance.assets(cloverDevId),
       destination: clover,
       feePerWeight: 50_000,
     }),
+    [pioneer.key]: withdraw.xTokens({
+      balance: balance.tokens().fungibleToken(pioneerDevId),
+      destination: pioneer,
+      feePerWeight: 50_000,
+    }),
   },
 };

packages/config/src/config/moonbase/assets/neer.ts

@@ -0,0 +1,40 @@
+import { AssetSymbol, ChainKey } from '../../../constants';
+import {
+  XTokensExtrinsicCurrencyTypes,
+  XTokensExtrinsicSuccessEvent,
+} from '../../../extrinsic';
+import {
+  assets,
+  balance,
+  chains,
+  extrinsic,
+  withdraw,
+} from '../moonbase.common';
+import { MoonbaseXcmConfig } from '../moonbase.interfaces';
+
+const asset = assets[AssetSymbol.NEER];
+const origin = chains[ChainKey.BitCountryPioneer];
+
+export const NEER: MoonbaseXcmConfig = {
+  asset,
+  origin,
+  deposit: {
+    [origin.key]: {
+      source: origin,
+      balance: balance.system(),
+      extrinsic: extrinsic
+        .xTokens()
+        .transfer()
+        .successEvent(XTokensExtrinsicSuccessEvent.TransferredMultiAssets)
+        .origin(origin)
+        .asset({ [XTokensExtrinsicCurrencyTypes.NativeToken]: 0 }),
+    },
+  },
+  withdraw: {
+    [origin.key]: withdraw.xTokens({
+      balance: balance.system(),
+      destination: origin,
+      feePerWeight: 8_000_000,
+    }),
+  },
+};