@make-software/cspr-trade-mcp-sdk 0.1.0

package/tests/integration/api.integration.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest';
+import { CsprTradeClient } from '../../src/client.js';
+
+const SHOULD_RUN = !!process.env.CSPR_TRADE_INTEGRATION;
+
+describe.skipIf(!SHOULD_RUN)('SDK Integration Tests (testnet)', () => {
+  const client = new CsprTradeClient({ network: 'testnet' });
+
+  it('should fetch tokens from testnet', async () => {
+    const tokens = await client.getTokens();
+    expect(tokens.length).toBeGreaterThan(0);
+    const cspr = tokens.find(t => t.symbol === 'CSPR');
+    expect(cspr).toBeDefined();
+  });
+
+  it('should fetch tokens with USD pricing', async () => {
+    const tokens = await client.getTokens('USD');
+    expect(tokens.length).toBeGreaterThan(0);
+    const cspr = tokens.find(t => t.symbol === 'CSPR');
+    expect(cspr).toBeDefined();
+    expect(cspr!.fiatPrice).toBeTypeOf('number');
+  });
+
+  it('should fetch pairs from testnet', async () => {
+    const result = await client.getPairs({ page: 1, pageSize: 5 });
+    expect(result.data.length).toBeGreaterThan(0);
+  });
+
+  it('should fetch currencies', async () => {
+    const currencies = await client.getCurrencies();
+    expect(currencies.length).toBeGreaterThan(0);
+    const usd = currencies.find(c => c.code === 'USD');
+    expect(usd).toBeDefined();
+  });
+
+  it('should resolve tokens by symbol', async () => {
+    const token = await client.resolveToken('CSPR');
+    expect(token.symbol).toBe('CSPR');
+    expect(token.decimals).toBe(9);
+  });
+
+  it('should get a swap quote', async () => {
+    const tokens = await client.getTokens();
+    // Find any non-CSPR token to pair with
+    const otherToken = tokens.find(t => t.symbol !== 'CSPR' && t.symbol !== 'WCSPR');
+    if (!otherToken) {
+      console.warn('No non-CSPR token found on testnet, skipping quote test');
+      return;
+    }
+
+    const quote = await client.getQuote({
+      tokenIn: 'CSPR',
+      tokenOut: otherToken.symbol,
+      amount: '100',
+      type: 'exact_in',
+    });
+
+    expect(quote.amountIn).toBeDefined();
+    expect(quote.amountOut).toBeDefined();
+    expect(quote.tokenInSymbol).toBe('CSPR');
+    expect(quote.tokenOutSymbol).toBe(otherToken.symbol);
+    expect(quote.pathSymbols.length).toBeGreaterThanOrEqual(2);
+  });
+});

package/tests/unit/api/http.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { HttpClient } from '../../../src/api/http.js';
+
+describe('HttpClient', () => {
+  let client: HttpClient;
+
+  beforeEach(() => {
+    client = new HttpClient('https://api.example.com');
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should make GET requests with correct URL', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(new Response(JSON.stringify({ data: 'test' })));
+
+    await client.get('/tokens');
+
+    expect(fetch).toHaveBeenCalledWith(
+      'https://api.example.com/tokens',
+      expect.objectContaining({ method: 'GET' })
+    );
+  });
+
+  it('should append query parameters', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(new Response(JSON.stringify({ data: 'test' })));
+
+    await client.get('/tokens', { includes: 'csprtrade_data(1)' });
+
+    expect(fetch).toHaveBeenCalledWith(
+      'https://api.example.com/tokens?includes=csprtrade_data%281%29',
+      expect.anything()
+    );
+  });
+
+  it('should parse JSON responses', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(
+      new Response(JSON.stringify({ data: [{ id: 1 }] }))
+    );
+
+    const result = await client.get<{ data: { id: number }[] }>('/tokens');
+    expect(result.data).toEqual([{ id: 1 }]);
+  });
+
+  it('should throw on HTTP errors', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(
+      new Response(JSON.stringify({ error: { message: 'Not found' } }), { status: 404 })
+    );
+
+    await expect(client.get('/missing')).rejects.toThrow();
+  });
+
+  it('should make POST requests with body', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(new Response(JSON.stringify({ data: 'ok' })));
+
+    await client.post('/submit', { key: 'value' });
+
+    expect(fetch).toHaveBeenCalledWith(
+      'https://api.example.com/submit',
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({ key: 'value' }),
+      })
+    );
+  });
+});

