@hsuite/native-connect-angular 1.0.0

package/src/lib/services/transaction-builders/hedera-transaction-builder.service.spec.ts

@@ -0,0 +1,741 @@
+/**
+ * @fileoverview Unit tests for HederaTransactionBuilderService
+ *
+ * Tests cover:
+ * - HBAR/token/NFT transfer transactions
+ * - Token association/dissociation
+ * - Atomic transactions with multiple transfers
+ * - Token/topic/account creation
+ * - Multisig key configuration
+ * - Error handling
+ *
+ * @module services/transaction-builders/hedera-transaction-builder
+ * @since 2.0.0
+ */
+
+import { TestBed } from '@angular/core/testing';
+import { describe, it, expect, beforeEach, vi, type MockedFunction } from 'vitest';
+import {
+  HederaTransactionBuilderService,
+  type HederaKeyConfig,
+  type TokenCreateOptions,
+  type TopicCreateOptions,
+  type AccountCreateOptions,
+} from './hedera-transaction-builder.service';
+import { UnifiedWalletService } from '../unified-wallet.service';
+import { LoggerService } from '../logger.service';
+import { signal } from '@angular/core';
+import type { WalletAccount } from '@hsuite/native-connect-types';
+
+// Mock Hedera SDK
+vi.mock('@hashgraph/sdk', () => {
+  const mockTransactionId = {
+    generate: vi.fn().mockReturnValue('mock-tx-id'),
+  };
+
+  const mockAccountId = {
+    fromString: vi.fn((s: string) => ({ toString: () => s })),
+  };
+
+  const mockTokenId = {
+    fromString: vi.fn((s: string) => ({ toString: () => s })),
+  };
+
+  const mockHbar = vi.fn((amount: number) => ({
+    toTinybars: () => amount * 100_000_000,
+    amount,
+  }));
+  mockHbar.fromTinybars = vi.fn((amount: number) => ({ amount }));
+
+  const createMockTransaction = () => ({
+    setTransactionId: vi.fn().mockReturnThis(),
+    freezeWith: vi.fn().mockResolvedValue({
+      toBytes: () => new Uint8Array([1, 2, 3, 4]),
+    }),
+    toBytes: () => new Uint8Array([1, 2, 3, 4]),
+    addHbarTransfer: vi.fn().mockReturnThis(),
+    addTokenTransfer: vi.fn().mockReturnThis(),
+    addNftTransfer: vi.fn().mockReturnThis(),
+    setAccountId: vi.fn().mockReturnThis(),
+    setTokenIds: vi.fn().mockReturnThis(),
+    setBatchKey: vi.fn().mockReturnThis(),
+    setAmount: vi.fn().mockReturnThis(),
+    setTokenId: vi.fn().mockReturnThis(),
+    setMetadata: vi.fn().mockReturnThis(),
+    setScheduledTransaction: vi.fn().mockReturnThis(),
+    setPayerAccountId: vi.fn().mockReturnThis(),
+    setScheduleMemo: vi.fn().mockReturnThis(),
+    setTokenName: vi.fn().mockReturnThis(),
+    setTokenSymbol: vi.fn().mockReturnThis(),
+    setDecimals: vi.fn().mockReturnThis(),
+    setInitialSupply: vi.fn().mockReturnThis(),
+    setTreasuryAccountId: vi.fn().mockReturnThis(),
+    setTokenType: vi.fn().mockReturnThis(),
+    setSupplyType: vi.fn().mockReturnThis(),
+    setMaxSupply: vi.fn().mockReturnThis(),
+    setTokenMemo: vi.fn().mockReturnThis(),
+    setAdminKey: vi.fn().mockReturnThis(),
+    setSupplyKey: vi.fn().mockReturnThis(),
+    setFreezeKey: vi.fn().mockReturnThis(),
+    setWipeKey: vi.fn().mockReturnThis(),
+    setPauseKey: vi.fn().mockReturnThis(),
+    setKycKey: vi.fn().mockReturnThis(),
+    setFeeScheduleKey: vi.fn().mockReturnThis(),
+    setTopicMemo: vi.fn().mockReturnThis(),
+    setAutoRenewAccountId: vi.fn().mockReturnThis(),
+    setSubmitKey: vi.fn().mockReturnThis(),
+    setKey: vi.fn().mockReturnThis(),
+    setInitialBalance: vi.fn().mockReturnThis(),
+    setAccountMemo: vi.fn().mockReturnThis(),
+    setMaxAutomaticTokenAssociations: vi.fn().mockReturnThis(),
+    setReceiverSignatureRequired: vi.fn().mockReturnThis(),
+    setAlias: vi.fn().mockReturnThis(),
+    addTransaction: vi.fn().mockReturnThis(),
+    setInnerTransactionIndex: vi.fn().mockReturnThis(),
+  });
+
+  const mockNftId = vi.fn((tokenId: unknown, serial: number) => ({
+    tokenId,
+    serial,
+  }));
+
+  const mockPublicKey = {
+    fromString: vi.fn((s: string) => ({ _key: s, toString: () => s })),
+  };
+
+  const mockKeyList = vi.fn((keys: unknown[], threshold: number) => ({
+    keys,
+    threshold,
+  }));
+
+  const mockPrivateKey = {
+    generate: vi.fn().mockReturnValue({
+      publicKey: { toString: () => 'mock-public-key' },
+    }),
+  };
+
+  const mockClient = {
+    forMainnet: vi.fn().mockReturnValue({ network: 'mainnet' }),
+    forTestnet: vi.fn().mockReturnValue({ network: 'testnet' }),
+    forPreviewnet: vi.fn().mockReturnValue({ network: 'previewnet' }),
+  };
+
+  const TokenType = {
+    FungibleCommon: 0,
+    NonFungibleUnique: 1,
+  };
+
+  const TokenSupplyType = {
+    Infinite: 0,
+    Finite: 1,
+  };
+
+  return {
+    TransferTransaction: vi.fn(createMockTransaction),
+    TokenAssociateTransaction: vi.fn(createMockTransaction),
+    TokenDissociateTransaction: vi.fn(createMockTransaction),
+    TokenCreateTransaction: vi.fn(createMockTransaction),
+    TokenMintTransaction: vi.fn(createMockTransaction),
+    TokenBurnTransaction: vi.fn(createMockTransaction),
+    TopicCreateTransaction: vi.fn(createMockTransaction),
+    TopicMessageSubmitTransaction: vi.fn(createMockTransaction),
+    AccountCreateTransaction: vi.fn(createMockTransaction),
+    AccountUpdateTransaction: vi.fn(createMockTransaction),
+    ScheduleCreateTransaction: vi.fn(createMockTransaction),
+    BatchTransaction: vi.fn(createMockTransaction),
+    Transaction: vi.fn(createMockTransaction),
+    TransactionId: mockTransactionId,
+    AccountId: mockAccountId,
+    TokenId: mockTokenId,
+    NftId: mockNftId,
+    Hbar: mockHbar,
+    Client: mockClient,
+    PublicKey: mockPublicKey,
+    PrivateKey: mockPrivateKey,
+    KeyList: mockKeyList,
+    Key: vi.fn(),
+    TokenType,
+    TokenSupplyType,
+  };
+});
+
+describe('HederaTransactionBuilderService', () => {
+  let service: HederaTransactionBuilderService;
+  let mockWalletService: {
+    activeAccount: ReturnType<typeof signal<WalletAccount | undefined>>;
+  };
+  let mockLogger: {
+    debug: MockedFunction<(...args: unknown[]) => void>;
+    warn: MockedFunction<(...args: unknown[]) => void>;
+    error: MockedFunction<(...args: unknown[]) => void>;
+    scoped: MockedFunction<(scope: string) => typeof mockLogger>;
+  };
+
+  const mockAccount: WalletAccount = {
+    address: '0.0.12345',
+    ledgerId: 'hedera',
+    networkId: 'hedera:testnet',
+    label: 'Test Account',
+    balance: '100',
+    metadata: {
+      publicKey: 'mock-public-key-hex',
+    },
+  };
+
+  beforeEach(async () => {
+    mockWalletService = {
+      activeAccount: signal<WalletAccount | undefined>(mockAccount),
+    };
+
+    mockLogger = {
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      scoped: vi.fn().mockReturnThis(),
+    };
+
+    await TestBed.configureTestingModule({
+      providers: [
+        HederaTransactionBuilderService,
+        { provide: UnifiedWalletService, useValue: mockWalletService },
+        { provide: LoggerService, useValue: mockLogger },
+      ],
+    }).compileComponents();
+
+    service = TestBed.inject(HederaTransactionBuilderService);
+  });
+
+  it('should create', () => {
+    expect(service).toBeTruthy();
+  });
+
+  // ==================== HBAR TRANSFER ====================
+  describe('buildSendHbar', () => {
+    it('should build HBAR transfer transaction', async () => {
+      const result = await service.buildSendHbar('0.0.12345', '0.0.67890', 10);
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+      // Base64 encoded
+      expect(result.match(/^[A-Za-z0-9+/]+=*$/)).toBeTruthy();
+    });
+
+    it('should throw error when no active wallet session', async () => {
+      mockWalletService.activeAccount.set(undefined);
+
+      await expect(service.buildSendHbar('0.0.12345', '0.0.67890', 10)).rejects.toThrow(
+        'No active wallet session',
+      );
+    });
+  });
+
+  // ==================== TOKEN TRANSFER ====================
+  describe('buildSendToken', () => {
+    it('should build token transfer transaction', async () => {
+      const result = await service.buildSendToken('0.0.12345', '0.0.67890', '0.0.98765', 100, 8);
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should use default decimals of 0', async () => {
+      const result = await service.buildSendToken('0.0.12345', '0.0.67890', '0.0.98765', 100);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  // ==================== NFT TRANSFER ====================
+  describe('buildSendNft', () => {
+    it('should build NFT transfer transaction', async () => {
+      const result = await service.buildSendNft('0.0.12345', '0.0.67890', '0.0.98765', 1);
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+    });
+  });
+
+  // ==================== TOKEN ASSOCIATION ====================
+  describe('buildAssociateToken', () => {
+    it('should build token association transaction', async () => {
+      const result = await service.buildAssociateToken('0.0.12345', ['0.0.98765']);
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should handle multiple token IDs', async () => {
+      const result = await service.buildAssociateToken('0.0.12345', [
+        '0.0.98765',
+        '0.0.98766',
+        '0.0.98767',
+      ]);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  // ==================== TOKEN DISSOCIATION ====================
+  describe('buildDissociateToken', () => {
+    it('should build token dissociation transaction', async () => {
+      const result = await service.buildDissociateToken('0.0.12345', ['0.0.98765']);
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+    });
+  });
+
+  // ==================== SCHEDULED TRANSACTION ====================
+  describe('buildScheduledTransaction', () => {
+    it('should build scheduled transaction', async () => {
+      const innerTxBase64 = btoa('mock-inner-tx');
+      const result = await service.buildScheduledTransaction(innerTxBase64, '0.0.12345');
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should build scheduled transaction with memo', async () => {
+      const innerTxBase64 = btoa('mock-inner-tx');
+      const result = await service.buildScheduledTransaction(
+        innerTxBase64,
+        '0.0.12345',
+        'Test scheduled transaction',
+      );
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  // ==================== BATCH TRANSACTIONS ====================
+  describe('buildBatchTransactions', () => {
+    it('should return transactions as-is', async () => {
+      const transactions = ['tx1', 'tx2', 'tx3'];
+      const result = await service.buildBatchTransactions(transactions);
+
+      expect(result).toEqual(transactions);
+    });
+  });
+
+  // ==================== ATOMIC TRANSACTION ====================
+  describe('buildAtomicTransaction', () => {
+    it('should build atomic transaction with HBAR transfers', async () => {
+      const result = await service.buildAtomicTransaction([
+        {
+          type: 'hbar',
+          fromAccount: '0.0.12345',
+          toAccount: '0.0.67890',
+          amount: 10,
+        },
+        {
+          type: 'hbar',
+          fromAccount: '0.0.12345',
+          toAccount: '0.0.11111',
+          amount: 5,
+        },
+      ]);
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should build atomic transaction with token transfers', async () => {
+      const result = await service.buildAtomicTransaction([
+        {
+          type: 'token',
+          fromAccount: '0.0.12345',
+          toAccount: '0.0.67890',
+          amount: 100,
+          tokenId: '0.0.98765',
+          decimals: 8,
+        },
+      ]);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should build atomic transaction with mixed transfers', async () => {
+      const result = await service.buildAtomicTransaction([
+        {
+          type: 'hbar',
+          fromAccount: '0.0.12345',
+          toAccount: '0.0.67890',
+          amount: 10,
+        },
+        {
+          type: 'token',
+          fromAccount: '0.0.12345',
+          toAccount: '0.0.67890',
+          amount: 100,
+          tokenId: '0.0.98765',
+        },
+      ]);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should throw error for empty transfers', async () => {
+      await expect(service.buildAtomicTransaction([])).rejects.toThrow(
+        'At least one transfer is required',
+      );
+    });
+  });
+
+  // ==================== TOKEN CREATE ====================
+  describe('buildTokenCreate', () => {
+    it('should build token creation with object options', async () => {
+      const options: TokenCreateOptions = {
+        name: 'Test Token',
+        symbol: 'TST',
+        decimals: 8,
+        initialSupply: 1_000_000,
+      };
+
+      const result = await service.buildTokenCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should build token creation with positional args', async () => {
+      const result = await service.buildTokenCreate('0.0.12345', 'Test Token', 'TST', 8, 1_000_000);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should build NFT token creation', async () => {
+      const options: TokenCreateOptions = {
+        name: 'Test NFT',
+        symbol: 'TNFT',
+        decimals: 0,
+        initialSupply: 0,
+        tokenType: 'NFT',
+      };
+
+      const result = await service.buildTokenCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should build token with max supply', async () => {
+      const options: TokenCreateOptions = {
+        name: 'Limited Token',
+        symbol: 'LTD',
+        decimals: 8,
+        initialSupply: 1_000_000,
+        maxSupply: 10_000_000,
+      };
+
+      const result = await service.buildTokenCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should build token with memo', async () => {
+      const options: TokenCreateOptions = {
+        name: 'Memo Token',
+        symbol: 'MEM',
+        decimals: 8,
+        initialSupply: 1_000_000,
+        memo: 'This is a test token',
+      };
+
+      const result = await service.buildTokenCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  // ==================== TOPIC CREATE ====================
+  describe('buildTopicCreate', () => {
+    it('should build topic creation transaction', async () => {
+      const options: TopicCreateOptions = {
+        memo: 'Test topic',
+      };
+
+      const result = await service.buildTopicCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should build topic with simple memo string', async () => {
+      const result = await service.buildTopicCreate('0.0.12345', 'Simple memo');
+
+      expect(result).toBeDefined();
+    });
+
+    it('should build topic with auto-renew account', async () => {
+      const options: TopicCreateOptions = {
+        memo: 'Auto-renew topic',
+        autoRenewAccountId: '0.0.67890',
+      };
+
+      const result = await service.buildTopicCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  // ==================== ACCOUNT CREATE ====================
+  describe('buildAccountCreate', () => {
+    it('should build account creation transaction', async () => {
+      const options: AccountCreateOptions = {
+        initialBalance: 10,
+        key: { publicKey: 'mock-public-key' },
+      };
+
+      const result = await service.buildAccountCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should build account with memo', async () => {
+      const options: AccountCreateOptions = {
+        initialBalance: 10,
+        memo: 'Test account',
+      };
+
+      const result = await service.buildAccountCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should build account with max automatic associations', async () => {
+      const options: AccountCreateOptions = {
+        initialBalance: 10,
+        maxAutomaticTokenAssociations: 100,
+      };
+
+      const result = await service.buildAccountCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should build account requiring receiver signature', async () => {
+      const options: AccountCreateOptions = {
+        initialBalance: 10,
+        receiverSignatureRequired: true,
+      };
+
+      const result = await service.buildAccountCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should build multisig account', async () => {
+      const options: AccountCreateOptions = {
+        initialBalance: 10,
+        key: {
+          signerPublicKeys: ['key1', 'key2', 'key3'],
+          threshold: 2,
+        },
+      };
+
+      const result = await service.buildAccountCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  // ==================== ACCOUNT UPDATE ====================
+  describe('buildAccountUpdate', () => {
+    it('should build account update transaction', async () => {
+      const result = await service.buildAccountUpdate('0.0.12345', {
+        key: { publicKey: 'new-public-key' },
+      });
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+    });
+
+    it('should build account update with memo', async () => {
+      const result = await service.buildAccountUpdate('0.0.12345', {
+        memo: 'Updated memo',
+      });
+
+      expect(result).toBeDefined();
+    });
+
+    it('should build account update with max automatic associations', async () => {
+      const result = await service.buildAccountUpdate('0.0.12345', {
+        maxAutomaticTokenAssociations: 50,
+      });
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  // ==================== BATCH INNER TRANSACTIONS ====================
+  describe('buildBatchInnerTransactions', () => {
+    const mockBatchKey = 'mock-batch-public-key';
+
+    it('should build batch with send-hbar', async () => {
+      const result = await service.buildBatchInnerTransactions('0.0.12345', mockBatchKey, [
+        { type: 'send-hbar', toAccount: '0.0.67890', amount: 100_000_000 },
+      ]);
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(1);
+      expect(result[0].payload).toBeDefined();
+      expect(result[0].description).toContain('tinybar');
+    });
+
+    it('should build batch with send-token', async () => {
+      const result = await service.buildBatchInnerTransactions('0.0.12345', mockBatchKey, [
+        {
+          type: 'send-token',
+          toAccount: '0.0.67890',
+          tokenId: '0.0.98765',
+          amount: 1000,
+        },
+      ]);
+
+      expect(result).toBeDefined();
+      expect(result.length).toBe(1);
+    });
+
+    it('should build batch with token-mint', async () => {
+      const result = await service.buildBatchInnerTransactions('0.0.12345', mockBatchKey, [
+        { type: 'token-mint', tokenId: '0.0.98765', amount: 100 },
+      ]);
+
+      expect(result).toBeDefined();
+      expect(result.length).toBe(1);
+    });
+
+    it('should build batch with token-mint and metadata', async () => {
+      const result = await service.buildBatchInnerTransactions('0.0.12345', mockBatchKey, [
+        { type: 'token-mint', tokenId: '0.0.98765', amount: 1, metadata: 'test-metadata' },
+      ]);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should build batch with token-associate', async () => {
+      const result = await service.buildBatchInnerTransactions('0.0.12345', mockBatchKey, [
+        { type: 'token-associate', tokenId: '0.0.98765' },
+      ]);
+
+      expect(result).toBeDefined();
+      expect(result.length).toBe(1);
+    });
+
+    it('should build batch with multiple transactions', async () => {
+      const result = await service.buildBatchInnerTransactions('0.0.12345', mockBatchKey, [
+        { type: 'send-hbar', toAccount: '0.0.67890', amount: 100_000_000 },
+        { type: 'send-hbar', toAccount: '0.0.11111', amount: 50_000_000 },
+        { type: 'token-associate', tokenId: '0.0.98765' },
+      ]);
+
+      expect(result).toBeDefined();
+      expect(result.length).toBe(3);
+    });
+
+    it('should throw error for unknown transaction type', async () => {
+      await expect(
+        service.buildBatchInnerTransactions('0.0.12345', mockBatchKey, [
+          { type: 'unknown-type' as any, toAccount: '0.0.67890' },
+        ]),
+      ).rejects.toThrow('Unknown transaction type');
+    });
+  });
+
+  // ==================== KEY CONFIG ====================
+  describe('key configuration', () => {
+    it('should auto-detect single-sig key from active account', async () => {
+      // Active account has publicKey in metadata
+      const options: TokenCreateOptions = {
+        name: 'Auto Key Token',
+        symbol: 'AKT',
+        decimals: 8,
+        initialSupply: 1_000_000,
+      };
+
+      const result = await service.buildTokenCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+      // The logger should have been called with debug about single-sig
+    });
+
+    it('should auto-detect multisig key from active account', async () => {
+      // Set up multisig account
+      mockWalletService.activeAccount.set({
+        ...mockAccount,
+        metadata: {
+          isMultisig: true,
+          signerPublicKeys: ['key1', 'key2', 'key3'],
+          threshold: 2,
+        },
+      });
+
+      const options: TokenCreateOptions = {
+        name: 'Multisig Token',
+        symbol: 'MST',
+        decimals: 8,
+        initialSupply: 1_000_000,
+      };
+
+      const result = await service.buildTokenCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should use explicitly provided key config over auto-detected', async () => {
+      const options: TokenCreateOptions = {
+        name: 'Explicit Key Token',
+        symbol: 'EKT',
+        decimals: 8,
+        initialSupply: 1_000_000,
+        adminKey: { publicKey: 'explicit-admin-key' },
+        supplyKey: { publicKey: 'explicit-supply-key' },
+      };
+
+      const result = await service.buildTokenCreate('0.0.12345', options);
+
+      expect(result).toBeDefined();
+    });
+  });
+
+  // ==================== NETWORK SELECTION ====================
+  describe('network selection', () => {
+    it('should use testnet for hedera:testnet', async () => {
+      mockWalletService.activeAccount.set({
+        ...mockAccount,
+        networkId: 'hedera:testnet',
+      });
+
+      const result = await service.buildSendHbar('0.0.12345', '0.0.67890', 10);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should use mainnet for hedera:mainnet', async () => {
+      mockWalletService.activeAccount.set({
+        ...mockAccount,
+        networkId: 'hedera:mainnet',
+      });
+
+      const result = await service.buildSendHbar('0.0.12345', '0.0.67890', 10);
+
+      expect(result).toBeDefined();
+    });
+
+    it('should default to testnet for unknown network', async () => {
+      mockWalletService.activeAccount.set({
+        ...mockAccount,
+        networkId: 'hedera:unknown',
+      });
+
+      const result = await service.buildSendHbar('0.0.12345', '0.0.67890', 10);
+
+      expect(result).toBeDefined();
+      expect(mockLogger.warn).toHaveBeenCalledWith(
+        'Unknown Hedera network, defaulting to testnet',
+        expect.any(Object),
+      );
+    });
+  });
+});