@interest-protocol/vortex-sdk 6.3.0 → 7.0.0

package/src/vortex-api.ts

@@ -0,0 +1,189 @@
+import invariant from 'tiny-invariant';
+import {
+  VortexAPIConstructorArgs,
+  VORTEX_API_URL,
+  HealthResponse,
+  AccountsResponse,
+  CreateAccountRequest,
+  AccountResponse,
+  PoolsResponse,
+  GetPoolsArgs,
+  CommitmentsResponse,
+  GetCommitmentsArgs,
+  MerklePathRequest,
+  MerklePathResponse,
+  ExecuteTransactionRequest,
+  TransactionResponse,
+  RelayerResponse,
+  ApiResponse,
+  ErrorResponse,
+} from './vortex-api.types';
+
+export class VortexAPI {
+  #apiUrl: string;
+
+  constructor({ apiUrl = VORTEX_API_URL }: VortexAPIConstructorArgs = {}) {
+    this.#apiUrl = apiUrl.replace(/\/$/, '');
+  }
+
+  async health(): Promise<HealthResponse> {
+    const response = await this.#get<HealthResponse>('/api/health');
+
+    this.#assertSuccess(response);
+
+    return response;
+  }
+
+  async getAccounts(hashedSecret: string): Promise<AccountsResponse> {
+    const params = new URLSearchParams({ hashed_secret: hashedSecret });
+
+    const response = await this.#get<AccountsResponse>(
+      `/api/v1/accounts?${params.toString()}`
+    );
+
+    this.#assertSuccess(response);
+
+    return response;
+  }
+
+  async createAccount(args: CreateAccountRequest): Promise<AccountResponse> {
+    const response = await this.#post<AccountResponse>('/api/v1/accounts', {
+      owner: args.owner,
+      hashedSecret: args.hashedSecret,
+    });
+
+    this.#assertSuccess(response);
+
+    return response;
+  }
+
+  async getPools(args: GetPoolsArgs = {}): Promise<PoolsResponse> {
+    const params = new URLSearchParams();
+
+    if (args.page !== undefined) {
+      params.set('page', args.page.toString());
+    }
+
+    if (args.limit !== undefined) {
+      params.set('limit', args.limit.toString());
+    }
+
+    if (args.coinType !== undefined) {
+      params.set('coin_type', args.coinType);
+    }
+
+    const query = params.toString();
+    const path = query ? `/api/v1/pools?${query}` : '/api/v1/pools';
+
+    const response = await this.#get<PoolsResponse>(path);
+
+    this.#assertSuccess(response);
+
+    return response;
+  }
+
+  async getCommitments(args: GetCommitmentsArgs): Promise<CommitmentsResponse> {
+    const params = new URLSearchParams({
+      coin_type: args.coinType,
+      index: args.index.toString(),
+    });
+
+    if (args.op !== undefined) {
+      params.set('op', args.op);
+    }
+
+    if (args.page !== undefined) {
+      params.set('page', args.page.toString());
+    }
+
+    if (args.limit !== undefined) {
+      params.set('limit', args.limit.toString());
+    }
+
+    const response = await this.#get<CommitmentsResponse>(
+      `/api/v1/commitments?${params.toString()}`
+    );
+
+    this.#assertSuccess(response);
+
+    return response;
+  }
+
+  async getMerklePath(args: MerklePathRequest): Promise<MerklePathResponse> {
+    const response = await this.#post<MerklePathResponse>(
+      '/api/v1/merkle/path',
+      {
+        coin_type: args.coinType,
+        index: args.index,
+        amount: args.amount,
+        public_key: args.publicKey,
+        blinding: args.blinding,
+        vortex_pool: args.vortexPool,
+      }
+    );
+
+    this.#assertSuccess(response);
+
+    return response;
+  }
+
+  async executeTransaction(
+    args: ExecuteTransactionRequest
+  ): Promise<TransactionResponse> {
+    const response = await this.#post<TransactionResponse>(
+      '/api/v1/transactions',
+      {
+        txBytes: args.txBytes,
+      }
+    );
+
+    this.#assertSuccess(response);
+
+    return response;
+  }
+
+  async getRelayer(): Promise<RelayerResponse> {
+    const response = await this.#get<RelayerResponse>('/api/v1/relayer');
+
+    this.#assertSuccess(response);
+
+    return response;
+  }
+
+  async #get<T>(path: string): Promise<ApiResponse<T>> {
+    const response = await fetch(`${this.#apiUrl}${path}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    return response.json() as Promise<ApiResponse<T>>;
+  }
+
+  async #post<T>(
+    path: string,
+    body: Record<string, unknown>
+  ): Promise<ApiResponse<T>> {
+    const response = await fetch(`${this.#apiUrl}${path}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    return response.json() as Promise<ApiResponse<T>>;
+  }
+
+  #assertSuccess<T extends { success: true }>(
+    response: ApiResponse<T>
+  ): asserts response is T {
+    invariant(
+      (response as T).success === true,
+      `VortexAPI request failed: ${(response as ErrorResponse).error}`
+    );
+  }
+}
+
+export const vortexAPI = new VortexAPI();

