Merge branch '106-arbitrary-tx-add-type' into 'dev'

Resolve "Arbitrary Tx: Add type"

Closes #106

See merge request ergo/rosen-bridge/rosen-chains!147

.changeset/stupid-ducks-fail.md

@@ -0,0 +1,5 @@
+---
+'@rosen-chains/abstract-chain': minor
+---
+
+add order encoder and decoder

.changeset/wicked-ears-grab.md

@@ -0,0 +1,6 @@
+---
+'@rosen-chains/abstract-chain': major
+'@rosen-chains/ergo': major
+---
+
+add arbitrary transaction type

packages/abstract-chain/lib/AbstractChain.ts

@@ -317,6 +317,8 @@ abstract class AbstractChain<TxType> {
         return this.configs.confirmations.observation;
       case TransactionType.manual:
         return this.configs.confirmations.manual;
+      case TransactionType.arbitrary:
+        return this.configs.confirmations.arbitrary;
       default:
         throw Error(
           `Confirmation for type [${transactionType}] is not defined in abstract chain`

packages/abstract-chain/lib/ChainUtils.ts

@@ -1,6 +1,7 @@
-import { AssetBalance, TokenInfo } from './types';
+import { AssetBalance, PaymentOrder, TokenInfo } from './types';
 import { ValueError } from './errors';
 import { TokenMap } from '@rosen-bridge/tokens';
+import JsonBigInt from '@rosen-bridge/json-bigint';
 
 class ChainUtils {
   /**
@@ -159,6 +160,35 @@ class ChainUtils {
     );
     return result;
   };
+
+  /**
+   * encodes the order to string
+   * token placement in single payment should not affect the encoding
+   * @param order
+   */
+  static encodeOrder = (order: PaymentOrder): string => {
+    const organizedOrder = order.map((payment) => {
+      const organizedPayment = structuredClone(payment);
+      organizedPayment.assets.tokens.sort((a, b) => {
+        if (a.id === b.id) {
+          if (a.value === b.value) return 0;
+          else if (a.value > b.value) return 1;
+          else return -1;
+        } else return a.id > b.id ? 1 : -1;
+      });
+      return organizedPayment;
+    });
+
+    return JsonBigInt.stringify(organizedOrder);
+  };
+
+  /**
+   * decodes the order from string
+   * @param encodedOrder
+   */
+  static decodeOrder = (encodedOrder: string): PaymentOrder => {
+    return JsonBigInt.parse(encodedOrder);
+  };
 }
 
 export default ChainUtils;

packages/abstract-chain/lib/types.ts

@@ -3,6 +3,7 @@ interface ConfirmationConfigs {
   payment: number;
   cold: number;
   manual: number;
+  arbitrary: number;
 }
 
 interface AddressConfigs {
@@ -100,6 +101,7 @@ enum TransactionType {
   coldStorage = 'cold-storage',
   lock = 'lock',
   manual = 'manual',
+  arbitrary = 'arbitrary',
 }
 
 interface TokenDetail {

packages/abstract-chain/tests/ChainUtils.spec.ts

@@ -1,11 +1,17 @@
 import { TokenMap } from '@rosen-bridge/tokens';
-import { AssetBalance, ChainUtils, ValueError } from '../lib';
+import { AssetBalance, ChainUtils, PaymentOrder, ValueError } from '../lib';
 import {
   actualBalance,
+  encodedOrder,
+  organizedOrder,
+  sortedTokens,
   testTokenMap,
+  unorganizedAssetBalance,
+  unorganizedOrder,
   unwrappedBalance,
   wrappedBalance,
 } from './testData';
+import JsonBigInt from '@rosen-bridge/json-bigint';
 
 describe('ChainUtils', () => {
   describe('isEqualAssetBalance', () => {
@@ -650,4 +656,92 @@ describe('ChainUtils', () => {
       expect(result).toEqual(unwrappedBalance);
     });
   });
+
+  describe('encodeOrder', () => {
+    /**
+     * @target ChainUtils.encodeOrder should NOT mutate the tokens
+     * @dependencies
+     * @scenario
+     * - mock an AssetBalance with unorganized tokens
+     * - run test
+     * - check returned value
+     * @expected
+     * - the tokens list should be sorted
+     * - the original order token list should remain unchanged
+     */
+    it('should NOT mutate the tokens', () => {
+      // mock an AssetBalance with unorganized tokens
+      const a = unorganizedAssetBalance;
+      const order: PaymentOrder = [
+        {
+          address: 'addr2',
+          assets: a,
+        },
+      ];
+      const originalTokens = structuredClone(a.tokens);
+
+      // run test
+      const result = ChainUtils.encodeOrder(order);
+
+      // check returned value
+      const organizedOrder: PaymentOrder = JsonBigInt.parse(result);
+      expect(organizedOrder[0].assets).toEqual({
+        nativeToken: a.nativeToken,
+        tokens: sortedTokens,
+      });
+      expect(order[0].assets.tokens).toEqual(originalTokens);
+    });
+  });
+
+  /**
+   * @target ChainUtils.encodeOrder should sort the tokens before encoding
+   * @dependencies
+   * @scenario
+   * - mock two AssetBalance with unorganized tokens
+   * - run test
+   * - check returned value
+   * @expected
+   * - order should remain the same
+   * - the tokens list of each record should be sorted
+   */
+  it('should sort the tokens before encoding', () => {
+    // mock two AssetBalance with unorganized tokens
+    const order: PaymentOrder = unorganizedOrder;
+
+    // run test
+    const result = ChainUtils.encodeOrder(order);
+
+    // check returned value
+    const organizedOrder: PaymentOrder = JsonBigInt.parse(result);
+    expect(organizedOrder[0].address).toEqual('addr2');
+    expect(organizedOrder[0].assets).toEqual({
+      nativeToken: unorganizedAssetBalance.nativeToken,
+      tokens: sortedTokens,
+    });
+    expect(organizedOrder[1].address).toEqual('addr1');
+    expect(organizedOrder[1].assets).toEqual({
+      nativeToken: 100n,
+      tokens: sortedTokens,
+    });
+  });
+
+  describe('decodeOrder', () => {
+    /**
+     * @target ChainUtils.decodeOrder should decode the order successfully
+     * @dependencies
+     * @scenario
+     * - run test
+     * - check returned value
+     * @expected
+     * - order should remain the same
+     * - the tokens list of each record should be sorted
+     */
+    it('should decode the order successfully', () => {
+      // run test
+      const result = ChainUtils.decodeOrder(encodedOrder);
+
+      // check returned value
+      expect(result).toEqual(organizedOrder);
+    });
+  });
 });

packages/abstract-chain/tests/testData.ts

@@ -1,5 +1,5 @@
 import { RosenTokens } from '@rosen-bridge/tokens';
-import { AssetBalance, EventTrigger } from '../lib';
+import { AssetBalance, EventTrigger, PaymentOrder, TokenInfo } from '../lib';
 
 export const paymentTxConfirmation = 6;
 
@@ -223,3 +223,61 @@ export const unwrappedBalance: AssetBalance = {
     },
   ],
 };
+export const originalTokens = [
+  {
+    id: 'id2',
+    value: 20n,
+  },
+  {
+    id: 'id1',
+    value: 10n,
+  },
+];
+export const unorganizedAssetBalance: AssetBalance = {
+  nativeToken: 200n,
+  tokens: originalTokens,
+};
+export const unorganizedAssetBalance2: AssetBalance = {
+  nativeToken: 100n,
+  tokens: structuredClone(originalTokens),
+};
+export const sortedTokens: TokenInfo[] = [
+  {
+    id: 'id1',
+    value: 10n,
+  },
+  {
+    id: 'id2',
+    value: 20n,
+  },
+];
+export const unorganizedOrder: PaymentOrder = [
+  {
+    address: 'addr2',
+    assets: unorganizedAssetBalance,
+  },
+  {
+    address: 'addr1',
+    assets: {
+      nativeToken: 100n,
+      tokens: structuredClone(originalTokens),
+    },
+  },
+];
+export const organizedOrder: PaymentOrder = [
+  {
+    address: 'addr2',
+    assets: {
+      nativeToken: unorganizedAssetBalance.nativeToken,
+      tokens: structuredClone(sortedTokens),
+    },
+  },
+  {
+    address: 'addr1',
+    assets: {
+      nativeToken: 100n,
+      tokens: structuredClone(sortedTokens),
+    },
+  },
+];
+export const encodedOrder = `[{"address":"addr2","assets":{"nativeToken":200,"tokens":[{"id":"id1","value":10},{"id":"id2","value":20}]}},{"address":"addr1","assets":{"nativeToken":100,"tokens":[{"id":"id1","value":10},{"id":"id2","value":20}]}}]`;

packages/abstract-chain/tests/testUtils.ts

@@ -16,6 +16,7 @@ export const generateChainObject = (network: TestChainNetwork) => {
       payment: testData.paymentTxConfirmation,
       cold: 7,
       manual: 8,
+      arbitrary: 9,
     },
     addresses: {
       lock: 'lock_addr',
@@ -36,6 +37,7 @@ export const generateUtxoChainObject = (network: TestUtxoChainNetwork) => {
       payment: 6,
       cold: 7,
       manual: 8,
+      arbitrary: 9,
     },
     addresses: {
       lock: 'lock_addr',

packages/chains/bitcoin/tests/testUtils.ts

@@ -9,6 +9,7 @@ export const observationTxConfirmation = 5;
 export const paymentTxConfirmation = 9;
 export const coldTxConfirmation = 10;
 export const manualTxConfirmation = 11;
+export const arbitraryTxConfirmation = 12;
 export const rwtId =
   '9410db5b39388c6b515160e7248346d7ec63d5457292326da12a26cc02efb526';
 export const configs: BitcoinConfigs = {
@@ -25,6 +26,7 @@ export const configs: BitcoinConfigs = {
     payment: paymentTxConfirmation,
     cold: coldTxConfirmation,
     manual: manualTxConfirmation,
+    arbitrary: arbitraryTxConfirmation,
   },
   aggregatedPublicKey: testData.lockAddressPublicKey,
   txFeeSlippage: 10,

packages/chains/cardano/tests/testUtils.ts

@@ -128,6 +128,7 @@ export const observationTxConfirmation = 5;
 export const paymentTxConfirmation = 9;
 export const coldTxConfirmation = 10;
 export const manualTxConfirmation = 11;
+export const arbitraryTxConfirmation = 12;
 export const rwtId =
   '9410db5b39388c6b515160e7248346d7ec63d5457292326da12a26cc02efb526';
 export const minBoxValue = 2000000n;
@@ -147,6 +148,7 @@ export const configs: CardanoConfigs = {
     payment: paymentTxConfirmation,
     cold: coldTxConfirmation,
     manual: manualTxConfirmation,
+    arbitrary: arbitraryTxConfirmation,
   },
   aggregatedPublicKey:
     'bcb07faa6c0f19e2f2587aa9ef6f43a68fc0135321216a71dc87c8527af4ca6a',

packages/chains/ergo/lib/ErgoChain.ts

@@ -689,6 +689,8 @@ class ErgoChain extends AbstractUtxoChain<wasm.Transaction, wasm.ErgoBox> {
         return this.configs.confirmations.observation;
       case TransactionType.manual:
         return this.configs.confirmations.manual;
+      case TransactionType.arbitrary:
+        return this.configs.confirmations.arbitrary;
       default:
         throw Error(
           `Confirmation for type [${transactionType}] is not defined in Ergo chain`