@interest-protocol/vortex-sdk 0.0.1-alpha.0 → 1.1.0

package/src/__tests__/entities/keypair.spec.ts

@@ -0,0 +1,191 @@
+import { VortexKeypair } from '../../entities/keypair';
+import { BN254_FIELD_MODULUS } from '../../constants';
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+
+describe(VortexKeypair.name, () => {
+  describe('generate', () => {
+    it('should generate a valid keypair', () => {
+      const keypair = VortexKeypair.generate();
+
+      expect(keypair.privateKey).toBeDefined();
+      expect(keypair.publicKey).toBeDefined();
+      expect(keypair.encryptionKey).toBeDefined();
+      expect(typeof keypair.publicKey).toBe('string');
+    });
+
+    it('should generate different keypairs each time', () => {
+      const keypair1 = VortexKeypair.generate();
+      const keypair2 = VortexKeypair.generate();
+
+      expect(keypair1.privateKey).not.toBe(keypair2.privateKey);
+      expect(keypair1.publicKey).not.toBe(keypair2.publicKey);
+    });
+
+    it('should ensure private key is within BN254 field', () => {
+      const keypair = VortexKeypair.generate();
+      expect(keypair.privateKey).toBeLessThanOrEqual(BN254_FIELD_MODULUS);
+    });
+  });
+
+  describe('fromString', () => {
+    it('should create keypair from string', () => {
+      const keypair = VortexKeypair.generate();
+      const keypairString = keypair.toString();
+      const restoredKeypair = VortexKeypair.fromString(keypairString);
+
+      expect(restoredKeypair.publicKey).toBe(keypair.publicKey);
+      expect(restoredKeypair.encryptionKey).toBe(keypair.encryptionKey);
+    });
+
+    it('should handle 0x prefix', () => {
+      const keypair = VortexKeypair.generate();
+      const withPrefix = keypair.toString();
+      const withoutPrefix = withPrefix.slice(2);
+
+      const keypair1 = VortexKeypair.fromString(withPrefix);
+      const keypair2 = VortexKeypair.fromString(withoutPrefix);
+
+      expect(keypair1.publicKey).toBe(keypair2.publicKey);
+    });
+  });
+
+  describe('sign', () => {
+    it('should produce consistent signatures', () => {
+      const keypair = VortexKeypair.generate();
+      const commitment = 123n;
+      const merklePath = 456n;
+
+      const sig1 = keypair.sign(commitment, merklePath);
+      const sig2 = keypair.sign(commitment, merklePath);
+
+      expect(sig1).toBe(sig2);
+    });
+
+    it('should produce different signatures for different inputs', () => {
+      const keypair = VortexKeypair.generate();
+
+      const sig1 = keypair.sign(123n, 456n);
+      const sig2 = keypair.sign(789n, 456n);
+
+      expect(sig1).not.toBe(sig2);
+    });
+  });
+
+  describe('encryption/decryption', () => {
+    it('should encrypt and decrypt UTXO data', () => {
+      const keypair = VortexKeypair.generate();
+      const utxo = {
+        amount: 1000n,
+        blinding: 999n,
+        index: 5n,
+      };
+
+      const encrypted = VortexKeypair.encryptUtxoFor(
+        utxo,
+        keypair.encryptionKey
+      );
+      const decrypted = keypair.decryptUtxo(encrypted);
+
+      expect(decrypted.amount).toBe(utxo.amount);
+      expect(decrypted.blinding).toBe(utxo.blinding);
+      expect(decrypted.index).toBe(utxo.index);
+    });
+
+    it('should fail to decrypt with wrong keypair', () => {
+      const keypair1 = VortexKeypair.generate();
+      const keypair2 = VortexKeypair.generate();
+
+      const utxo = {
+        amount: 1000n,
+        blinding: 999n,
+        index: 5n,
+      };
+
+      const encrypted = VortexKeypair.encryptUtxoFor(
+        utxo,
+        keypair1.encryptionKey
+      );
+
+      // Attempting to decrypt with wrong keypair should throw or produce garbage
+      expect(() => keypair2.decryptUtxo(encrypted)).toThrow();
+    });
+  });
+
+  describe('toString/address', () => {
+    it('should produce consistent string representation', () => {
+      const keypair = VortexKeypair.generate();
+      const str1 = keypair.toString();
+      const str2 = keypair.toString();
+
+      expect(str1).toBe(str2);
+    });
+
+    it('should start with 0x', () => {
+      const keypair = VortexKeypair.generate();
+      expect(keypair.toString()).toMatch(/^0x/);
+    });
+
+    it('address should match toString', () => {
+      const keypair = VortexKeypair.generate();
+      expect(keypair.address()).toBe(keypair.toString());
+    });
+  });
+
+  describe('fromSuiWallet', () => {
+    it('should create keypair from Sui wallet', async () => {
+      const suiWallet = Ed25519Keypair.generate();
+
+      const keypair = await VortexKeypair.fromSuiWallet(
+        suiWallet.toSuiAddress(),
+        async (message) => suiWallet.signPersonalMessage(message)
+      );
+
+      expect(keypair.publicKey).toBeDefined();
+      expect(keypair.encryptionKey).toBeDefined();
+      expect(keypair.privateKey).toBeDefined();
+      expect(typeof keypair.privateKey).toBe('bigint');
+      expect(typeof keypair.publicKey).toBe('string');
+      expect(typeof keypair.encryptionKey).toBe('string');
+      expect(keypair.privateKey).toBeLessThanOrEqual(BN254_FIELD_MODULUS);
+    });
+
+    it('should recreate the same keypair from the same Sui wallet', async () => {
+      const suiWallet = Ed25519Keypair.generate();
+      const keypair = await VortexKeypair.fromSuiWallet(
+        suiWallet.toSuiAddress(),
+        async (message) => suiWallet.signPersonalMessage(message)
+      );
+
+      const keypair2 = await VortexKeypair.fromSuiWallet(
+        suiWallet.toSuiAddress(),
+        async (message) => suiWallet.signPersonalMessage(message)
+      );
+
+      expect(keypair.publicKey).toBe(keypair2.publicKey);
+      expect(keypair.encryptionKey).toBe(keypair2.encryptionKey);
+      expect(keypair.privateKey).toBe(keypair2.privateKey);
+      expect(keypair.address()).toBe(keypair2.address());
+      expect(keypair.toString()).toBe(keypair2.toString());
+    });
+
+    it('should create a different keypair for a different Sui wallet', async () => {
+      const suiWallet1 = Ed25519Keypair.generate();
+      const suiWallet2 = Ed25519Keypair.generate();
+
+      const keypair1 = await VortexKeypair.fromSuiWallet(
+        suiWallet1.toSuiAddress(),
+        async (message) => suiWallet1.signPersonalMessage(message)
+      );
+      const keypair2 = await VortexKeypair.fromSuiWallet(
+        suiWallet2.toSuiAddress(),
+        async (message) => suiWallet2.signPersonalMessage(message)
+      );
+
+      expect(keypair1.publicKey).not.toBe(keypair2.publicKey);
+      expect(keypair1.encryptionKey).not.toBe(keypair2.encryptionKey);
+      expect(keypair1.privateKey).not.toBe(keypair2.privateKey);
+      expect(keypair1.address()).not.toBe(keypair2.address());
+      expect(keypair1.toString()).not.toBe(keypair2.toString());
+    });
+  });
+});