package/src/vortex-api.types.ts

@@ -0,0 +1,137 @@
+import type { MerklePath } from './utils';
+
+export const VORTEX_API_URL = 'https://api.vortexfi.xyz';
+
+export interface VortexAPIConstructorArgs {
+  apiUrl?: string;
+}
+
+export interface HealthStatus {
+  mongodb: boolean;
+  redis: boolean;
+  sui: boolean;
+}
+
+export interface HealthResponse {
+  success: true;
+  data: HealthStatus;
+}
+
+export interface Account {
+  owner: string;
+  hashedSecret: string;
+}
+
+export interface AccountsResponse {
+  success: true;
+  data: Account[];
+}
+
+export interface CreateAccountRequest {
+  owner: string;
+  hashedSecret: string;
+}
+
+export interface AccountResponse {
+  success: true;
+  data: Account;
+}
+
+export interface Pool {
+  objectId: string;
+  coinType: string;
+  balance: string;
+  nextIndex: number;
+}
+
+export interface Pagination {
+  page: number;
+  limit: number;
+  total: number;
+  totalPages: number;
+  hasNext: boolean;
+  hasPrev: boolean;
+}
+
+export interface PoolsResponse {
+  success: true;
+  data: {
+    items: Pool[];
+    pagination: Pagination;
+  };
+}
+
+export interface GetPoolsArgs {
+  page?: number;
+  limit?: number;
+  coinType?: string;
+}
+
+export interface Commitment {
+  commitment: string;
+  index: number;
+  coinType: string;
+  encryptedOutput: string;
+}
+
+export interface CommitmentsResponse {
+  success: true;
+  data: {
+    items: Commitment[];
+    pagination: Pagination;
+  };
+}
+
+export type CommitmentsOperator = 'gt' | 'gte' | 'lt' | 'lte';
+
+export interface GetCommitmentsArgs {
+  coinType: string;
+  index: number;
+  op?: CommitmentsOperator;
+  page?: number;
+  limit?: number;
+}
+
+export interface MerklePathRequest {
+  coinType: string;
+  index: number;
+  amount: string;
+  publicKey: string;
+  blinding: string;
+  vortexPool: string;
+}
+
+export interface MerklePathResponse {
+  success: true;
+  data: {
+    path: MerklePath;
+    root: string;
+  };
+}
+
+export interface ExecuteTransactionRequest {
+  txBytes: string;
+}
+
+export interface TransactionResponse {
+  success: true;
+  data: {
+    digest: string;
+  };
+}
+
+export interface Relayer {
+  address: string;
+}
+
+export interface RelayerResponse {
+  success: true;
+  data: Relayer;
+}
+
+export interface ErrorResponse {
+  success: false;
+  error: string;
+}
+
+export type ApiResponse<T> = T | ErrorResponse;

package/src/vortex.ts

