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

package/src/utils/index.ts

@@ -0,0 +1,152 @@
+import { toHex } from '@mysten/sui/utils';
+import invariant from 'tiny-invariant';
+import { MerkleTree } from '../entities/merkle-tree';
+import { Utxo } from '../entities/utxo';
+import { VortexKeypair } from '../entities/keypair';
+import { ZERO_VALUE, MERKLE_TREE_HEIGHT } from '../constants';
+import { poseidon2 } from '../crypto';
+
+export const reverseBytes = (bytes: Uint8Array): Uint8Array => {
+  const reversed = new Uint8Array(bytes.length);
+  for (let i = 0; i < bytes.length; i++) {
+    reversed[i] = bytes[bytes.length - 1 - i]!;
+  }
+  return reversed;
+};
+
+export const bytesToBigInt = (bytes: Uint8Array): bigint => {
+  return BigInt('0x' + toHex(bytes));
+};
+
+export function getMerklePath(
+  merkleTree: MerkleTree,
+  utxo: Utxo | null
+): [string, string][] {
+  // Handle zero-amount UTXOs
+  if (!utxo || utxo.amount === 0n) {
+    return Array(MERKLE_TREE_HEIGHT)
+      .fill(null)
+      .map(() => [ZERO_VALUE.toString(), ZERO_VALUE.toString()]);
+  }
+
+  const utxoIndex = Number(utxo.index);
+  const treeSize = merkleTree.elements().length;
+
+  // For deposits, input UTXOs don't exist yet
+  if (utxoIndex < 0 || utxoIndex >= treeSize) {
+    return Array(MERKLE_TREE_HEIGHT)
+      .fill(null)
+      .map(() => [ZERO_VALUE.toString(), ZERO_VALUE.toString()]);
+  }
+
+  // Get Merkle path
+  const { pathElements, pathIndices } = merkleTree.path(utxoIndex);
+  const commitment = utxo.commitment();
+
+  // Verify commitment matches what's in the tree
+  const storedCommitment = merkleTree.elements()[utxoIndex]!;
+
+  invariant(
+    storedCommitment === commitment,
+    `Commitment mismatch at index ${utxoIndex}: expected ${commitment}, got ${storedCommitment}`
+  );
+
+  // Build WASM-compatible path (always [left, right] format)
+  const wasmPath: [string, string][] = [];
+  let currentHash = commitment;
+
+  for (let i = 0; i < MERKLE_TREE_HEIGHT; i++) {
+    const sibling = pathElements[i];
+    const isLeft = pathIndices[i] === 0;
+
+    invariant(sibling !== undefined, `Sibling undefined at level ${i}`);
+
+    const leftHash = isLeft ? currentHash : sibling;
+    const rightHash = isLeft ? sibling : currentHash;
+
+    // Verify current hash appears in the pair (critical Rust check)
+    if (currentHash !== leftHash && currentHash !== rightHash) {
+      throw new Error(
+        `Invalid path at level ${i}: current hash must be either left or right`
+      );
+    }
+
+    wasmPath.push([leftHash.toString(), rightHash.toString()]);
+
+    const nextHash = poseidon2(leftHash, rightHash);
+
+    currentHash = nextHash;
+  }
+
+  const calculatedRoot = currentHash;
+  const expectedRoot = merkleTree.root();
+
+  invariant(
+    calculatedRoot === expectedRoot,
+    `Root mismatch: calculated ${calculatedRoot}, expected ${expectedRoot}`
+  );
+
+  return wasmPath;
+}
+
+interface ToProveInputArgs {
+  merkleTree: MerkleTree;
+  publicAmount: bigint;
+  extDataHash: bigint;
+  nullifier0: bigint;
+  nullifier1: bigint;
+  commitment0: bigint;
+  commitment1: bigint;
+  vortexKeypair: VortexKeypair;
+  inputUtxo0: Utxo;
+  inputUtxo1: Utxo;
+  outputUtxo0: Utxo;
+  outputUtxo1: Utxo;
+}
+
+export const toProveInput = ({
+  merkleTree,
+  publicAmount,
+  extDataHash,
+  nullifier0,
+  nullifier1,
+  commitment0,
+  commitment1,
+  vortexKeypair,
+  inputUtxo0,
+  inputUtxo1,
+  outputUtxo0,
+  outputUtxo1,
+}: ToProveInputArgs) => {
+  return {
+    root: merkleTree.root(),
+    publicAmount,
+    extDataHash,
+    inputNullifier0: nullifier0,
+    inputNullifier1: nullifier1,
+    outputCommitment0: commitment0,
+    outputCommitment1: commitment1,
+    inPrivateKey0: vortexKeypair.privateKey,
+    inPrivateKey1: vortexKeypair.privateKey,
+    inAmount0: inputUtxo0.amount,
+    inAmount1: inputUtxo1.amount,
+    inBlinding0: inputUtxo0.blinding,
+    inBlinding1: inputUtxo1.blinding,
+    inPathIndex0: inputUtxo0.index,
+    inPathIndex1: inputUtxo1.index,
+    merklePath0: getMerklePath(merkleTree, inputUtxo0),
+    merklePath1: getMerklePath(merkleTree, inputUtxo1),
+
+    outPublicKey0: vortexKeypair.publicKey,
+    outPublicKey1: vortexKeypair.publicKey,
+    outAmount0: outputUtxo0.amount,
+    outAmount1: outputUtxo1.amount,
+    outBlinding0: outputUtxo0.blinding,
+    outBlinding1: outputUtxo1.blinding,
+  };
+};
+
+export * from './ext-data';
+export * from './events';
+export * from './prove';
+export * from './decrypt';