package/src/__tests__/test-utils.ts

@@ -0,0 +1,76 @@
+import { SuiClient, getFullnodeUrl } from '@mysten/sui/client';
+import { Transaction, TransactionArgument } from '@mysten/sui/transactions';
+
+import { Vortex } from '../vortex';
+
+export const devnetSuiClient = new SuiClient({
+  url: getFullnodeUrl('devnet'),
+});
+
+export const TEST_VORTEX_PACKAGE_ID =
+  '0xe5c3cc57317735311a9e054fa3d59c625d6e530ab9b9499409c4a7157fbfbaba';
+
+export const TEST_VORTEX_SHARED_OBJECT_ID =
+  '0x9751819ded69b113eea0ca81b4fcb95be8a07b166a88858ce58057417b5713d3';
+
+export const TEST_REGISTRY_SHARED_OBJECT_ID =
+  '0x86b4429f15c699d4a225474be82490f1165c1123228dcfedc6966c245b840ac2';
+
+export const TEST_UPGRADE_CAP_ID =
+  '0xb76878578f39017a04a892e7250a146c13663282de80876fae7d62fb5b073f4b';
+
+export const TEST_REGISTRY_INITIAL_SHARED_VERSION = '8';
+
+export const TEST_VORTEX_INITIAL_SHARED_VERSION = '8';
+
+interface ExpectDevInspectTransactionBlockArgs {
+  tx: Transaction;
+  sender: string;
+  expectStatus: 'success' | 'failure';
+}
+
+export const expectDevInspectTransactionBlock = async ({
+  tx,
+  sender,
+  expectStatus,
+}: ExpectDevInspectTransactionBlockArgs) => {
+  const result = await devnetSuiClient.devInspectTransactionBlock({
+    sender,
+    transactionBlock: tx,
+  });
+
+  if (result.effects.status.status !== expectStatus) {
+    console.log(result);
+  }
+  expect(result.effects.status.status).toBe(expectStatus);
+};
+
+export const testVortex = new Vortex({
+  registry: {
+    objectId: TEST_REGISTRY_SHARED_OBJECT_ID,
+    initialSharedVersion: TEST_REGISTRY_INITIAL_SHARED_VERSION,
+  },
+  vortex: {
+    objectId: TEST_VORTEX_SHARED_OBJECT_ID,
+    initialSharedVersion: TEST_VORTEX_INITIAL_SHARED_VERSION,
+  },
+  packageId: TEST_VORTEX_PACKAGE_ID,
+});
+
+interface AssertValueArgs {
+  tx: Transaction;
+  typeArguments: string[];
+  args: TransactionArgument[];
+}
+
+export const assertValueMoveCall = ({
+  tx,
+  typeArguments,
+  args,
+}: AssertValueArgs) => {
+  tx.moveCall({
+    target: `${TEST_VORTEX_PACKAGE_ID}::vortex::assert_value`,
+    arguments: args,
+    typeArguments: typeArguments,
+  });
+};

