tests: rest controller transfer

Author: sansan

tests/src/__tests__/rest/assets/controllerTransfer.ts

@@ -0,0 +1,116 @@
+import { TestFactory } from '~/helpers';
+import { RestClient } from '~/rest';
+import { controllerTransferParams, createAssetParams } from '~/rest/assets/params';
+import { ProcessMode } from '~/rest/common';
+import { Identity } from '~/rest/identities/interfaces';
+import { RestSuccessResult } from '~/rest/interfaces';
+import { fungibleInstructionParams } from '~/rest/settlements/params';
+import { expectBasicTxInfo } from '../utils';
+
+const handles = ['issuer', 'holder'];
+let factory: TestFactory;
+
+describe('Fungible AssetController transfer', () => {
+    let restClient: RestClient;
+    let signer: string;
+    let issuer: Identity;
+    let holder: Identity;
+    let assetParams: ReturnType<typeof createAssetParams>;
+    let assetId: string;
+
+    beforeAll(async () => {
+        factory = await TestFactory.create({ handles });
+        ({ restClient } = factory);
+        issuer = factory.getSignerIdentity(handles[0]);
+        holder = factory.getSignerIdentity(handles[1]);
+
+        signer = issuer.signer;
+
+        assetParams = createAssetParams({
+            options: { processMode: ProcessMode.Submit, signer },
+        });
+    });
+
+    afterAll(async () => {
+        await factory.close();
+    });
+
+    it('should create and fetch the Asset', async () => {
+        assetId = await restClient.assets.createAndGetAssetId(assetParams);
+
+        const asset = await restClient.assets.getAsset(assetId);
+
+        expect(asset).toMatchObject({
+            name: assetParams.name,
+            assetType: assetParams.assetType,
+        });
+    });
+
+    it('should transfer the asset to holder', async () => {
+        const transferToHolderTx = await restClient.settlements.createDirectInstruction(fungibleInstructionParams(assetId, issuer.did, holder.did, {
+            options: { processMode: ProcessMode.Submit, signer },
+        }));
+
+        // should have created an instruction
+        expect((transferToHolderTx as RestSuccessResult).instruction).toBeDefined();
+
+        const txData = await restClient.settlements.affirmInstruction(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (transferToHolderTx as any).instruction,
+            {
+                options: { processMode: ProcessMode.Submit, signer: holder.signer },
+            }
+        );
+
+        expect(txData).toMatchObject({
+            transactions: expect.arrayContaining([
+                {
+                    transactionTag: 'settlement.affirmInstructionWithCount',
+                    type: 'single',
+                    ...expectBasicTxInfo,
+                },
+            ]),
+        });
+
+        const { results } = await restClient.assets.getAssetHolders(assetId);
+
+        expect(results.length).toEqual(2);
+        expect(results).toContainEqual(expect.objectContaining({
+            identity: issuer.did,
+            balance: '99990',
+        }));
+        expect(results).toContainEqual(expect.objectContaining({
+            identity: holder.did,
+            balance: '10',
+        }));
+    });
+
+    it('should run controller transfer and return the asset back to the issuer', async () => {
+        const controllerTransferTx = await restClient.assets.controllerTransfer(assetId, controllerTransferParams({ did: holder.did, id: '0' }, 10, {
+            options: { processMode: ProcessMode.Submit, signer },
+        })) as RestSuccessResult;
+
+        expect(controllerTransferTx).toMatchObject({
+            transactions: expect.arrayContaining([
+                {
+                    transactionTag: 'asset.controllerTransfer',
+                    type: 'single',
+                    ...expectBasicTxInfo,
+                },
+            ]),
+        });
+
+
+        const { results } = await restClient.assets.getAssetHolders(assetId);
+
+        expect(results.length).toEqual(1);
+        expect(results).toContainEqual(expect.objectContaining({
+            identity: expect.objectContaining({
+                did: issuer.did,
+            }),
+            balance: expect.objectContaining({
+                amount: '100000',
+            }),
+        }));
+    });
+});

tests/src/__tests__/sdk/assets/controllerTransfer.ts

@@ -1,5 +1,5 @@
 import { LocalSigningManager } from '@polymeshassociation/local-signing-manager';
-import { BigNumber, Polymesh } from '@polymeshassociation/polymesh-sdk';
+import { Polymesh } from '@polymeshassociation/polymesh-sdk';
 import { FungibleAsset } from '@polymeshassociation/polymesh-sdk/types';
 
 import { TestFactory } from '~/helpers';

tests/src/rest/assets/client.ts

@@ -8,10 +8,11 @@ import {
   setAssetDocumentParams,
   setMetadataParams,
   transferAssetOwnershipParams,
+  controllerTransferParams,
 } from '~/rest/assets/params';
 import { RestClient } from '~/rest/client';
 import { TxBase } from '~/rest/common';
-import { PostResult, RestSuccessResult } from '~/rest/interfaces';
+import { PostResult, ResultSet, RestSuccessResult } from '~/rest/interfaces';
 
 export class Assets {
   constructor(private client: RestClient) {}
@@ -133,4 +134,12 @@ export class Assets {
   public async unfreeze(asset: string, params: TxBase): Promise<PostResult> {
     return this.client.post(`assets/${asset}/unfreeze`, { ...params });
   }
+
+  public async controllerTransfer(asset: string, params: ReturnType<typeof controllerTransferParams>): Promise<PostResult> {
+    return this.client.post(`assets/${asset}/controller-transfer`, params);
+  }
+
+  public async getAssetHolders(asset: string): Promise<ResultSet<Record<string, unknown>>> {
+    return this.client.get(`assets/${asset}/holders`);
+  }
 }

tests/src/rest/assets/params.ts

@@ -105,3 +105,12 @@ export const issueAssetParams = (amount: number, base: TxBase, extras: TxExtras
     ...extras,
     ...base,
   } as const);
+
+
+export const controllerTransferParams = (origin: { did: string, id: string }, amount: number, base: TxBase, extras: TxExtras = {}) =>
+  ({
+    origin,
+    amount,
+    ...extras,
+    ...base,
+  } as const);