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

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

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { buildAddLiquidityInnerArgs, buildRemoveLiquidityInnerArgs } from '../../../src/transactions/liquidity.js';
+
+const ACCOUNT_HASH = 'account-hash-0000000000000000000000000000000000000000000000000000000000000000';
+const DEADLINE = Date.now() + 20 * 60 * 1000;
+const TOKEN_A_HASH = 'hash-1111111111111111111111111111111111111111111111111111111111111111';
+const TOKEN_B_HASH = 'hash-2222222222222222222222222222222222222222222222222222222222222222';
+const USDT_HASH = 'hash-3333333333333333333333333333333333333333333333333333333333333333';
+
+describe('Liquidity transaction builders', () => {
+  describe('buildAddLiquidityInnerArgs', () => {
+    it('should build args for token-token add_liquidity', () => {
+      const args = buildAddLiquidityInnerArgs({
+        isCSPRPair: false,
+        tokenAHash: TOKEN_A_HASH,
+        tokenBHash: TOKEN_B_HASH,
+        amountADesired: '1000000',
+        amountBDesired: '2000000',
+        amountAMin: '970000',
+        amountBMin: '1940000',
+        accountHash: ACCOUNT_HASH,
+        deadline: DEADLINE,
+      });
+      const bytes = args.toBytes();
+      expect(bytes.length).toBeGreaterThan(0);
+    });
+
+    it('should build args for CSPR pair add_liquidity_cspr', () => {
+      const args = buildAddLiquidityInnerArgs({
+        isCSPRPair: true,
+        tokenHash: USDT_HASH,
+        amountTokenDesired: '50000000',
+        amountTokenMin: '48500000',
+        amountCSPRMin: '97000000000',
+        accountHash: ACCOUNT_HASH,
+        deadline: DEADLINE,
+      });
+      const bytes = args.toBytes();
+      expect(bytes.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('buildRemoveLiquidityInnerArgs', () => {
+    it('should build args for token-token remove_liquidity', () => {
+      const args = buildRemoveLiquidityInnerArgs({
+        isCSPRPair: false,
+        tokenAHash: TOKEN_A_HASH,
+        tokenBHash: TOKEN_B_HASH,
+        liquidity: '500000',
+        amountAMin: '485000',
+        amountBMin: '970000',
+        accountHash: ACCOUNT_HASH,
+        deadline: DEADLINE,
+      });
+      const bytes = args.toBytes();
+      expect(bytes.length).toBeGreaterThan(0);
+    });
+  });
+});

package/tests/unit/transactions/proxy-wasm.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { buildProxyWasmArgs, serializeInnerArgs } from '../../../src/transactions/proxy-wasm.js';
+import { Args, CLValue, CLTypeKey, Key } from 'casper-js-sdk';
+
+describe('Proxy WASM encoding', () => {
+  it('should serialize inner args to byte array', () => {
+    const innerArgs = Args.fromMap({
+      amount_in: CLValue.newCLUInt256('1000'),
+      to: CLValue.newCLKey(Key.newKey('account-hash-0000000000000000000000000000000000000000000000000000000000000000')),
+    });
+
+    const bytes = serializeInnerArgs(innerArgs);
+    expect(bytes).toBeInstanceOf(Uint8Array);
+    expect(bytes.length).toBeGreaterThan(0);
+  });
+
+  it('should build outer proxy WASM args with correct structure', () => {
+    const routerHash = '04a11a367e708c52557930c4e9c1301f4465100d1b1b6d0a62b48d3e32402867';
+    const innerArgs = Args.fromMap({
+      amount_in: CLValue.newCLUInt256('1000'),
+    });
+
+    const outerArgs = buildProxyWasmArgs({
+      routerPackageHash: routerHash,
+      entryPoint: 'swap_exact_tokens_for_tokens',
+      innerArgs,
+      attachedValue: '0',
+    });
+
+    expect(outerArgs).toBeDefined();
+    const bytes = outerArgs.toBytes();
+    expect(bytes.length).toBeGreaterThan(0);
+  });
+
+  it('should set attached_value and amount for CSPR operations', () => {
+    const routerHash = '04a11a367e708c52557930c4e9c1301f4465100d1b1b6d0a62b48d3e32402867';
+    const innerArgs = Args.fromMap({
+      amount_out_min: CLValue.newCLUInt256('500'),
+    });
+
+    const outerArgs = buildProxyWasmArgs({
+      routerPackageHash: routerHash,
+      entryPoint: 'swap_exact_cspr_for_tokens',
+      innerArgs,
+      attachedValue: '100000000000',
+    });
+
+    expect(outerArgs).toBeDefined();
+  });
+});

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

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import {
+  getSwapEntryPoint,
+  buildSwapInnerArgs,
+} from '../../../src/transactions/swap.js';
+
+describe('Swap transaction builder', () => {
+  describe('getSwapEntryPoint', () => {
+    it('should return swap_exact_cspr_for_tokens for CSPR->Token exact_in', () => {
+      expect(getSwapEntryPoint(true, false, 'exact_in')).toBe('swap_exact_cspr_for_tokens');
+    });
+
+    it('should return swap_cspr_for_exact_tokens for CSPR->Token exact_out', () => {
+      expect(getSwapEntryPoint(true, false, 'exact_out')).toBe('swap_cspr_for_exact_tokens');
+    });
+
+    it('should return swap_exact_tokens_for_cspr for Token->CSPR exact_in', () => {
+      expect(getSwapEntryPoint(false, true, 'exact_in')).toBe('swap_exact_tokens_for_cspr');
+    });
+
+    it('should return swap_tokens_for_exact_cspr for Token->CSPR exact_out', () => {
+      expect(getSwapEntryPoint(false, true, 'exact_out')).toBe('swap_tokens_for_exact_cspr');
+    });
+
+    it('should return swap_exact_tokens_for_tokens for Token->Token exact_in', () => {
+      expect(getSwapEntryPoint(false, false, 'exact_in')).toBe('swap_exact_tokens_for_tokens');
+    });
+
+    it('should return swap_tokens_for_exact_tokens for Token->Token exact_out', () => {
+      expect(getSwapEntryPoint(false, false, 'exact_out')).toBe('swap_tokens_for_exact_tokens');
+    });
+  });
+
+  describe('buildSwapInnerArgs', () => {
+    const ACCOUNT_HASH = 'account-hash-0000000000000000000000000000000000000000000000000000000000000000';
+    const WCSPR_HASH = 'hash-3d80df21ba4ee4d66a2a1f60c32570dd5685e4b279f6538162a5fd1314847c1e';
+    const USDT_HASH = 'hash-1111111111111111111111111111111111111111111111111111111111111111';
+    const TOKEN_A_HASH = 'hash-2222222222222222222222222222222222222222222222222222222222222222';
+    const TOKEN_B_HASH = 'hash-3333333333333333333333333333333333333333333333333333333333333333';
+
+    it('should build inner args for CSPR->Token exact_in', () => {
+      const args = buildSwapInnerArgs({
+        isFirstTokenNative: true,
+        isSecondTokenNative: false,
+        quoteType: 'exact_in',
+        path: [WCSPR_HASH, USDT_HASH],
+        accountHash: ACCOUNT_HASH,
+        deadline: Date.now() + 20 * 60 * 1000,
+        amountIn: '100000000000',
+        amountOut: '50000000',
+        amountInMax: '103000000000',
+        amountOutMin: '48500000',
+      });
+
+      const bytes = args.toBytes();
+      expect(bytes.length).toBeGreaterThan(0);
+    });
+
+    it('should build inner args for Token->Token exact_in', () => {
+      const args = buildSwapInnerArgs({
+        isFirstTokenNative: false,
+        isSecondTokenNative: false,
+        quoteType: 'exact_in',
+        path: [TOKEN_A_HASH, TOKEN_B_HASH],
+        accountHash: ACCOUNT_HASH,
+        deadline: Date.now() + 20 * 60 * 1000,
+        amountIn: '1000000',
+        amountOut: '2000000',
+        amountInMax: '1030000',
+        amountOutMin: '1940000',
+      });
+
+      const bytes = args.toBytes();
+      expect(bytes.length).toBeGreaterThan(0);
+    });
+  });
+});

package/tests/unit/utils/amounts.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { toRawAmount, toFormattedAmount, calculateMinWithSlippage, calculateMaxWithSlippage } from '../../../src/utils/amounts.js';
+
+describe('Amount conversion', () => {
+  it('should convert human amount to raw (CSPR, 9 decimals)', () => {
+    expect(toRawAmount('100', 9)).toBe('100000000000');
+  });
+
+  it('should convert human amount to raw (USDT, 6 decimals)', () => {
+    expect(toRawAmount('50.5', 6)).toBe('50500000');
+  });
+
+  it('should convert human amount to raw (1.23456789, 9 decimals)', () => {
+    expect(toRawAmount('1.23456789', 9)).toBe('1234567890');
+  });
+
+  it('should convert raw to human (CSPR)', () => {
+    expect(toFormattedAmount('100000000000', 9)).toBe('100');
+  });
+
+  it('should convert raw to human (USDT)', () => {
+    expect(toFormattedAmount('50500000', 6)).toBe('50.5');
+  });
+
+  it('should handle zero', () => {
+    expect(toRawAmount('0', 9)).toBe('0');
+    expect(toFormattedAmount('0', 9)).toBe('0');
+  });
+});
+
+describe('Slippage calculations', () => {
+  it('should calculate min amount with 3% slippage', () => {
+    expect(calculateMinWithSlippage('100000000000', 300)).toBe('97000000000');
+  });
+
+  it('should calculate max amount with 3% slippage', () => {
+    expect(calculateMaxWithSlippage('100000000000', 300)).toBe('103000000000');
+  });
+
+  it('should round min down and max up', () => {
+    expect(calculateMinWithSlippage('333', 300)).toBe('323');
+    expect(calculateMaxWithSlippage('333', 300)).toBe('343');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["tests/**/*", "dist/**/*"]
+}