package/tests/unit/api/liquidity.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { LiquidityApi } from '../../../src/api/liquidity.js';
+import { HttpClient } from '../../../src/api/http.js';
+
+vi.mock('../../../src/api/http.js');
+
+describe('LiquidityApi', () => {
+  let api: LiquidityApi;
+  let mockHttp: HttpClient;
+
+  beforeEach(() => {
+    mockHttp = new HttpClient('https://api.example.com');
+    api = new LiquidityApi(mockHttp);
+  });
+
+  it('should fetch liquidity positions', async () => {
+    vi.mocked(mockHttp.get).mockResolvedValueOnce({
+      data: [{
+        account_hash: 'account-hash-abc',
+        pair_contract_package_hash: 'hash-pair1',
+        lp_token_balance: '1000000',
+        pair: { token0_contract_package: { metadata: { symbol: 'CSPR' } }, token1_contract_package: { metadata: { symbol: 'USDT' } } },
+        pair_lp_tokens_total_supply: '10000000',
+      }],
+    });
+
+    const positions = await api.getPositions('01abc123');
+    expect(positions).toHaveLength(1);
+    expect(positions[0].pair_contract_package_hash).toBe('hash-pair1');
+  });
+
+  it('should fetch impermanent loss', async () => {
+    vi.mocked(mockHttp.get).mockResolvedValueOnce({
+      data: { value: '-2.5', pair_contract_package_hash: 'hash-pair1', account_hash: 'account-hash-abc', timestamp: '2025-01-01T00:00:00Z' },
+    });
+
+    const il = await api.getImpermanentLoss('01abc123', 'hash-pair1');
+    expect(il.value).toBe('-2.5');
+  });
+});

package/tests/unit/api/pairs.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PairsApi } from '../../../src/api/pairs.js';
+import { HttpClient } from '../../../src/api/http.js';
+
+vi.mock('../../../src/api/http.js');
+
+const MOCK_PAIR = {
+  contract_package_hash: 'hash-pair1',
+  token0_contract_package_hash: 'hash-token0',
+  token1_contract_package_hash: 'hash-token1',
+  decimals0: 9,
+  decimals1: 6,
+  reserve0: '1000000000000',
+  reserve1: '500000000',
+  timestamp: '2025-01-01T00:00:00Z',
+  latest_event_id: '123',
+  contract_package: { name: 'Pair' },
+  token0_contract_package: { metadata: { symbol: 'CSPR', name: 'Casper', decimals: 9 }, icon_url: null, csprtrade_data: { price: 0.02 } },
+  token1_contract_package: { metadata: { symbol: 'USDT', name: 'Tether', decimals: 6 }, icon_url: null, csprtrade_data: { price: 1.0 } },
+};
+
+describe('PairsApi', () => {
+  let api: PairsApi;
+  let mockHttp: HttpClient;
+
+  beforeEach(() => {
+    mockHttp = new HttpClient('https://api.example.com');
+    api = new PairsApi(mockHttp);
+  });
+
+  it('should fetch paginated pairs', async () => {
+    vi.mocked(mockHttp.get).mockResolvedValueOnce({
+      data: [MOCK_PAIR],
+      item_count: 1,
+      page_count: 1,
+    });
+
+    const result = await api.getPairs({ page: 1, pageSize: 10 });
+
+    expect(result.data).toHaveLength(1);
+    expect(result.data[0].token0.symbol).toBe('CSPR');
+    expect(result.itemCount).toBe(1);
+  });
+
+  it('should fetch pair by hash', async () => {
+    vi.mocked(mockHttp.get).mockResolvedValueOnce({ data: MOCK_PAIR });
+
+    const pair = await api.getPairDetails('hash-pair1');
+
+    expect(pair.contractPackageHash).toBe('hash-pair1');
+    expect(pair.token0.symbol).toBe('CSPR');
+  });
+});

