@iota/isc-sdk 0.0.0-dev-20251015065834

package/tests/getHname.spec.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import { getHname } from '../src/utils/getHname';
+import { AccountsContractMethod, CoreContract } from '../src/enums/contracts.enums';
+
+describe('getHname function', () => {
+    it('should return a number for a string input', () => {
+        const result = getHname('test');
+        expect(typeof result).toBe('number');
+    });
+
+    it('should return consistent results for the same input', () => {
+        const input = 'transferAllowanceTo';
+        const result1 = getHname(input);
+        const result2 = getHname(input);
+        expect(result1).toBe(result2);
+    });
+
+    it('should handle empty strings', () => {
+        const result = getHname('');
+        expect(typeof result).toBe('number');
+    });
+
+    it('should generate different hashes for different inputs', () => {
+        const result1 = getHname('deposit');
+        const result2 = getHname('withdraw');
+        expect(result1).not.toBe(result2);
+    });
+
+    it('should generate valid hnames for AccountsContractMethod', () => {
+        const hnames = Object.values(AccountsContractMethod).map((method) => ({
+            method,
+            hname: getHname(method),
+        }));
+
+        // Check all hnames are unique
+        const uniqueHnames = new Set(hnames.map((item) => item.hname));
+        expect(uniqueHnames.size).toBe(hnames.length);
+
+        const accountsHname = hnames.find((h) => h.method === 'transferAllowanceTo')?.hname;
+        expect(accountsHname).toBe(603251617);
+
+        console.table(hnames);
+    });
+
+    it('should generate valid hnames for CoreContract', () => {
+        const hnames = Object.values(CoreContract).map((contract) => ({
+            contract,
+            hname: getHname(contract),
+        }));
+
+        const accountsHname = hnames.find((h) => h.contract === 'accounts')?.hname;
+        expect(accountsHname).toBe(1011572226);
+
+        console.table(hnames);
+    });
+
+    it('should generate hnames in the correct format', () => {
+        // The function returns a number, but it's derived from a hex string
+        // with 8 digits (32 bits)
+        const result = getHname('test');
+        const hexString = result.toString(16);
+        expect(hexString.length).toBeLessThanOrEqual(8);
+    });
+
+    it('should match known test vectors', () => {
+        const testVectors = [
+            { input: 'accounts', expected: 1011572226 },
+            { input: 'transferAllowanceTo', expected: 603251617 },
+            { input: 'deposit', expected: 3184070701 },
+            { input: 'withdraw', expected: 2647396161 },
+            { input: 'balanceBaseToken', expected: 1284295951 },
+        ];
+
+        for (const vector of testVectors) {
+            expect(getHname(vector.input)).toBe(vector.expected);
+        }
+    });
+});

package/tests/utils.ts

@@ -0,0 +1,69 @@
+import type { IotaClient } from '@iota/iota-sdk/client';
+import { requestIotaFromFaucetV0 } from '@iota/iota-sdk/faucet';
+import { Ed25519Keypair } from '@iota/iota-sdk/keypairs/ed25519';
+import { Transaction } from '@iota/iota-sdk/transactions';
+import type { AssetsResponse } from '../src/index.js';
+import { EvmRpcClient } from '../src/index.js';
+import { CONFIG } from './config.js';
+
+const { L2 } = CONFIG;
+
+export async function requestFunds(
+    client: IotaClient,
+    faucetUrl: string,
+    recipientAddress: string,
+) {
+    const keypair = new Ed25519Keypair();
+    const address = keypair.toIotaAddress();
+
+    await requestIotaFromFaucetV0({
+        host: faucetUrl,
+        recipient: address,
+    });
+
+    const transaction = new Transaction();
+    const [coin] = transaction.splitCoins(transaction.gas, [9]);
+    transaction.transferObjects([coin], recipientAddress);
+    transaction.setSender(address);
+
+    await transaction.build({ client });
+
+    await client.signAndExecuteTransaction({
+        signer: keypair,
+        transaction,
+    });
+}
+
+export async function checkL2BalanceWithRetries(
+    address: string,
+    coinType?: string,
+    maxRetries = 10,
+    delay = 2500,
+): Promise<AssetsResponse | null> {
+    const evmClient = new EvmRpcClient(L2.evmRpcUrl);
+    let evmBalance: AssetsResponse | null = null;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            evmBalance = await evmClient.getBalanceBaseToken(address);
+        } catch (error) {
+            console.error('Error checking balance:', error);
+        } finally {
+            const nativeToken = evmBalance?.nativeTokens?.find((t) => t.coinType === coinType);
+            const nativeTokenBalance = nativeToken ? nativeToken.balance : '0';
+
+            if (
+                (evmBalance?.baseTokens.startsWith('0') ||
+                    (coinType && nativeTokenBalance.startsWith('0'))) &&
+                attempt < maxRetries
+            ) {
+                console.log(
+                    `Fetching EVM balance attempt ${attempt + 1} out of ${maxRetries} in ${delay} ms`,
+                );
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+
+    return evmBalance;
+}

package/tsconfig.esm.json

@@ -0,0 +1,7 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "module": "ESNext",
+        "outDir": "dist/esm"
+    }
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+    "extends": "../build-scripts/tsconfig.shared.json",
+    "include": ["src"],
+    "compilerOptions": {
+        "module": "CommonJS",
+        "outDir": "dist/cjs",
+        "rootDir": "src",
+        "isolatedModules": true
+    },
+    "references": [{ "path": "../bcs" }]
+}

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        minWorkers: 1,
+        maxWorkers: 4,
+        hookTimeout: 1000000,
+        testTimeout: 1000000,
+    },
+});