package/src/__tests__/types.ts

@@ -0,0 +1,3 @@
+export const STRING_TYPE_ARGUMENT = '0x1::string::String';
+
+export const OPTION_STRING_TYPE_ARGUMENT = `0x1::option::Option<${STRING_TYPE_ARGUMENT}>`;

package/src/__tests__/vortex.test.ts

@@ -0,0 +1,25 @@
+import { testVortex } from './test-utils';
+import { MERKLE_TREE_HEIGHT, EMPTY_SUBTREE_HASHES } from '../constants';
+
+describe('Vortex', () => {
+  it('should get the TVL', async () => {
+    const tvl = await testVortex.tvl();
+    expect(tvl).toBe(0n);
+  });
+
+  it('should get the root', async () => {
+    const root = await testVortex.root();
+    expect(root).toBe(String(EMPTY_SUBTREE_HASHES[MERKLE_TREE_HEIGHT]));
+  });
+
+  it('should get the next index', async () => {
+    const nextIndex = await testVortex.nextIndex();
+    expect(nextIndex).toBe('0');
+  });
+
+  it('should check if a nullifier is spent', async () => {
+    const nullifier = 12345n;
+    const isNullifierSpent = await testVortex.isNullifierSpent(nullifier);
+    expect(isNullifierSpent).toBe(false);
+  });
+});

package/src/constants.ts