package/tests/unit/api/quotes.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { QuotesApi } from '../../../src/api/quotes.js';
+import { HttpClient } from '../../../src/api/http.js';
+
+vi.mock('../../../src/api/http.js');
+
+describe('QuotesApi', () => {
+  let api: QuotesApi;
+  let mockHttp: HttpClient;
+
+  beforeEach(() => {
+    mockHttp = new HttpClient('https://api.example.com');
+    api = new QuotesApi(mockHttp);
+  });
+
+  it('should fetch exact-in quote', async () => {
+    vi.mocked(mockHttp.get).mockResolvedValueOnce({
+      data: {
+        amount_in: '100000000000',
+        amount_out: '50000000',
+        execution_price: '50000000',
+        mid_price: '50100000',
+        path: ['hash-wcspr', 'hash-usdt'],
+        price_impact: '0.20',
+        recommended_slippage_bps: '20',
+        type_id: 1,
+      },
+    });
+
+    const quote = await api.getQuote({
+      tokenIn: 'hash-0000',
+      tokenOut: 'hash-usdt',
+      amount: '100000000000',
+      typeId: 1,
+    });
+
+    expect(quote.amount_in).toBe('100000000000');
+    expect(quote.amount_out).toBe('50000000');
+    expect(quote.price_impact).toBe('0.20');
+  });
+
+  it('should pass correct query params', async () => {
+    vi.mocked(mockHttp.get).mockResolvedValueOnce({ data: {} });
+
+    await api.getQuote({
+      tokenIn: 'hash-aaa',
+      tokenOut: 'hash-bbb',
+      amount: '1000',
+      typeId: 2,
+    });
+
+    expect(mockHttp.get).toHaveBeenCalledWith('/quote', {
+      token_in: 'hash-aaa',
+      token_out: 'hash-bbb',
+      amount: '1000',
+      type_id: '2',
+    });
+  });
+});

package/tests/unit/api/rates.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RatesApi } from '../../../src/api/rates.js';
+import { HttpClient } from '../../../src/api/http.js';
+
+vi.mock('../../../src/api/http.js');
+
+describe('RatesApi', () => {
+  let api: RatesApi;
+  let mockHttp: HttpClient;
+
+  beforeEach(() => {
+    mockHttp = new HttpClient('https://api.example.com');
+    api = new RatesApi(mockHttp);
+  });
+
+  it('should fetch CSPR fiat rate', async () => {
+    vi.mocked(mockHttp.get).mockResolvedValueOnce({ data: { rate: 0.025 } });
+    const rate = await api.getCsprRate(1);
+    expect(mockHttp.get).toHaveBeenCalledWith('/rates/1/latest');
+  });
+
+  it('should fetch token fiat rate', async () => {
+    vi.mocked(mockHttp.get).mockResolvedValueOnce({ data: { amount: '1.00' } });
+    const rate = await api.getTokenRate('hash-abc', 1);
+    expect(mockHttp.get).toHaveBeenCalledWith('/ft/hash-abc/rates/latest', { currency_id: '1' });
+  });
+});