package/src/utils/prove.ts

@@ -0,0 +1,18 @@
+import { prove as proveNode, verify as verifyNode } from '../pkg/nodejs/vortex';
+import { prove as proveWeb, verify as verifyWeb } from '../pkg/web/vortex';
+import { getEnv } from './env';
+import { VERIFYING_KEY, PROVING_KEY } from '../keys';
+
+export const prove = (input: string) => {
+  const env = getEnv();
+  if (env === 'node') return proveNode(input, PROVING_KEY);
+  if (env === 'web') return proveWeb(input, PROVING_KEY);
+  throw new Error('Unsupported environment');
+};
+
+export const verify = (proof: string) => {
+  const env = getEnv();
+  if (env === 'node') return verifyNode(proof, VERIFYING_KEY);
+  if (env === 'web') return verifyWeb(proof, VERIFYING_KEY);
+  throw new Error('Unsupported environment');
+};

package/src/vortex.ts

@@ -1,162 +1,286 @@
+import { SuiClient, getFullnodeUrl } from '@mysten/sui/client';
+import { Transaction } from '@mysten/sui/transactions';
 import {
-  SdkConstructorArgs,
-  VortexPools,
-  DepositArgs,
-  Modules,
-  Pool,
-  WithdrawArgs,
+  ConstructorArgs,
+  RegisterArgs,
+  SharedObjectData,
+  NewExtDataArgs,
+  Action,
+  NewProofArgs,
+  TransactArgs,
 } from './vortex.types';
-import { SuiClient } from '@mysten/sui/client';
-import {
-  generateRandomNote,
-  zeros,
-  BN254_FIELD_MODULUS,
-  addressToFieldElement,
-  bigIntToFieldElement,
-} from './utils';
-import { poseidon2, poseidon1 } from 'poseidon-lite';
 import { devInspectAndGetReturnValues } from '@polymedia/suitcase-core';
-import { Transaction, coinWithBalance } from '@mysten/sui/transactions';
-import { fromHex, SUI_TYPE_ARG } from '@mysten/sui/utils';
 import { bcs } from '@mysten/sui/bcs';
 import invariant from 'tiny-invariant';
+import { pathOr } from 'ramda';
+import {
+  BN254_FIELD_MODULUS,
+  VORTEX_PACKAGE_ID,
+  REGISTRY_OBJECT_ID,
+  INITIAL_SHARED_VERSION,
+  VORTEX_POOL_OBJECT_ID,
+} from './constants';
 