@@ -0,0 +1,104 @@
+export const BN254_FIELD_MODULUS =
+  21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+
+// ZERO_VALUE := Poseidon("vortex")
+export const ZERO_VALUE =
+  18688842432741139442778047327644092677418528270738216181718229581494125774932n;
+
+export const EMPTY_COMMITMENT = ZERO_VALUE;
+
+export enum Output {
+  HasCommitments,
+  NoCommitments,
+}
+
+export const EMPTY_SUBTREE_HASHES = [
+  ZERO_VALUE,
+  929670100605127589096201729966801143828059989180770638007278601230757123028n,
+  20059153686521406362481271315473498068253845102360114882796737328118528819600n,
+  667276972495892769517195136104358636854444397700904910347259067486374491460n,
+  12333205860481369973758777121486440301866097422034925170601892818077919669856n,
+  13265906118204670164732063746425660672195834675096811019428798251172285860978n,
+  3254533810100792365765975246297999341668420141674816325048742255119776645299n,
+  18309808253444361227126414342398728022042151803316641228967342967902364963927n,
+  12126650299593052178871547753567584772895820192048806970138326036720774331291n,
+  9949817351285988369728267498508465715570337443235086859122087250007803517342n,
+  11208526958197959509185914785003803401681281543885952782991980697855275912368n,
+  59685738145310886711325295148553591612803302297715439999772116453982910402n,
+  20837058910394942465479261789141487609029093821244922450759151002393360448717n,
+  8209451842087447702442792222326370366485985268583914555249981462794434142285n,
+  19651337661238139284113069695072175498780734789512991455990330919229086149402n,
+  11527931080332651861006914960138009072130600556413592683110711451245237795573n,
+  20764556403192106825184782309105498322242675071639346714780565918367449744227n,
+  10818178251908058160377157228631396071771716850372988172358158281935915764080n,
+  21598305620835755437985090087223184201582363356396834169567261294737143234327n,
+  16481295130402928965223624965091828506529631770925981912487987233811901391354n,
+  17911512007742433173433956238979622028159186641781974955249650899638270671335n,
+  5186032540459307640178997905000265487821097518169449170073506338735292796958n,
+  19685513117592528774434273738957742787082069361009067298107167967352389473358n,
+  10912258653908058948673432107359060806004349811796220228800269957283778663923n,
+  19880031465088514794850462701773174075421406509504511537647395867323147191667n,
+  18344394662872801094289264994998928886741543433797415760903591256277307773470n,
+  4023688209857926016730691838838984168964497755397275208674494663143007853450n,
+  17055783594241143909439856980092099474877726697157440085377630370122026265082n,
+  11977926289934490781035408984815805799047418332367129159688326349739029448709n,
+  15234625627661323144444670162795779218620386251655457701229891659668427854091n,
+  7411478947588169403968017607782514706815527017510001740123258574686422728877n,
+  3160803355012082913337590211745210499441340098978812414661765381488126569348n,
+];
+
+export enum Modules {
+  ExtData = 'vortex_ext_data',
+  Proof = 'vortex_proof',
+  Vortex = 'vortex',
+}
+
+export const ROOT_HISTORY_SIZE = 100;
+
+export const MERKLE_TREE_HEIGHT = 26;
+
+export const ERROR_CODES = {
+  0: 'Invalid allowed deposit value',
+  1: 'Merkle tree overflow',
+  2: 'Proof root not known',
+  3: 'Invalid Poseidon input',
+  4: 'Invalid proof',
+  5: 'Invalid proof vortex',
+  6: 'Invalid address',
+  7: 'Invalid zero value',
+  8: 'Invalid ext data hash',
+  9: 'Invalid ext data value',
+  10: 'Invalid public value',
+  11: 'Nullifier already spent',
+  12: 'Invalid deposit value',
+  13: 'Invalid relayer',
+  14: 'Invalid output flag',
+};
+
+export const VORTEX_PACKAGE_ID =
+  '0x178934e5693d18a8fe9106c5590bb034c717035a94fda19472ca6d989c29f4b3';
+
+export const UPGRADE_CAP =
+  '0x20aa94b46c4297aa07fb5789bc0350a32433933cb47a5392727b6eff73dc3f95';
+
+export const VORTEX_POOL_OBJECT_ID =
+  '0x3a928257e6842ee56607c010162767e081a2756abd9ae4b039ce7c487db49c9f';
+
+export const REGISTRY_OBJECT_ID =
+  '0x55b4b0d3e837937de4438fa70470da9fea8d72627458d68c1195a91b2769867f';
+
+export const INITIAL_SHARED_VERSION = '4';
+
+export const LSK_FETCH_OFFSET = 'fetch_offset';
+
+export const LSK_ENCRYPTED_OUTPUTS = 'encrypted_outputs';
+
+export const VORTEX_SIGNATURE_DOMAIN = 'VORTEXFI.XYZ';
+
+export const TREASURY_ADDRESS =
+  '0x894261575b948c035d002adc3ca4d73c683c01a1bfafac183870940bf9afef1a';
+
+// 0.5% deposit fee
+export const DEPOSIT_FEE_IN_BASIS_POINTS = 50n;
+
+export const BASIS_POINTS = 10_000n;