package/tests/unit/api/tokens.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TokensApi } from '../../../src/api/tokens.js';
+import { HttpClient } from '../../../src/api/http.js';
+
+vi.mock('../../../src/api/http.js');
+
+const WCSPR_HASH = 'hash-3d80df21ba4ee4d66a2a1f60c32570dd5685e4b279f6538162a5fd1314847c1e';
+
+describe('TokensApi', () => {
+  let api: TokensApi;
+  let mockHttp: HttpClient;
+
+  beforeEach(() => {
+    mockHttp = new HttpClient('https://api.example.com');
+    vi.mocked(mockHttp.get).mockResolvedValue({
+      data: [
+        {
+          contract_package_hash: WCSPR_HASH,
+          contract_package: {
+            contract_package_hash: WCSPR_HASH,
+            name: 'Wrapped CSPR',
+            metadata: { symbol: 'WCSPR', name: 'Wrapped CSPR', decimals: 9 },
+            icon_url: 'https://example.com/cspr.png',
+            csprtrade_data: { price: 0.02 },
+          },
+          listed_at: '2025-01-01T00:00:00Z',
+          sorting_order: 0,
+        },
+        {
+          contract_package_hash: 'hash-abc123',
+          contract_package: {
+            contract_package_hash: 'hash-abc123',
+            name: 'USD Tether',
+            metadata: { symbol: 'USDT', name: 'USD Tether', decimals: 6 },
+            icon_url: 'https://example.com/usdt.png',
+            csprtrade_data: { price: 1.0 },
+          },
+          listed_at: '2025-01-01T00:00:00Z',
+          sorting_order: 1,
+        },
+      ],
+    });
+    api = new TokensApi(mockHttp, WCSPR_HASH);
+  });
+
+  it('should transform WCSPR into virtual CSPR token', async () => {
+    const tokens = await api.getTokens(1);
+
+    expect(mockHttp.get).toHaveBeenCalledWith('/tokens', {
+      includes: 'csprtrade_data(1)',
+    });
+    expect(tokens).toHaveLength(2);
+    // WCSPR is transformed into CSPR
+    expect(tokens[0].id).toBe('cspr');
+    expect(tokens[0].symbol).toBe('CSPR');
+    expect(tokens[0].name).toBe('Casper');
+    expect(tokens[0].packageHash).toBe(WCSPR_HASH); // keeps real WCSPR hash
+    expect(tokens[0].decimals).toBe(9);
+    expect(tokens[0].fiatPrice).toBe(0.02);
+    // USDT unchanged
+    expect(tokens[1].symbol).toBe('USDT');
+    expect(tokens[1].decimals).toBe(6);
+  });
+
+  it('should fetch tokens without currency', async () => {
+    await api.getTokens();
+    expect(mockHttp.get).toHaveBeenCalledWith('/tokens', {
+      includes: undefined,
+    });
+  });
+
+  it('should not include CSPR if WCSPR is not in the token list', async () => {
+    vi.mocked(mockHttp.get).mockResolvedValueOnce({
+      data: [
+        {
+          contract_package_hash: 'hash-abc123',
+          contract_package: {
+            contract_package_hash: 'hash-abc123',
+            name: 'USD Tether',
+            metadata: { symbol: 'USDT', name: 'USD Tether', decimals: 6 },
+            icon_url: null,
+            csprtrade_data: null,
+          },
+          listed_at: '2025-01-01T00:00:00Z',
+          sorting_order: 1,
+        },
+      ],
+    });
+
+    const tokens = await api.getTokens();
+    const csprTokens = tokens.filter(t => t.id === 'cspr');
+    expect(csprTokens).toHaveLength(0);
+  });
+
+  it('should return raw API response via getTokensRaw', async () => {
+    const raw = await api.getTokensRaw(1);
+    expect(raw).toHaveLength(2);
+    expect(raw[0].contract_package_hash).toBe(WCSPR_HASH);
+  });
+});

package/tests/unit/assets/proxy-caller.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { getProxyCallerWasm } from '../../../src/assets/index.js';
+
+describe('getProxyCallerWasm', () => {
+  it('should load the proxy_caller.wasm binary', async () => {
+    const wasm = await getProxyCallerWasm();
+    expect(wasm).toBeInstanceOf(Uint8Array);
+    expect(wasm.length).toBeGreaterThan(0);
+    // WASM magic bytes: \0asm
+    expect(wasm[0]).toBe(0x00);
+    expect(wasm[1]).toBe(0x61); // 'a'
+    expect(wasm[2]).toBe(0x73); // 's'
+    expect(wasm[3]).toBe(0x6d); // 'm'
+  });
+
+  it('should cache the binary on subsequent calls', async () => {
+    const wasm1 = await getProxyCallerWasm();
+    const wasm2 = await getProxyCallerWasm();
+    expect(wasm1).toBe(wasm2); // same reference
+  });
+});

