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

package/src/vortex.types.ts

@@ -1,84 +1,104 @@
-import { SuiClient } from '@mysten/sui/client';
-import { Transaction, TransactionResult } from '@mysten/sui/transactions';
+import { MaybeTx } from '@interest-protocol/sui-core-sdk';
+import { TransactionResult } from '@mysten/sui/transactions';
+import { Vortex } from './vortex';
+import { VortexKeypair } from './entities/keypair';
+import { MerkleTree } from './entities/merkle-tree';
+import { Utxo } from './entities/utxo';
 
-export enum Pool {
-  // 0.1 Sui
-  shrimp = 100_000_000,
-  // 1 Sui
-  dolphin = 1_000_000_000,
-  // 10 Sui
-  whale = 10_000_000_000,
+export enum Action {
+  Deposit,
+  Withdraw,
 }
 
-export enum Modules {
-  vortex = 'vortex',
-  proof = 'vortex_proof',
-  merkleTree = 'vortex_merkle_tree',
+export interface RegisterArgs extends MaybeTx {
+  encryptionKey: string;
 }
 
-export interface SharedObject {
+export interface SharedObjectData {
   objectId: string;
   initialSharedVersion: string;
 }
 
-export interface VortexPools {
-  [Pool.shrimp]: SharedObject;
-  [Pool.dolphin]: SharedObject;
-  [Pool.whale]: SharedObject;
-}
-
-export interface SdkConstructorArgs {
-  client: SuiClient;
+export interface ConstructorArgs {
+  registry: SharedObjectData;
+  vortex: SharedObjectData;
+  fullNodeUrl?: string;
   packageId: string;
-  pools: VortexPools;
 }
 
-export interface AdminSdkConstructorArgs {
-  packageId: string;
-  adminCap: string;
+export interface ExtDataHashArgs {
+  recipient: string; // Sui address
+  value: bigint;
+  valueSign: boolean;
+  relayer: string; // Sui address
+  relayerFee: bigint;
+  encryptedOutput0: Uint8Array;
+  encryptedOutput1: Uint8Array;
 }
 
-export interface DepositArgs {
-  tx?: Transaction;
-  commitment: bigint;
-  pool: Pool;
+export interface Proof {
+  proofA: number[];
+  proofB: number[];
+  proofC: number[];
+  publicInputs: [string, string, string, string, string, string, string];
+  proofSerializedHex: string;
+  publicInputsHex: string;
 }
 
-export interface WithdrawArgs {
-  tx?: Transaction;
-  pool: Pool;
-  proofPointsHex: string;
-  root: bigint;
-  nullifier: bigint;
+export interface NewExtDataArgs extends MaybeTx {
   recipient: string;
+  value: bigint;
   relayer: string;
   relayerFee: bigint;
+  encryptedOutput0: Uint8Array;
+  encryptedOutput1: Uint8Array;
+  action: Action;
 }
 
-export interface NewPoolArgs {
-  tx?: Transaction;
-  pool: Pool;
+export interface NewProofArgs extends MaybeTx {
+  proofPoints: Uint8Array;
+  root: bigint;
+  publicValue: bigint;
+  action: Action;
+  extDataHash: bigint;
+  inputNullifier0: bigint;
+  inputNullifier1: bigint;
+  outputCommitment0: bigint;
+  outputCommitment1: bigint;
 }
 
-export interface SharePoolArgs {
-  tx: Transaction;
-  pool: TransactionResult;
+interface NestedResult {
+  $kind: 'NestedResult';
+  NestedResult: [number, number];
 }
 
-export interface SetDepositFeeArgs {
-  tx?: Transaction;
-  pool: TransactionResult | string;
-  fee: bigint;
+export interface TransactArgs extends MaybeTx {
+  proof: TransactionResult;
+  extData: TransactionResult;
+  deposit: TransactionResult | NestedResult;
 }
 
-export interface SetWithdrawFeeArgs {
-  tx?: Transaction;
-  pool: TransactionResult | string;
-  fee: bigint;
+export interface DepositArgs extends MaybeTx {
+  amount: bigint;
+  vortex: Vortex;
+  vortexKeypair: VortexKeypair;
+  merkleTree: MerkleTree;
+  unspentUtxos?: Utxo[];
 }
 
-export interface SetGroth16VkArgs {
-  tx?: Transaction;
-  pool: TransactionResult | string;
-  vk: string;
+export interface WithdrawArgs extends MaybeTx {
+  amount: bigint;
+  unspentUtxos: Utxo[];
+  vortex: Vortex;
+  vortexKeypair: VortexKeypair;
+  merkleTree: MerkleTree;
+  recipient: string;
+  relayer: string;
+  relayerFee: bigint;
+}
+
+export interface ParsedCommitmentEvent {
+  commitment: bigint;
+  index: bigint;
+  encryptedOutput: string;
 }

package/src/withdraw.ts

@@ -0,0 +1,159 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { Utxo } from './entities/utxo';
+import { VortexKeypair } from './entities/keypair';
+import invariant from 'tiny-invariant';
+import { BN } from 'bn.js';
+import { normalizeSuiAddress } from '@mysten/sui/utils';
+
+import { fromHex } from '@mysten/sui/utils';
+import {
+  bytesToBigInt,
+  reverseBytes,
+  toProveInput,
+  computeExtDataHash,
+} from './utils';
+import { BN254_FIELD_MODULUS } from './constants';
+import { prove, verify } from './utils';
+import { Proof, Action, WithdrawArgs } from './vortex.types';
+
+export const withdraw = async ({
+  tx = new Transaction(),
+  amount,
+  unspentUtxos = [],
+  vortex,
+  vortexKeypair,
+  merkleTree,
+  recipient,
+  relayer,
+  relayerFee,
+}: WithdrawArgs) => {
+  invariant(1 >= unspentUtxos.length, 'Must have at least 1 unspent UTXO');
+
+  unspentUtxos.sort((a, b) => new BN(b.amount).cmp(new BN(a.amount)));
+
+  const totalUnspentUtxosAmount = unspentUtxos
+    .slice(0, 2)
+    .reduce((acc, utxo) => acc + utxo.amount, 0n);
+
+  invariant(
+    totalUnspentUtxosAmount >= amount + relayerFee,
+    'Total unspent UTXOs amount must be greater than or equal to amount'
+  );
+
+  const randomVortexKeypair = VortexKeypair.generate();
+
+  const inputUtxo0 = unspentUtxos[0];
+
+  const inputUtxo1 =
+    unspentUtxos.length > 1 && unspentUtxos[1].amount > 0n
+      ? unspentUtxos[1]
+      : new Utxo({
+          amount: 0n,
+          keypair: vortexKeypair,
+        });
+
+  const totalWithdrawAmount = inputUtxo0.amount + inputUtxo1.amount;
+
+  const changeAmount = totalWithdrawAmount - amount - relayerFee;
+
+  const nextIndex = await vortex.nextIndex();
+
+  const outputUtxo0 = new Utxo({
+    amount: changeAmount,
+    index: nextIndex,
+    keypair: vortexKeypair,
+  });
+
+  const outputUtxo1 = new Utxo({
+    amount: 0n,
+    index: nextIndex + 1n,
+    keypair: vortexKeypair,
+  });
+
+  const [nullifier0, nullifier1, commitment0, commitment1] = [
+    inputUtxo0.nullifier(),
+    inputUtxo1.nullifier(),
+    outputUtxo0.commitment(),
+    outputUtxo1.commitment(),
+  ];
+
+  const encryptedUtxo0 = VortexKeypair.encryptUtxoFor(
+    outputUtxo0.payload(),
+    vortexKeypair.encryptionKey
+  );
+
+  // UTXO1 is a dummy UTXO for obfuscation, so we use a random Vortex keypair.
+  const encryptedUtxo1 = VortexKeypair.encryptUtxoFor(
+    outputUtxo1.payload(),
+    randomVortexKeypair.encryptionKey
+  );
+
+  const extDataHash = computeExtDataHash({
+    recipient,
+    value: amount,
+    valueSign: false,
+    relayer: normalizeSuiAddress(relayer),
+    relayerFee,
+    encryptedOutput0: fromHex(encryptedUtxo0),
+    encryptedOutput1: fromHex(encryptedUtxo1),
+  });
+
+  const extDataHashBigInt = bytesToBigInt(reverseBytes(extDataHash));
+
+  // Prepare circuit input
+  const input = toProveInput({
+    merkleTree,
+    publicAmount: BN254_FIELD_MODULUS - (amount + relayerFee),
+    extDataHash: extDataHashBigInt,
+    nullifier0,
+    nullifier1,
+    commitment0,
+    commitment1,
+    vortexKeypair,
+    inputUtxo0,
+    inputUtxo1,
+    outputUtxo0,
+    outputUtxo1,
+  });
+
+  const proofJson: string = prove(JSON.stringify(input));
+
+  const proof: Proof = JSON.parse(proofJson);
+
+  invariant(verify(proofJson), 'Proof verification failed');
+
+  const { extData, tx: tx2 } = vortex.newExtData({
+    tx,
+    recipient,
+    value: amount,
+    action: Action.Withdraw,
+    relayer: normalizeSuiAddress(relayer),
+    relayerFee,
+    encryptedOutput0: fromHex(encryptedUtxo0),
+    encryptedOutput1: fromHex(encryptedUtxo1),
+  });
+
+  const { proof: moveProof, tx: tx3 } = vortex.newProof({
+    tx: tx2,
+    proofPoints: fromHex('0x' + proof.proofSerializedHex),
+    root: merkleTree.root(),
+    publicValue: amount + relayerFee,
+    action: Action.Withdraw,
+    extDataHash: extDataHashBigInt,
+    inputNullifier0: nullifier0,
+    inputNullifier1: nullifier1,
+    outputCommitment0: commitment0,
+    outputCommitment1: commitment1,
+  });
+
+  const zeroSuiCoin = tx3.splitCoins(tx3.gas, [tx3.pure.u64(0n)]);
+
+  const { tx: tx4 } = vortex.transact({
+    tx: tx3,
+    proof: moveProof,
+    extData: extData,
+    deposit: zeroSuiCoin,
+  });
+
+  return tx4;
+};

package/tsconfig.json

@@ -11,8 +11,10 @@
     "rootDir": "src",
     "strict": true,
     "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowJs": true
   },
   "@interest-protocol/*": ["../*/src"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "jest.config.js", "rollup.config.js"]
 }

package/dist/admin.d.ts

@@ -1,17 +0,0 @@
-import { AdminSdkConstructorArgs } from './vortex.types';
-import { Transaction } from '@mysten/sui/transactions';
-import { NewPoolArgs, SharePoolArgs, SetDepositFeeArgs, SetWithdrawFeeArgs, SetGroth16VkArgs } from './vortex.types';
-export declare class VortexAdminSdk {
-    private packageId;
-    private adminCap;
-    constructor(args: AdminSdkConstructorArgs);
-    newPool({ pool, tx }: NewPoolArgs): {
-        vortex: import("@mysten/sui/dist/cjs/transactions").TransactionResult;
-        tx: Transaction;
-    };
-    sharePool({ tx, pool }: SharePoolArgs): Transaction;
-    setDepositFee({ tx, pool, fee }: SetDepositFeeArgs): Transaction;
-    setWithdrawFee({ tx, pool, fee }: SetWithdrawFeeArgs): Transaction;
-    setGroth16Vk({ tx, pool, vk }: SetGroth16VkArgs): Transaction;
-}
-//# sourceMappingURL=admin.d.ts.map

package/dist/admin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../src/admin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,EACL,WAAW,EAEX,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,gBAAgB,CAAC;AAExB,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAS;gBAEb,IAAI,EAAE,uBAAuB;IAKzC,OAAO,CAAC,EAAE,IAAI,EAAE,EAAsB,EAAE,EAAE,WAAW;;;;IAcrD,SAAS,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,aAAa;IAWrC,aAAa,CAAC,EAAE,EAAsB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,iBAAiB;IAwBtE,cAAc,CAAC,EAAE,EAAsB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,kBAAkB;IAwBxE,YAAY,CAAC,EAAE,EAAsB,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,gBAAgB;CA6BpE"}

package/dist/utils.d.ts

@@ -1,11 +0,0 @@
-export declare const BN254_FIELD_MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
-export declare const generateRandomNote: () => {
-    nullifier: bigint;
-    secret: bigint;
-    commitment: bigint;
-};
-export declare function bigIntToFieldElement(value: bigint): bigint;
-export declare function addressToFieldElement(address: string): bigint;
-export declare const stringToField: (s: string) => bigint;
-export declare function zeros(treeLevels: number): bigint[];
-//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB,iFACgD,CAAC;AAYjF,eAAO,MAAM,kBAAkB;;;;CAS9B,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,UAEjD;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,UAMpD;AAED,eAAO,MAAM,aAAa,GAAI,GAAG,MAAM,WAKtC,CAAC;AAEF,wBAAgB,KAAK,CAAC,UAAU,EAAE,MAAM,YAiBvC"}

package/src/admin.ts

@@ -1,124 +0,0 @@
-import { AdminSdkConstructorArgs } from './vortex.types';
-import { Transaction } from '@mysten/sui/transactions';
-import { fromHex } from '@mysten/sui/utils';
-import {
-  NewPoolArgs,
-  Modules,
-  SharePoolArgs,
-  SetDepositFeeArgs,
-  SetWithdrawFeeArgs,
-  SetGroth16VkArgs,
-} from './vortex.types';
-
-export class VortexAdminSdk {
-  private packageId: string;
-  private adminCap: string;
-
-  constructor(args: AdminSdkConstructorArgs) {
-    this.packageId = args.packageId;
-    this.adminCap = args.adminCap;
-  }
-
-  newPool({ pool, tx = new Transaction() }: NewPoolArgs) {
-    const vortex = tx.moveCall({
-      package: this.packageId,
-      module: Modules.vortex,
-      function: 'new',
-      arguments: [tx.object(this.adminCap), tx.pure.u64(pool)],
-    });
-
-    return {
-      vortex,
-      tx,
-    };
-  }
-
-  sharePool({ tx, pool }: SharePoolArgs) {
-    tx.moveCall({
-      package: this.packageId,
-      module: Modules.vortex,
-      function: 'share',
-      arguments: [pool],
-    });
-
-    return tx;
-  }
-
-  setDepositFee({ tx = new Transaction(), pool, fee }: SetDepositFeeArgs) {
-    if (typeof pool === 'object') {
-      tx.moveCall({
-        package: this.packageId,
-        module: Modules.vortex,
-        function: 'set_deposit_fee',
-        arguments: [pool, tx.object(this.adminCap), tx.pure.u64(fee)],
-      });
-    } else {
-      tx.moveCall({
-        package: this.packageId,
-        module: Modules.vortex,
-        function: 'set_deposit_fee',
-        arguments: [
-          tx.object(pool),
-          tx.object(this.adminCap),
-          tx.pure.u64(fee),
-        ],
-      });
-    }
-
-    return tx;
-  }
-
-  setWithdrawFee({ tx = new Transaction(), pool, fee }: SetWithdrawFeeArgs) {
-    if (typeof pool === 'object') {
-      tx.moveCall({
-        package: this.packageId,
-        module: Modules.vortex,
-        function: 'set_withdraw_fee',
-        arguments: [pool, tx.object(this.adminCap), tx.pure.u64(fee)],
-      });
-    } else {
-      tx.moveCall({
-        package: this.packageId,
-        module: Modules.vortex,
-        function: 'set_withdraw_fee',
-        arguments: [
-          tx.object(pool),
-          tx.object(this.adminCap),
-          tx.pure.u64(fee),
-        ],
-      });
-    }
-
-    return tx;
-  }
-
-  setGroth16Vk({ tx = new Transaction(), pool, vk }: SetGroth16VkArgs) {
-    const vkBytes = fromHex(vk);
-
-    if (typeof pool === 'object') {
-      tx.moveCall({
-        package: this.packageId,
-        module: Modules.vortex,
-        function: 'set_groth16_vk',
-        arguments: [
-          pool,
-          tx.object(this.adminCap),
-          tx.pure.vector('u8', vkBytes),
-        ],
-      });
-    } else {
-      tx.moveCall({
-        package: this.packageId,
-        module: Modules.vortex,
-        function: 'set_groth16_vk',
-        arguments: [
-          tx.object(pool),
-          tx.object(this.adminCap),
-          tx.pure.vector('u8', vkBytes),
-        ],
-      });
-    }
-
-    return tx;
-  }
-}

package/src/utils.ts

@@ -1,66 +0,0 @@
-import { poseidon2, poseidon1 } from 'poseidon-lite';
-import invariant from 'tiny-invariant';
-
-import { isValidSuiAddress, normalizeSuiAddress } from '@mysten/sui/utils';
-
-export const BN254_FIELD_MODULUS =
-  21888242871839275222246405745257275088548364400416034343698204186575808495617n;
-
-function randomBigIntHex(byteLength: number): bigint {
-  const hexString = Array.from(
-    crypto.getRandomValues(new Uint8Array(byteLength))
-  )
-    .map((b) => b.toString(16).padStart(2, '0'))
-    .join('');
-
-  return BigInt('0x' + hexString);
-}
-
-export const generateRandomNote = () => {
-  const nullifier = randomBigIntHex(31);
-  const secret = randomBigIntHex(31);
-  const commitment = poseidon2([nullifier, secret]);
-  return {
-    nullifier,
-    secret,
-    commitment,
-  };
-};
-
-export function bigIntToFieldElement(value: bigint) {
-  return value % BN254_FIELD_MODULUS;
-}
-
-export function addressToFieldElement(address: string) {
-  invariant(isValidSuiAddress(address), 'Invalid Sui address');
-
-  const cleanAddress = normalizeSuiAddress(address, true);
-
-  return bigIntToFieldElement(BigInt(cleanAddress));
-}
-
-export const stringToField = (s: string) => {
-  const bytes = new TextEncoder().encode(s);
-  let acc = 0n;
-  for (const b of bytes) acc = (acc << 8n) | BigInt(b);
-  return acc % BN254_FIELD_MODULUS;
-};
-
-export function zeros(treeLevels: number) {
-  if (treeLevels < 1) throw new Error('treeLevels must be >= 1');
-
-  // ZERO_VALUE := Poseidon("vortex")
-  const ZERO_VALUE = poseidon1([stringToField('vortex')]);
-
-  const zeros: bigint[] = [];
-
-  let currentZero = ZERO_VALUE;
-  zeros.push(currentZero);
-
-  for (let i = 1; i < treeLevels; i++) {
-    currentZero = poseidon2([currentZero, currentZero]);
-    zeros.push(currentZero);
-  }
-
-  return zeros;
-}