wasm, node: tidy exports and parse functions

Author: sehyunc

packages/core/src/utils.d.ts

@@ -203,6 +203,11 @@ export function create_request_signature(path: string, headers: any, body: strin
 */
 export function b64_to_hex_hmac_key(b64_key: string): string;
 /**
+* @param {string} pk_root
+* @returns {any[]}
+*/
+export function byok_get_pk_root_scalars(pk_root: string): any[];
+/**
 * @param {string} seed
 * @param {bigint} nonce
 * @returns {any}
@@ -225,8 +230,3 @@ export function get_pk_root_scalars(seed: string, nonce: bigint): any[];
 * @returns {any}
 */
 export function get_symmetric_key(seed: string): any;
-/**
-* @param {string} pk_root
-* @returns {any[]}
-*/
-export function byok_get_pk_root_scalars(pk_root: string): any[];

packages/node/package.json

@@ -35,7 +35,7 @@
       "types": "./dist/types/exports/actions.d.ts",
       "default": "./dist/exports/actions.js"
     },
-    "./actions/byok": {
+    "./byok": {
       "types": "./dist/types/exports/byok.d.ts",
       "default": "./dist/exports/byok.js"
     },
@@ -50,7 +50,7 @@
       "actions": [
         "./dist/types/exports/actions.d.ts"
       ],
-      "actions/byok": [
+      "byok": [
         "./dist/types/exports/byok.d.ts"
       ]
     }

packages/node/src/actions/byok/createWallet.ts

@@ -1,8 +1,8 @@
 import {
   CREATE_WALLET_ROUTE,
-  type Config,
   postRelayerRaw,
 } from '@renegade-fi/core'
+import type { BYOKConfig } from '../../utils/createBYOKConfig.js'
 
 export type CreateWalletReturnType = { taskId: string }
 
@@ -16,7 +16,7 @@ export type CreateWalletParameters = {
 }
 
 export async function createWallet(
-  config: Config,
+  config: BYOKConfig,
   parameters: CreateWalletParameters,
 ): Promise<CreateWalletReturnType> {
   const { walletId, blinderSeed, shareSeed, pkRoot, skMatch, symmetricKey } =

packages/node/src/actions/byok/generateWalletSecrets.ts

@@ -1,22 +1,30 @@
-import type { Config } from '@renegade-fi/core'
 import type { SignMessageReturnType } from 'viem'
+import { generate_wallet_secrets } from '../../../renegade-utils/index.js'
 
+/**
+ * Interface representing the cryptographic secrets generated for a wallet
+ */
 export interface GeneratedSecrets {
-  wallet_id: string // UUID as string
-  blinder_seed: `0x${string}` // Hex string
-  share_seed: `0x${string}` // Hex string
-  symmetric_key: `0x${string}` // Hex string
-  sk_match: `0x${string}` // Hex string
+  /** Unique identifier for the wallet in UUID format */
+  wallet_id: string
+
+  /** Cryptographic seed for the wallet's blinder CSPRNG*/
+  blinder_seed: `0x${string}`
+
+  /** Cryptographic seed for the wallet's share CSPRNG */
+  share_seed: `0x${string}`
+
+  /** Encryption key for authenticating API requests */
+  symmetric_key: `0x${string}`
+
+  /** Secret key used for matching operations */
+  sk_match: `0x${string}`
 }
 
 export async function generateWalletSecrets(
-  config: Config,
   signMessage: (message: string) => Promise<SignMessageReturnType>,
-  publicKey: string,
 ): Promise<GeneratedSecrets> {
-  const { utils } = config
-  console.log('Generating wallet secrets for public key:', publicKey)
-  const secrets = await utils.generate_wallet_secrets(signMessage, publicKey)
+  const secrets = await generate_wallet_secrets(signMessage)
   const parsedSecrets = JSON.parse(secrets) as GeneratedSecrets
   return parsedSecrets
 }

packages/node/src/exports/byok.ts

@@ -1,51 +1,84 @@
-export {
-  deposit,
-  type DepositParameters,
-  type DepositReturnType,
-} from '../actions/byok/deposit.js'
+import { createBYOKConfig as core_createBYOKConfig } from '../utils/createBYOKConfig.js'
+import * as RustUtils from '../../renegade-utils/index.js'
+
+////////////////////////////////////////////////////////////////////////////////
+// Config
+////////////////////////////////////////////////////////////////////////////////
+
+function createBYOKConfig(
+  ...args: Parameters<typeof core_createBYOKConfig>
+): ReturnType<typeof core_createBYOKConfig> {
+  const config = core_createBYOKConfig({
+    ...args[0],
+    utils: RustUtils,
+  })
+  return config
+}
+
+export { createBYOKConfig }
+
+////////////////////////////////////////////////////////////////////////////////
+// Actions (Bring Your Own Key)
+////////////////////////////////////////////////////////////////////////////////
+
 export {
   createWallet,
   type CreateWalletParameters,
   type CreateWalletReturnType,
 } from '../actions/byok/createWallet.js'
+
 export {
   generateWalletSecrets,
   type GeneratedSecrets,
 } from '../actions/byok/generateWalletSecrets.js'
+
 export {
   getPkRootScalars,
   type GetPkRootParameters,
   type GetPkRootScalarsReturnType,
 } from '../actions/byok/getPkRoot.js'
+
 export {
   getBackOfQueueWallet,
   type GetBackOfQueueWalletParameters,
   type GetBackOfQueueWalletReturnType,
 } from '../actions/byok/getBackOfQueueWallet.js'
+
+export {
+  lookupWallet,
+  type LookupWalletParameters,
+  type LookupWalletReturnType,
+} from '../actions/byok/lookupWallet.js'
+
+export {
+  deposit,
+  type DepositParameters,
+  type DepositReturnType,
+} from '../actions/byok/deposit.js'
+
 export {
   withdraw,
   type WithdrawParameters,
   type WithdrawReturnType,
 } from '../actions/byok/withdraw.js'
+
+export {
+  payFees,
+  type PayFeesReturnType,
+} from '../actions/byok/payFees.js'
+
 export {
   createOrder,
   type CreateOrderParameters,
   type CreateOrderReturnType,
 } from '../actions/byok/createOrder.js'
+
 export {
   cancelOrder,
   type CancelOrderParameters,
   type CancelOrderReturnType,
 } from '../actions/byok/cancelOrder.js'
-export {
-  lookupWallet,
-  type LookupWalletParameters,
-  type LookupWalletReturnType,
-} from '../actions/byok/lookupWallet.js'
-export {
-  payFees,
-  type PayFeesReturnType,
-} from '../actions/byok/payFees.js'
+
 export {
   getOrderHistory,
   type GetOrderHistoryParameters,

packages/node/src/exports/index.ts

@@ -6,7 +6,6 @@ import {
   createAuthConfig as core_createAuthConfig,
   createConfig as core_createConfig,
 } from '@renegade-fi/core'
-import { createBYOKConfig as core_createBYOKConfig } from '../utils/createBYOKConfig.js'
 
 import * as RustUtils from '../../renegade-utils/index.js'
 
@@ -30,17 +29,8 @@ function createAuthConfig(
   return config
 }
 
-function createBYOKConfig(
-  ...args: Parameters<typeof core_createBYOKConfig>
-): ReturnType<typeof core_createBYOKConfig> {
-  const config = core_createBYOKConfig({
-    ...args[0],
-    utils: RustUtils,
-  })
-  return config
-}
 
-export { createAuthConfig, createConfig, createBYOKConfig }
+export { createAuthConfig, createConfig }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Actions

wasm/src/exports/byok/create_order.rs

@@ -43,18 +43,15 @@ pub async fn byok_create_order(
     let mut wallet = deserialize_wallet(wallet_str)?;
     handle_key_rotation(&mut wallet, &public_key)?;
 
-    let amount_u128 = params.amount_as_u128()?;
-    let min_fill_size_u128 = params.min_fill_size_as_u128()?;
-
     let order = ApiOrder {
         id: params.id,
         base_mint: params.base_mint,
         quote_mint: params.quote_mint,
         side: params.side,
-        amount: amount_u128,
+        amount: params.amount,
         worst_case_price: params.worst_case_price,
         type_: crate::external_api::types::ApiOrderType::Midpoint,
-        min_fill_size: min_fill_size_u128,
+        min_fill_size: params.min_fill_size,
         allow_external_matches: params.allow_external_matches,
     };
 

wasm/src/exports/byok/find_wallet.rs

@@ -2,7 +2,7 @@ use wasm_bindgen::prelude::*;
 
 use crate::{
     exports::byok::parameters::FindWalletParameters, external_api::wallet::FindWalletRequest,
-    serialize_to_js, types::scalar_to_biguint,
+    serialize_to_js,
 };
 
 #[wasm_bindgen]
@@ -25,8 +25,8 @@ pub async fn byok_find_wallet(
 
     let request = FindWalletRequest {
         wallet_id: params.wallet_id,
-        blinder_seed: scalar_to_biguint(&params.blinder_seed),
-        secret_share_seed: scalar_to_biguint(&params.share_seed),
+        blinder_seed: params.blinder_seed,
+        secret_share_seed: params.share_seed,
         private_keychain: params.key_chain.private_keys,
     };
 

wasm/src/exports/byok/key_rotation.rs

@@ -18,7 +18,6 @@ pub fn handle_key_rotation(wallet: &mut Wallet, new_public_key: &str) -> Result<
     let current_pk_root = wallet.key_chain.pk_root().to_uncompressed_bytes();
 
     if current_pk_root != new_pk_root {
-        // Key has been rotated
         wallet.key_chain.increment_nonce();
         let new_pk_root = PublicSigningKey::from_bytes(&new_pk_root)
             .map_err(|e| Error::new(format!("Failed to parse public key: {}", e)))?;

wasm/src/exports/byok/mod.rs

@@ -20,5 +20,5 @@ pub use create_wallet::byok_create_wallet;
 pub use deposit::byok_deposit;
 pub use find_wallet::byok_find_wallet;
 pub use generate_wallet_secrets::generate_wallet_secrets;
-pub use signature::{authorize_withdrawal, generate_signature, generate_statement_signature};
+pub use signature::{authorize_withdrawal, generate_signature};
 pub use withdraw::byok_withdraw;

wasm/src/exports/byok/parameters/order.rs

@@ -13,9 +13,9 @@ pub struct CreateOrderParameters {
     pub base_mint: BigUint,
     pub quote_mint: BigUint,
     pub side: OrderSide,
-    pub amount: BigUint,
+    pub amount: u128,
     pub worst_case_price: FixedPoint,
-    pub min_fill_size: BigUint,
+    pub min_fill_size: u128,
     pub allow_external_matches: bool,
 }
 
@@ -50,10 +50,16 @@ impl CreateOrderParameters {
             .map_err(|e| Error::invalid_parameter(format!("Invalid quote mint: {}", e)))?;
 
         let amount = biguint_from_hex_string(amount)
-            .map_err(|e| Error::invalid_parameter(format!("Invalid amount: {}", e)))?;
+            .map_err(|e| Error::invalid_parameter(format!("Invalid amount: {}", e)))?
+            .to_u128()
+            .ok_or_else(|| Error::invalid_parameter(format!("Could not convert amount to u128")))?;
 
         let min_fill_size = biguint_from_hex_string(min_fill_size)
-            .map_err(|e| Error::invalid_parameter(format!("Invalid min fill size: {}", e)))?;
+            .map_err(|e| Error::invalid_parameter(format!("Invalid min fill size: {}", e)))?
+            .to_u128()
+            .ok_or_else(|| {
+                Error::invalid_parameter(format!("Could not convert min fill size to u128"))
+            })?;
 
         let worst_case_price = if worst_case_price.is_empty() {
             match side {
@@ -78,16 +84,4 @@ impl CreateOrderParameters {
             allow_external_matches,
         })
     }
-
-    pub fn amount_as_u128(&self) -> Result<u128, Error> {
-        self.amount.to_u128().ok_or_else(|| {
-            Error::invalid_parameter(format!("Could not convert {} to u128", self.amount))
-        })
-    }
-
-    pub fn min_fill_size_as_u128(&self) -> Result<u128, Error> {
-        self.min_fill_size.to_u128().ok_or_else(|| {
-            Error::invalid_parameter(format!("Could not convert {} to u128", self.min_fill_size))
-        })
-    }
 }

wasm/src/exports/byok/parameters/wallet.rs

@@ -1,3 +1,4 @@
+use num_bigint::BigUint;
 use serde::Serialize;
 use uuid::Uuid;
 
@@ -73,8 +74,8 @@ impl CreateWalletParameters {
 
 pub struct FindWalletParameters {
     pub wallet_id: Uuid,
-    pub blinder_seed: Scalar,
-    pub share_seed: Scalar,
+    pub blinder_seed: BigUint,
+    pub share_seed: BigUint,
     pub key_chain: ApiKeychain,
 }
 
@@ -90,12 +91,10 @@ impl FindWalletParameters {
         // Wallet seed info
         let wallet_id = Uuid::parse_str(wallet_id)
             .map_err(|e| Error::invalid_parameter(format!("wallet_id: {}", e)))?;
-        let blinder_seed_bigint = biguint_from_hex_string(blinder_seed)
+        let blinder_seed = biguint_from_hex_string(blinder_seed)
             .map_err(|e| Error::invalid_parameter(format!("blinder_seed: {}", e)))?;
-        let blinder_seed = Scalar::from(blinder_seed_bigint);
-        let share_seed_bigint = biguint_from_hex_string(share_seed)
+        let share_seed = biguint_from_hex_string(share_seed)
             .map_err(|e| Error::invalid_parameter(format!("share_seed: {}", e)))?;
-        let share_seed = Scalar::from(share_seed_bigint);
 
         // KeyChain
         let sk_match_bigint = biguint_from_hex_string(sk_match)