package/tests/unit/client.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CsprTradeClient } from '../../src/client.js';
+
+// Mock fetch globally
+global.fetch = vi.fn();
+
+describe('CsprTradeClient', () => {
+  let client: CsprTradeClient;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    client = new CsprTradeClient({ network: 'testnet' });
+  });
+
+  it('should create with testnet config', () => {
+    expect(client).toBeDefined();
+  });
+
+  it('should create with custom API URL', () => {
+    const custom = new CsprTradeClient({
+      network: 'testnet',
+      apiUrl: 'https://custom-api.example.com',
+    });
+    expect(custom).toBeDefined();
+  });
+
+  it('should expose getTokens method', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(
+      new Response(JSON.stringify({ data: [] }))
+    );
+
+    const tokens = await client.getTokens();
+    expect(Array.isArray(tokens)).toBe(true);
+  });
+
+  it('should expose getQuote method', async () => {
+    // First call: getTokens for resolution (WCSPR gets transformed to CSPR)
+    vi.mocked(fetch).mockResolvedValueOnce(
+      new Response(JSON.stringify({
+        data: [
+          { contract_package_hash: 'hash-3d80df21ba4ee4d66a2a1f60c32570dd5685e4b279f6538162a5fd1314847c1e', contract_package: { metadata: { symbol: 'WCSPR', name: 'Wrapped CSPR', decimals: 9 } } },
+          { contract_package_hash: 'hash-aaa', contract_package: { metadata: { symbol: 'USDT', name: 'Tether', decimals: 6 } } },
+        ],
+      }))
+    );
+    // Second call: the actual quote
+    vi.mocked(fetch).mockResolvedValueOnce(
+      new Response(JSON.stringify({
+        data: {
+          amount_in: '100000000000',
+          amount_out: '50000000',
+          execution_price: '0.5',
+          mid_price: '0.5',
+          path: ['hash-wcspr', 'hash-aaa'],
+          price_impact: '0.1',
+          recommended_slippage_bps: '10',
+          type_id: 1,
+        },
+      }))
+    );
+
+    const quote = await client.getQuote({
+      tokenIn: 'CSPR',
+      tokenOut: 'USDT',
+      amount: '100',
+      type: 'exact_in',
+    });
+
+    expect(quote.amountIn).toBe('100000000000');
+    expect(quote.amountOut).toBe('50000000');
+    expect(quote.tokenInSymbol).toBe('CSPR');
+  });
+});

package/tests/unit/config.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { getNetworkConfig, TESTNET_CONFIG, DEFAULT_SLIPPAGE_BPS, DEFAULT_DEADLINE_MINUTES } from '../../src/config.js';
+
+describe('Network Config', () => {
+  it('should return testnet config', () => {
+    const config = getNetworkConfig('testnet');
+    expect(config.chainName).toBe('casper-test');
+    expect(config.apiUrl).toContain('dev.make.services');
+    expect(config.routerPackageHash).toMatch(/^hash-/);
+    expect(config.wcsprPackageHash).toMatch(/^hash-/);
+  });
+
+  it('should return mainnet config', () => {
+    const config = getNetworkConfig('mainnet');
+    expect(config.chainName).toBe('casper');
+    expect(config.routerPackageHash).toMatch(/^hash-/);
+  });
+
+  it('should have correct defaults', () => {
+    expect(DEFAULT_SLIPPAGE_BPS).toBe(300);
+    expect(DEFAULT_DEADLINE_MINUTES).toBe(20);
+  });
+});

