fix specs

Author: sinzii

packages/typink/src/helpers/balance.ts

@@ -0,0 +1,14 @@
+import { GenericContractApi } from 'dedot/contracts';
+import { ISubstrateClient } from 'dedot';
+import { BalanceInsufficientError } from '../utils/index.js';
+
+export const checkBalanceSufficiency = async <T extends GenericContractApi = GenericContractApi>(
+  client: ISubstrateClient<T['types']['ChainApi']>,
+  address: string,
+): Promise<void> => {
+  const balance = await client.query.system.account(address);
+  // TODO better calculate reducible balance
+  if (balance.data.free <= 0n) {
+    throw new BalanceInsufficientError(address);
+  }
+};

packages/typink/src/helpers/index.ts

@@ -0,0 +1 @@
+export * from './balance.js'

packages/typink/src/hooks/__tests__/useContractTx.test.ts

@@ -3,20 +3,28 @@ import { renderHook, act } from '@testing-library/react';
 import { useContractTx } from '../useContractTx.js';
 import { useTypink } from '../useTypink.js';
 import { Contract } from 'dedot/contracts';
-import { waitForNextUpdate } from './test-utils.js';
+import { sleep, waitForNextUpdate } from './test-utils.js';
+import { checkBalanceSufficiency } from '../../helpers/index.js';
+import { BalanceInsufficientError } from '../../utils/index.js';
+import { useDeployerTx } from '../useDeployerTx.js';
 
 // Mock the useTypink hook
 vi.mock('../useTypink', () => ({
   useTypink: vi.fn(),
 }));
 