-export class VortexSdk {
-  private client: SuiClient;
-  private packageId: string;
-  private pools: VortexPools;
+export class Vortex {
+  #suiClient: SuiClient;
 
-  public TREE_HEIGHT = 26;
-  public BN254_FIELD_MODULUS = BN254_FIELD_MODULUS;
+  packageId: string;
+  registry: SharedObjectData;
+  vortex: SharedObjectData;
 
-  constructor(args: SdkConstructorArgs) {
-    this.client = args.client;
-    this.packageId = args.packageId;
-    this.pools = args.pools;
-  }
+  newCommitmentEventType: string;
+  nullifierSpentEventType: string;
+  newEncryptionKeyEventType: string;
 
-  generateRandomNote() {
-    return generateRandomNote();
-  }
+  constructor({
+    registry,
+    packageId,
+    vortex,
+    fullNodeUrl = getFullnodeUrl('devnet'),
+  }: ConstructorArgs) {
+    this.#suiClient = new SuiClient({
+      url: fullNodeUrl,
+    });
 
-  poseidon1(a: bigint | number | string) {
-    return poseidon1([a]);
-  }
+    this.newCommitmentEventType = `${packageId}::vortex::NewCommitment`;
+    this.nullifierSpentEventType = `${packageId}::vortex::NullifierSpent`;
+    this.newEncryptionKeyEventType = `${packageId}::vortex::NewEncryptionKey`;
 
-  poseidon2(a: bigint | number | string, b: bigint | number | string) {
-    return poseidon2([a, b]);
+    this.packageId = packageId;
+    this.registry = registry;
+    this.vortex = vortex;
   }
 
-  addressToFieldElement(address: string) {
-    return addressToFieldElement(address);
-  }
-
-  bigIntToFieldElement(value: bigint) {
-    return bigIntToFieldElement(value);
-  }
+  register({ tx = new Transaction(), encryptionKey }: RegisterArgs) {
+    tx.moveCall({
+      target: `${this.packageId}::vortex::register`,
+      arguments: [this.mutableRegistryRef(tx), tx.pure.string(encryptionKey)],
+    });
 
-  zeros() {
-    return zeros(this.TREE_HEIGHT);
+    return { tx };
   }
 
-  deposit({ commitment, pool, tx = new Transaction() }: DepositArgs) {
-    const poolObject = this.pools[pool];
-
-    const suiCoin = coinWithBalance({
-      type: SUI_TYPE_ARG,
-      balance: pool,
-    })(tx);
+  async encryptionKey(user: string) {
+    const tx = new Transaction();
 
     tx.moveCall({
-      package: this.packageId,
-      module: Modules.vortex,
-      function: 'deposit',
-      arguments: [
-        tx.sharedObjectRef({
-          objectId: poolObject.objectId,
-          mutable: true,
-          initialSharedVersion: poolObject.initialSharedVersion,
-        }),
-        suiCoin,
-        tx.pure.u256(commitment),
-      ],
+      target: `${this.packageId}::vortex::encryption_key`,
+      arguments: [this.immutableRegistryRef(tx), tx.pure.address(user)],
     });
 
-    return tx;
+    const result = await devInspectAndGetReturnValues(this.#suiClient, tx, [
+      [bcs.String],
+    ]);
+
+    invariant(result[0], 'Encryption key devInspectAndGetReturnValues failed');
+
+    return result[0][0] as string;
   }
 
-  withdraw({
-    proofPointsHex,
-    root,
-    nullifier,
+  newExtData({
+    tx = new Transaction(),
     recipient,
+    value,
+    action,
     relayer,
     relayerFee,
-    pool,
-    tx = new Transaction(),
-  }: WithdrawArgs) {
-    const poolObject = this.pools[pool];
-
-    const proof = tx.moveCall({
-      package: this.packageId,
-      module: Modules.proof,
-      function: 'new',
+    encryptedOutput1,
+    encryptedOutput0,
+  }: NewExtDataArgs) {
+    const extData = tx.moveCall({
+      target: `${this.packageId}::vortex_ext_data::new`,
       arguments: [
-        tx.pure.vector('u8', fromHex(proofPointsHex)),
-        tx.pure.vector('u8', []),
-        tx.pure.vector('u8', []),
-        tx.pure.u256(root),
-        tx.pure.u256(nullifier),
         tx.pure.address(recipient),
-        tx.pure.u64(pool),
+        tx.pure.u64(value),
+        tx.pure.bool(action === Action.Deposit), // true for deposit, false for withdraw
         tx.pure.address(relayer),
         tx.pure.u64(relayerFee),
+        tx.pure.vector('u8', encryptedOutput0),
+        tx.pure.vector('u8', encryptedOutput1),
       ],
     });
 
-    tx.moveCall({
-      package: this.packageId,
-      module: Modules.vortex,
-      function: 'withdraw',
+    return { tx, extData };
+  }
+
+  newProof({
+    tx = new Transaction(),
+    proofPoints,
+    root,
+    publicValue,
+    action,
+    extDataHash,
+    inputNullifier0,
+    inputNullifier1,
+    outputCommitment0,
+    outputCommitment1,
+  }: NewProofArgs) {
+    const value =
+      action === Action.Deposit
+        ? publicValue
+        : BN254_FIELD_MODULUS - publicValue;
+
+    const proof = tx.moveCall({
+      target: `${this.packageId}::vortex_proof::new`,
       arguments: [
-        tx.sharedObjectRef({
-          objectId: poolObject.objectId,
-          mutable: true,
-          initialSharedVersion: poolObject.initialSharedVersion,
-        }),
-        proof,
+        tx.pure.vector('u8', proofPoints),
+        tx.pure.u256(root),
+        tx.pure.u256(value),
+        tx.pure.u256(extDataHash),
+        tx.pure.u256(inputNullifier0),
+        tx.pure.u256(inputNullifier1),
+        tx.pure.u256(outputCommitment0),
+        tx.pure.u256(outputCommitment1),
       ],
     });
 
-    return tx;
+    return { tx, proof };
   }
 
-  async root(pool: Pool) {
-    const tx = new Transaction();
+  transact({ tx = new Transaction(), proof, extData, deposit }: TransactArgs) {
+    tx.moveCall({
+      target: `${this.packageId}::vortex::transact`,
+      arguments: [this.mutableVortexRef(tx), proof, extData, deposit],
+    });
+
+    return { tx };
+  }
+
+  async tvl() {
+    const object = await this.#suiClient.getObject({
+      id: this.vortex.objectId,
+      options: {
+        showContent: true,
+      },
+    });
+
+    invariant(object.data, 'Vortex object data not found');
+
+    const content = object.data.content;
+
+    return BigInt(pathOr(0, ['fields', 'balance'], content));
+  }
 
-    const poolObject = this.pools[pool];
+  async root() {
+    const tx = new Transaction();
 
     tx.moveCall({
-      package: this.packageId,
-      module: Modules.merkleTree,
-      function: 'root',
-      arguments: [
-        tx.sharedObjectRef({
-          objectId: poolObject.objectId,
-          mutable: false,
-          initialSharedVersion: poolObject.initialSharedVersion,
-        }),
-      ],
+      target: `${this.packageId}::vortex::root`,
+      arguments: [this.immutableVortexRef(tx)],
     });
 
-    const result = await devInspectAndGetReturnValues(this.client, tx, [
+    const result = await devInspectAndGetReturnValues(this.#suiClient, tx, [
       [bcs.u256()],
     ]);
 
     invariant(result[0], 'Root devInspectAndGetReturnValues failed');
 
-    const [root] = result[0][0].map((value: string) => BigInt(value));
+    return BigInt(result[0][0] as string);
+  }
+
+  async nextIndex() {
+    const tx = new Transaction();
+
+    tx.moveCall({
+      target: `${this.packageId}::vortex::next_index`,
+      arguments: [this.immutableVortexRef(tx)],
+    });
+
+    const result = await devInspectAndGetReturnValues(this.#suiClient, tx, [
+      [bcs.u64()],
+    ]);
+
+    invariant(result[0], 'Next index devInspectAndGetReturnValues failed');
+
+    return BigInt(result[0][0] as string);
+  }
+
+  async isNullifierSpent(nullifier: bigint) {
+    const tx = new Transaction();
+
+    tx.moveCall({
+      target: `${this.packageId}::vortex::is_nullifier_spent`,
+      arguments: [this.immutableVortexRef(tx), tx.pure.u256(nullifier)],
+    });
+
+    const result = await devInspectAndGetReturnValues(this.#suiClient, tx, [
+      [bcs.Bool],
+    ]);
+
+    invariant(
+      result[0],
+      'Is nullifier spent devInspectAndGetReturnValues failed'
+    );
+
+    return result[0][0] as boolean;
+  }
+
+  async areNullifiersSpent(nullifiers: bigint[]) {
+    const tx = new Transaction();
+
+    nullifiers.forEach((nullifier) => {
+      tx.moveCall({
+        target: `${this.packageId}::vortex::is_nullifier_spent`,
+        arguments: [this.immutableVortexRef(tx), tx.pure.u256(nullifier)],
+      });
+    });
+
+    const result = await devInspectAndGetReturnValues(
+      this.#suiClient,
+      tx,
+      nullifiers.map(() => [bcs.Bool])
+    );
+
+    invariant(
+      result[0],
+      'Is nullifier spent devInspectAndGetReturnValues failed'
+    );
+
+    return result.flat() as boolean[];
+  }
+
+  immutableVortexRef(tx: Transaction) {
+    return tx.sharedObjectRef({
+      objectId: this.vortex.objectId,
+      initialSharedVersion: this.vortex.initialSharedVersion,
+      mutable: false,
+    });
+  }
 
-    return root;
+  immutableRegistryRef(tx: Transaction) {
+    return tx.sharedObjectRef({
+      objectId: this.registry.objectId,
+      initialSharedVersion: this.registry.initialSharedVersion,
+      mutable: false,
+    });
+  }
+
+  mutableVortexRef(tx: Transaction) {
+    return tx.sharedObjectRef({
+      objectId: this.vortex.objectId,
+      initialSharedVersion: this.vortex.initialSharedVersion,
+      mutable: true,
+    });
+  }
+
+  mutableRegistryRef(tx: Transaction) {
+    return tx.sharedObjectRef({
+      objectId: this.registry.objectId,
+      initialSharedVersion: this.registry.initialSharedVersion,
+      mutable: true,
+    });
   }
 }
+
+export const vortexSDK = new Vortex({
+  packageId: VORTEX_PACKAGE_ID,
+  registry: {
+    objectId: REGISTRY_OBJECT_ID,
+    initialSharedVersion: INITIAL_SHARED_VERSION,
+  },
+  vortex: {
+    objectId: VORTEX_POOL_OBJECT_ID,
+    initialSharedVersion: INITIAL_SHARED_VERSION,
+  },
+  fullNodeUrl: getFullnodeUrl('devnet'),
+});