package/tests/unit/resolver/currency-resolver.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CurrencyResolver } from '../../../src/resolver/currency-resolver.js';
+import type { Currency } from '../../../src/types/index.js';
+
+const MOCK_CURRENCIES: Currency[] = [
+  { id: 1, code: 'USD', name: 'US Dollar', symbol: '$' },
+  { id: 2, code: 'EUR', name: 'Euro', symbol: '€' },
+];
+
+describe('CurrencyResolver', () => {
+  let resolver: CurrencyResolver;
+
+  beforeEach(() => {
+    const fetchCurrencies = vi.fn().mockResolvedValue(MOCK_CURRENCIES);
+    resolver = new CurrencyResolver(fetchCurrencies);
+  });
+
+  it('should resolve currency code to ID', async () => {
+    const id = await resolver.resolveToId('USD');
+    expect(id).toBe(1);
+  });
+
+  it('should be case-insensitive', async () => {
+    const id = await resolver.resolveToId('eur');
+    expect(id).toBe(2);
+  });
+
+  it('should return undefined for unknown currency', async () => {
+    const id = await resolver.resolveToId('JPY');
+    expect(id).toBeUndefined();
+  });
+});

package/tests/unit/resolver/token-resolver.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TokenResolver } from '../../../src/resolver/token-resolver.js';
+import type { Token } from '../../../src/types/index.js';
+
+const MOCK_TOKENS: Token[] = [
+  { id: 'cspr', name: 'Casper', symbol: 'CSPR', decimals: 9, packageHash: 'hash-0000000000000000000000000000000000000000000000000000000000000000', iconUrl: null, fiatPrice: null },
+  { id: 'hash-aaa111', name: 'USD Tether', symbol: 'USDT', decimals: 6, packageHash: 'hash-aaa111', iconUrl: null, fiatPrice: 1.0 },
+  { id: 'hash-bbb222', name: 'Wrapped Casper', symbol: 'WCSPR', decimals: 9, packageHash: 'hash-bbb222', iconUrl: null, fiatPrice: null },
+];
+
+describe('TokenResolver', () => {
+  let resolver: TokenResolver;
+  let fetchTokens: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    fetchTokens = vi.fn().mockResolvedValue(MOCK_TOKENS);
+    resolver = new TokenResolver(fetchTokens);
+  });
+
+  it('should resolve by symbol (case-insensitive)', async () => {
+    const token = await resolver.resolve('usdt');
+    expect(token.symbol).toBe('USDT');
+    expect(token.packageHash).toBe('hash-aaa111');
+  });
+
+  it('should resolve CSPR as native token', async () => {
+    const token = await resolver.resolve('CSPR');
+    expect(token.id).toBe('cspr');
+    expect(token.decimals).toBe(9);
+  });
+
+  it('should resolve by contract package hash', async () => {
+    const token = await resolver.resolve('hash-aaa111');
+    expect(token.symbol).toBe('USDT');
+  });
+
+  it('should resolve by name', async () => {
+    const token = await resolver.resolve('USD Tether');
+    expect(token.symbol).toBe('USDT');
+  });
+
+  it('should throw for unknown token', async () => {
+    await expect(resolver.resolve('UNKNOWN')).rejects.toThrow('Token not found');
+  });
+
+  it('should cache token list', async () => {
+    await resolver.resolve('CSPR');
+    await resolver.resolve('USDT');
+    expect(fetchTokens).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/unit/transactions/approve.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import { buildApproveArgs } from '../../../src/transactions/approve.js';
+
+describe('Approve transaction builder', () => {
+  it('should build approve args with spender and amount', () => {
+    const args = buildApproveArgs({
+      spenderPackageHash: 'hash-04a11a367e708c52557930c4e9c1301f4465100d1b1b6d0a62b48d3e32402867',
+      amount: '100000000000',
+    });
+    const bytes = args.toBytes();
+    expect(bytes.length).toBeGreaterThan(0);
+  });
+});