@@ -213,7 +213,7 @@ export class Vortex {
         ? publicValue
         : BN254_FIELD_MODULUS - publicValue;
 
-    const vortex = await this.#getVortexPool(vortexPool);
+    const vortex = await this.resolveVortexPool(vortexPool);
 
     const proof = tx.moveCall({
       target: `${this.packageId}::vortex_proof::new`,
@@ -240,7 +240,7 @@ export class Vortex {
     extData,
     deposit,
   }: TransactArgs) {
-    const vortex = await this.#getVortexPool(vortexPool);
+    const vortex = await this.resolveVortexPool(vortexPool);
 
     const coin = tx.moveCall({
       target: `${this.packageId}::vortex::transact`,
@@ -259,7 +259,7 @@ export class Vortex {
     proof,
     extData,
   }: TransactWithAccountArgs) {
-    const vortex = await this.#getVortexPool(vortexPool);
+    const vortex = await this.resolveVortexPool(vortexPool);
 
     const coin = tx.moveCall({
       target: `${this.packageId}::vortex::transact_with_account`,
@@ -320,7 +320,7 @@ export class Vortex {
   async nextIndex(vortexPool: string | VortexPool) {
     const tx = new Transaction();
 
-    const vortex = await this.#getVortexPool(vortexPool);
+    const vortex = await this.resolveVortexPool(vortexPool);
 
     tx.moveCall({
       target: `${this.packageId}::vortex::next_index`,
@@ -338,7 +338,7 @@ export class Vortex {
   }
 
   async isNullifierSpent({ nullifier, vortexPool }: IsNullifierSpentArgs) {
-    const vortex = await this.#getVortexPool(vortexPool);
+    const vortex = await this.resolveVortexPool(vortexPool);
 
     const tx = new Transaction();
 
@@ -361,7 +361,7 @@ export class Vortex {
   }
 
   async areNullifiersSpent({ nullifiers, vortexPool }: AreNullifiersSpentArgs) {
-    const vortex = await this.#getVortexPool(vortexPool);
+    const vortex = await this.resolveVortexPool(vortexPool);
 
     if (nullifiers.length === 0) return [];
 
@@ -398,7 +398,7 @@ export class Vortex {
     minAmountOut,
     coinOutType,
   }: StartSwapArgs) {
-    const vortexPool = await this.#getVortexPool(vortex);
+    const vortexPool = await this.resolveVortexPool(vortex);
 
     const [receipt, coinIn] = tx.moveCall({
       target: `${this.swapPackageId}::vortex_swap::start_swap`,
@@ -424,7 +424,7 @@ export class Vortex {
     receipt,
     coinInType,
   }: FinishSwapArgs) {
-    const vortexPool = await this.#getVortexPool(vortex);
+    const vortexPool = await this.resolveVortexPool(vortex);
 
     tx.moveCall({
       target: `${this.swapPackageId}::vortex_swap::finish_swap`,
@@ -490,7 +490,7 @@ export class Vortex {
     });
   }
 
-  async #getVortexPool(vortex: string | VortexPool): Promise<VortexPool> {
+  async resolveVortexPool(vortex: string | VortexPool): Promise<VortexPool> {
     return typeof vortex === 'string' ? this.getVortexPool(vortex) : vortex;
   }
 }

package/src/vortex.types.ts

@@ -16,7 +16,9 @@ interface NestedResult {
   NestedResult: [number, number];
 }
 
-export type GetMerklePathFn = (utxo: Utxo | null) => Promise<MerklePath>;
+export type GetMerklePathFn = (
+  utxo: Utxo | null
+) => Promise<{ path: MerklePath; root: bigint }>;
 
 export interface RegisterArgs extends MaybeTx {
   encryptionKey: string;
@@ -102,7 +104,6 @@ export interface DepositArgs extends MaybeTx {
   vortexSdk: Vortex;
   vortexPool: string | VortexPool;
   vortexKeypair: VortexKeypair;
-  root: bigint;
   getMerklePathFn: GetMerklePathFn;
   unspentUtxos?: Utxo[];
   relayer?: string;
@@ -113,7 +114,6 @@ export interface DepositWithAccountArgs extends MaybeTx {
   vortexSdk: Vortex;
   vortexPool: string | VortexPool;
   vortexKeypair: VortexKeypair;
-  root: bigint;
   getMerklePathFn: GetMerklePathFn;
   unspentUtxos?: Utxo[];
   account: string;
@@ -129,7 +129,6 @@ export interface WithdrawArgs extends MaybeTx {
   unspentUtxos: Utxo[];
   vortexSdk: Vortex;
   vortexKeypair: VortexKeypair;
-  root: bigint;
   getMerklePathFn: GetMerklePathFn;
   relayer: string;
   relayerFee: bigint;
@@ -139,7 +138,6 @@ export interface WithdrawWithAccountArgs extends MaybeTx {
   vortexSdk: Vortex;
   vortexPool: string | VortexPool;
   vortexKeypair: VortexKeypair;
-  root: bigint;
   getMerklePathFn: GetMerklePathFn;
   unspentUtxos?: Utxo[];
   account: string;
@@ -206,7 +204,6 @@ export interface StartSwapHelperArgs extends MaybeTx {
   unspentUtxos: Utxo[];
   vortexSdk: Vortex;
   vortexKeypair: VortexKeypair;
-  root: bigint;
   getMerklePathFn: GetMerklePathFn;
   relayer: string;
   minAmountOut: bigint;
@@ -218,7 +215,6 @@ export interface FinishSwapHelperArgs extends MaybeTx {
   vortexSdk: Vortex;
   vortexPool: string | VortexPool;
   vortexKeypair: VortexKeypair;
-  root: bigint;
   getMerklePathFn: GetMerklePathFn;
   unspentUtxos?: Utxo[];
   coinOut: TransactionResult;

package/src/withdraw-with-account.ts

@@ -7,7 +7,6 @@ export const withdrawWithAccount = async ({
   unspentUtxos = [],
   vortexPool,
   vortexKeypair,
-  root,
   getMerklePathFn,
   relayer,
   relayerFee,
@@ -27,7 +26,6 @@ export const withdrawWithAccount = async ({
     unspentUtxos,
     vortexPool,
     vortexKeypair,
-    root,
     getMerklePathFn,
     relayer,
     relayerFee,

package/src/withdraw.ts

@@ -1,6 +1,7 @@
 import { Transaction } from '@mysten/sui/transactions';
 import { WithdrawArgs } from './vortex.types';
 import { prepareWithdraw } from './utils/withdraw';
+import { SUI_FRAMEWORK_ADDRESS } from '@mysten/sui/utils';
 
 export const withdraw = async ({
   tx = new Transaction(),
@@ -8,14 +9,13 @@ export const withdraw = async ({
   unspentUtxos = [],
   vortexPool,
   vortexKeypair,
-  root,
   getMerklePathFn,
   relayer,
   relayerFee,
   vortexSdk,
 }: WithdrawArgs) => {
   const {
-    tx: tx3,
+    tx: tx2,
     moveProof,
     extData,
     vortexPool: pool,
@@ -25,7 +25,6 @@ export const withdraw = async ({
     unspentUtxos,
     vortexPool,
     vortexKeypair,
-    root,
     getMerklePathFn,
     relayer,
     relayerFee,
@@ -33,13 +32,18 @@ export const withdraw = async ({
     accountSecret: 0n,
   });
 
-  const zeroSuiCoin = tx3.splitCoins(tx3.gas, [tx3.pure.u64(0n)]);
+  const vortexPoolObject = await vortexSdk.resolveVortexPool(pool);
+
+  const zeroCoin = tx2.moveCall({
+    target: `${SUI_FRAMEWORK_ADDRESS}::coin::zero`,
+    typeArguments: [vortexPoolObject.coinType],
+  });
 
   return vortexSdk.transact({
     vortexPool: pool,
-    tx: tx3,
+    tx: tx2,
     proof: moveProof,
     extData: extData,
-    deposit: zeroSuiCoin,
+    deposit: zeroCoin,
   });
 };