+vi.mock('../../helpers', () => ({
+  checkBalanceSufficiency: vi.fn(),
+}));
+
 describe('useContractTx', () => {
   const randomGasLimit = { refTime: 1000n, proofSize: 1000n };
   let mockContract: Contract<any>;
   let mockConnectedAccount: { address: string };
 
   beforeEach(() => {
     mockContract = {
+      client: vi.fn(),
       tx: {
         message: vi.fn(),
       },
@@ -30,6 +38,8 @@ describe('useContractTx', () => {
     (useTypink as any).mockReturnValue({
       connectedAccount: mockConnectedAccount,
     });
+
+    (checkBalanceSufficiency as any).mockImplementation(() => Promise.resolve(true));
   });
 
   it('should return the correct structure', () => {
@@ -56,7 +66,7 @@ describe('useContractTx', () => {
       ),
     );
 
-    await expect(result.current.signAndSend({} as any)).rejects.toThrow('Contract Not Found');
+    await expect(result.current.signAndSend({} as any)).rejects.toThrow('Contract not found');
   });
 
   it('should throw an error if connectedAccount is undefined', async () => {
@@ -72,7 +82,9 @@ describe('useContractTx', () => {
       ),
     );
 
-    await expect(result.current.signAndSend({} as any)).rejects.toThrow('Connected Account Not Found');
+    await expect(result.current.signAndSend({} as any)).rejects.toThrow(
+      'No connected account. Please connect your wallet.',
+    );
   });
 
   it('should call the contract method with correct parameters', async () => {
@@ -165,6 +177,26 @@ describe('useContractTx', () => {
       ),
     );
 
-    await expect(result.current.signAndSend({ args: [] })).rejects.toThrow('Contract error');
+    await expect(result.current.signAndSend({ args: [] })).rejects.toThrow('Contract Message Error: Contract error');
+  });
+
+  it('should throw an error when balance is insufficient', async () => {
+    vi.mocked(checkBalanceSufficiency).mockRejectedValue(new BalanceInsufficientError(mockConnectedAccount.address));
+
+    const { result } = renderHook(() =>
+      useContractTx(
+        mockContract,
+        // @ts-ignore
+        'message',
+      ),
+    );
+
+    await expect(result.current.signAndSend({ args: [] })).rejects.toThrow(
+      new BalanceInsufficientError(mockConnectedAccount.address),
+    );
+
+    expect(checkBalanceSufficiency).toHaveBeenCalledWith(expect.anything(), 'mock-address');
+    expect(mockContract.query.message).not.toHaveBeenCalled();
+    expect(mockContract.tx.message).not.toHaveBeenCalled();
   });
 });

packages/typink/src/hooks/__tests__/useDeployerTx.test.ts

@@ -1,22 +1,29 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { renderHook } from '@testing-library/react';
 import { useTypink } from '../useTypink.js';
 import { ContractDeployer } from 'dedot/contracts';
 import { waitForNextUpdate } from './test-utils.js';
 import { useDeployerTx } from '../useDeployerTx.js';
+import { checkBalanceSufficiency } from '../../helpers/index.js';
+import { BalanceInsufficientError } from '../../utils/index.js';
 
 // Mock the useTypink hook
 vi.mock('../useTypink', () => ({
   useTypink: vi.fn(),
 }));
 
+vi.mock('../../helpers', () => ({
+  checkBalanceSufficiency: vi.fn(),
+}));
+
 describe('useDeployerTx', () => {
   const randomGasLimit = { refTime: 1000n, proofSize: 1000n };
   let mockContractDeployer: ContractDeployer<any>;
   let mockConnectedAccount: { address: string };
 
   beforeEach(() => {
     mockContractDeployer = {
+      client: vi.fn(),
       tx: {
         message: vi.fn(),
       },
@@ -30,6 +37,8 @@ describe('useDeployerTx', () => {
     (useTypink as any).mockReturnValue({
       connectedAccount: mockConnectedAccount,
     });
+
+    (checkBalanceSufficiency as any).mockImplementation(() => Promise.resolve(true));
   });
 
   it('should return the correct structure', () => {
@@ -56,7 +65,7 @@ describe('useDeployerTx', () => {
       ),
     );
 
-    await expect(result.current.signAndSend({} as any)).rejects.toThrow('Contract Deployer Not Found');
+    await expect(result.current.signAndSend({} as any)).rejects.toThrow('ContractDeployer not found');
   });
 
   it('should throw an error if connectedAccount is undefined', async () => {
@@ -72,7 +81,9 @@ describe('useDeployerTx', () => {
       ),
     );
 
-    await expect(result.current.signAndSend({} as any)).rejects.toThrow('Connected Account Not Found');
+    await expect(result.current.signAndSend({} as any)).rejects.toThrow(
+      'No connected account. Please connect your wallet.',
+    );
   });
 
   it('should call the contract method with correct parameters', async () => {
@@ -171,6 +182,26 @@ describe('useDeployerTx', () => {
       ),
     );
 
-    await expect(result.current.signAndSend({ args: [] })).rejects.toThrow('Contract error');
+    await expect(result.current.signAndSend({ args: [] })).rejects.toThrow('Contract Message Error: Contract error');
+  });
+
+  it('should throw an error when balance is insufficient', async () => {
+    vi.mocked(checkBalanceSufficiency).mockRejectedValue(new BalanceInsufficientError(mockConnectedAccount.address));
+
+    const { result } = renderHook(() =>
+      useDeployerTx(
+        mockContractDeployer,
+        // @ts-ignore
+        'message',
+      ),
+    );
+
+    await expect(result.current.signAndSend({ args: [] })).rejects.toThrow(
+      new BalanceInsufficientError(mockConnectedAccount.address),
+    );
+
+    expect(checkBalanceSufficiency).toHaveBeenCalledWith(expect.anything(), 'mock-address');
+    expect(mockContractDeployer.query.message).not.toHaveBeenCalled();
+    expect(mockContractDeployer.tx.message).not.toHaveBeenCalled();
   });
 });

packages/typink/src/hooks/useContractTx.ts

@@ -10,9 +10,9 @@ import {
 } from 'dedot/contracts';
 import { ISubmittableResult } from 'dedot/types';
 import { assert, deferred } from 'dedot/utils';
-import { BalanceInsufficientError, ContractMessageError } from '../utils/index.js';
+import { ContractMessageError } from '../utils/index.js';
 import { useDeepDeps } from './internal/index.js';
-import { ISubstrateClient } from 'dedot';
+import { checkBalanceSufficiency } from '../helpers/index.js';
 
 type UseContractTx<A extends GenericContractApi = GenericContractApi> = OmitNever<{
   [K in keyof A['tx']]: K extends string ? (K extends `${infer Literal}` ? Literal : never) : never;
@@ -128,7 +128,7 @@ export async function contractTx<
   const signAndSend = async () => {
     const { contract, fn, args = [], caller, txOptions = {}, callback } = parameters;
 
-    await checkBalanceSufficient(contract.client, caller);
+    await checkBalanceSufficiency(contract.client, caller);
 
     try {
       const dryRunOptions: ContractCallOptions = { caller };
@@ -176,14 +176,3 @@ export async function contractTx<
 
   return defer.promise;
 }
-
-const checkBalanceSufficient = async <T extends GenericContractApi = GenericContractApi>(
-  client: ISubstrateClient<T['types']['ChainApi']>,
-  caller: string,
-): Promise<void> => {
-  const balance = await client.query.system.account(caller);
-  // TODO better calculate reducible balance
-  if (balance.data.free <= 0n) {
-    throw new BalanceInsufficientError(caller);
-  }
-};

packages/typink/src/hooks/useDeployerTx.ts

@@ -11,9 +11,10 @@ import {
 } from 'dedot/contracts';
 import { IEventRecord, IRuntimeEvent, ISubmittableResult } from 'dedot/types';
 import { assert, deferred } from 'dedot/utils';
-import { TypinkError } from '../utils/index.js';
+import { ContractMessageError } from '../utils/index.js';
 import { Hash } from 'dedot/codecs';
 import { useDeepDeps } from './internal/index.js';
+import { checkBalanceSufficiency } from '../helpers/index.js';
 
 type UseDeployerTx<A extends GenericContractApi = GenericContractApi> = OmitNever<{
   [K in keyof A['constructorTx']]: K extends string ? (K extends `${infer Literal}` ? Literal : never) : never;
@@ -70,8 +71,8 @@ export function useDeployerTx<
   const signAndSend = useMemo(
     () => {
       return async (o: Parameters<UseDeployerTxReturnType<T>['signAndSend']>[0]) => {
-        assert(deployer, 'Contract Deployer Not Found');
-        assert(connectedAccount, 'Connected Account Not Found');
+        assert(deployer, 'ContractDeployer not found');
+        assert(connectedAccount, 'No connected account. Please connect your wallet.');
 
         setInProgress(true);
         setInBestBlockProgress(true);
@@ -139,16 +140,14 @@ export async function deployerTx<
     callback?: (result: ISubmittableResult) => void;
   } & Args<Pop<Parameters<T['tx'][M]>>>,
 ): Promise<void> {
-  // TODO assertions
-  // TODO check if balance is sufficient
-
   const defer = deferred<void>();
 
   const signAndSend = async () => {
     const { deployer, fn, args = [], caller, txOptions = {}, callback } = parameters;
 
     try {
-      // TODO dry running
+      await checkBalanceSufficiency(deployer.client, caller);
+
       const dryRunOptions: ConstructorCallOptions = { caller };
 
       const dryRun = await deployer.query[fn](...args, dryRunOptions);
@@ -160,8 +159,7 @@ export async function deployerTx<
       } = dryRun;
 
       if (data && data['isErr'] && data['err']) {
-        // TODO Add a specific contract level error
-        throw new TypinkError(JSON.stringify(data['err']));
+        throw new ContractMessageError(data['err']);
       }
 
       const actualTxOptions: ContractTxOptions = {

packages/typink/src/networks/mainnet.ts

@@ -1,4 +1,4 @@
-import { JsonRpcApi, NetworkInfo } from '../types';
+import { JsonRpcApi, NetworkInfo } from '../types.js';
 
 export const alephZero: NetworkInfo = {
   id: 'alephzero',