@dydxprotocol/v4-client-js 3.0.2 → 3.0.4

package/examples/permissioned_keys_example.ts

@@ -1,19 +1,29 @@
-import { toBase64 } from '@cosmjs/encoding';
-import { Order_TimeInForce } from '@dydxprotocol/v4-proto/src/codegen/dydxprotocol/clob/order';
+import Long from 'long';
 
 import { BECH32_PREFIX } from '../src';
 import { CompositeClient } from '../src/clients/composite-client';
-import { AuthenticatorType, Network, OrderSide, SelectedGasDenom } from '../src/clients/constants';
+import {
+  Network,
+  OrderExecution,
+  OrderSide,
+  OrderTimeInForce,
+  OrderType,
+  SelectedGasDenom,
+} from '../src/clients/constants';
 import LocalWallet from '../src/clients/modules/local-wallet';
 import { SubaccountInfo } from '../src/clients/subaccount';
-import { DYDX_TEST_MNEMONIC, DYDX_TEST_MNEMONIC_2, DYDX_TEST_MNEMONIC_3 } from './constants';
+import {
+  createNewRandomDydxWallet,
+  getAuthorizeNewTradingKeyArguments,
+  getAuthorizedTradingKeysMetadata,
+} from '../src/lib/trading-key-utils';
+import { DYDX_TEST_MNEMONIC, DYDX_TEST_MNEMONIC_2 } from './constants';
 
 async function test(): Promise<void> {
   const wallet1 = await LocalWallet.fromMnemonic(DYDX_TEST_MNEMONIC, BECH32_PREFIX);
   const wallet2 = await LocalWallet.fromMnemonic(DYDX_TEST_MNEMONIC_2, BECH32_PREFIX);
-  const wallet3 = await LocalWallet.fromMnemonic(DYDX_TEST_MNEMONIC_3, BECH32_PREFIX);
 
-  const network = Network.staging();
+  const network = Network.testnet();
   const client = await CompositeClient.connect(network);
   client.setSelectedGasDenom(SelectedGasDenom.NATIVE);
 
@@ -22,7 +32,6 @@ async function test(): Promise<void> {
 
   const subaccount1 = SubaccountInfo.forLocalWallet(wallet1, 0);
   const subaccount2 = SubaccountInfo.forLocalWallet(wallet2, 0);
-  const subaccount3 = SubaccountInfo.forLocalWallet(wallet3, 0);
 
   // Change second wallet pubkey
   // Add an authenticator to allow wallet2 to place orders
@@ -31,7 +40,12 @@ async function test(): Promise<void> {
   const authsBefore = await client.getAuthenticators(wallet1.address!);
   const beforeCount = authsBefore.accountAuthenticators.length;
   console.log(`Authenticators before: ${beforeCount}`);
-  await addTestAuthenticator(client, subaccount1, wallet2.pubKey!.value);
+
+  const apiTradingWalletInfo1 = await createApiTradingWallet(client, subaccount1);
+  const apiTradingWallet1 = await LocalWallet.fromPrivateKey(
+    apiTradingWalletInfo1.privteKeyHex,
+    BECH32_PREFIX,
+  );
 
   console.log('** Waiting 3 seconds for txn to be confirmed **');
   await new Promise((resolve) => setTimeout(resolve, 3000));
@@ -45,21 +59,29 @@ async function test(): Promise<void> {
   } else {
     console.log('Authenticator count incremented by 1 as expected.');
   }
-  // Last element in authenticators array is the most recently created
-  const lastElement = authsAfter.accountAuthenticators.length - 1;
-  const newAuthenticatorID = authsAfter.accountAuthenticators[lastElement].id;
 
+  const parsedAuths = getAuthorizedTradingKeysMetadata(authsAfter.accountAuthenticators);
+  const newAuthenticatorID = parsedAuths.find(
+    (a) => apiTradingWallet1.address != null && a.address === apiTradingWallet1.address,
+  )?.id;
+  if (newAuthenticatorID == null) {
+    console.error(
+      'Unable to locate the created authenticator. Address: ',
+      apiTradingWallet1.address,
+    );
+    throw new Error('Unable to locate the new authenticator');
+  }
   console.log(`New authenticator ID: ${newAuthenticatorID}`);
 
   // Placing order using subaccount2 for subaccount1 succeeds
   console.log(
     '** Placing order for subaccount1 with subaccount2 + authenticator, should succeed **',
   );
-  await placeOrder(client, subaccount2, subaccount1, newAuthenticatorID);
+  await placeOrder(client, apiTradingWallet1, subaccount1.address, newAuthenticatorID);
 
-  // Placing order using subaccount3 for subaccount1 should fail
+  // Placing order using subaccount2 for subaccount1 should fail
   console.log('** Placing order for subaccount1 with subaccount3 + authenticator, should fail **');
-  await placeOrder(client, subaccount3, subaccount1, newAuthenticatorID);
+  await placeOrder(client, subaccount2.signingWallet, subaccount1.address, newAuthenticatorID);
 
   // Remove authenticator
   console.log('** Removing authenticator **');
@@ -70,91 +92,65 @@ async function test(): Promise<void> {
 
   // Placing an order using subaccount2 will now fail
   console.log('** Placing order with removed authenticator should fail **');
-  await placeOrder(client, subaccount2, subaccount1, newAuthenticatorID);
+  await placeOrder(client, apiTradingWallet1, subaccount1.address, newAuthenticatorID);
 }
 
 async function removeAuthenticator(
   client: CompositeClient,
   subaccount: SubaccountInfo,
-  id: Long,
+  id: string,
 ): Promise<void> {
-  await client.removeAuthenticator(subaccount, id.toString());
+  await client.removeAuthenticator(subaccount, id);
 }
 
-async function addTestAuthenticator(
+async function createApiTradingWallet(
   client: CompositeClient,
   subaccount: SubaccountInfo,
-  authedPubKey: string,
-): Promise<void> {
-  const msgType = (s: string): string => toBase64(new TextEncoder().encode(s));
-  const anyOfSubAuth = [
-    {
-      type: AuthenticatorType.MESSAGE_FILTER,
-      config: msgType('/dydxprotocol.clob.MsgPlaceOrder'),
-    },
-    {
-      type: AuthenticatorType.MESSAGE_FILTER,
-      config: msgType('/dydxprotocol.sending.MsgCreateTransfer'),
-    },
-  ];
-
-  // Nested AnyOf config must be base64(JSON([...])) as on-chain expects []byte
-  const anyOfConfigB64 = toBase64(new TextEncoder().encode(JSON.stringify(anyOfSubAuth)));
-
-  const subAuth = [
-    {
-      type: AuthenticatorType.SIGNATURE_VERIFICATION,
-      config: authedPubKey,
-    },
-    {
-      type: AuthenticatorType.ANY_OF,
-      config: anyOfConfigB64,
-    },
-  ];
-
-  const jsonString = JSON.stringify(subAuth);
-  const encodedData = new TextEncoder().encode(jsonString);
-
-  await client.addAuthenticator(subaccount, AuthenticatorType.ALL_OF, encodedData);
+): Promise<{ privteKeyHex: string; forDydxAddress: string }> {
+  const wallet = await createNewRandomDydxWallet();
+  if (wallet == null) {
+    throw new Error("Couldn't create wallet");
+  }
+  const { data, type } = getAuthorizeNewTradingKeyArguments({
+    generatedWalletPubKey: wallet?.publicKey,
+  });
+  console.log('adding', wallet.address);
+  await client.addAuthenticator(subaccount, type, data);
+  return { privteKeyHex: wallet.privateKeyHex, forDydxAddress: subaccount.address };
 }
 
 async function placeOrder(
   client: CompositeClient,
-  fromAccount: SubaccountInfo,
-  forAccount: SubaccountInfo,
-  authenticatorId: Long,
+  apiTradingWallet: LocalWallet,
+  forAccountAddress: string,
+  authenticatorId: string,
 ): Promise<void> {
   try {
     const side = OrderSide.BUY;
-    const price = Number('1000');
-    const currentBlock = await client.validatorClient.get.latestBlockHeight();
-    const nextValidBlockHeight = currentBlock + 5;
-    const goodTilBlock = nextValidBlockHeight + 10;
-
-    const timeInForce = Order_TimeInForce.TIME_IN_FORCE_UNSPECIFIED;
+    const price = Number('10000');
 
     const clientId = Math.floor(Math.random() * 10000);
 
-    const tx = await client.placeShortTermOrder(
-      SubaccountInfo.forPermissionedWallet(
-        fromAccount.signingWallet,
-        forAccount.address,
-        forAccount.subaccountNumber,
-        [authenticatorId],
-      ),
+    const tx = await client.placeOrder(
+      SubaccountInfo.forPermissionedWallet(apiTradingWallet, forAccountAddress, 0, [
+        Long.fromString(authenticatorId),
+      ]),
       'ETH-USD',
+      OrderType.MARKET,
       side,
       price,
       0.01,
       clientId,
-      goodTilBlock,
-      timeInForce,
+      OrderTimeInForce.IOC,
+      100,
+      OrderExecution.IOC,
+      false,
       false,
-      undefined,
     );
     console.log('**Order Tx**');
     console.log(Buffer.from(tx.hash).toString('hex'));
-  } catch (error) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (error: any) {
     console.log(error.message);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dydxprotocol/v4-client-js",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "General client library for the new dYdX system (v4 decentralized)",
   "main": "build/cjs/src/index.js",
   "module": "build/esm/src/index.js",

package/src/index.ts

@@ -4,6 +4,7 @@ export * from './types';
 // Utility functions.
 export * as helpers from './lib/helpers';
 export * as onboarding from './lib/onboarding';
+export * as tradingKeyUtils from './lib/trading-key-utils';
 export * as utils from './lib/utils';
 export * as validation from './lib/validation';
 

package/src/lib/trading-key-utils.ts

@@ -0,0 +1,136 @@
+import { fromBase64, toBase64, toBech32, toHex } from '@cosmjs/encoding';
+import { rawSecp256k1PubkeyToRawAddress } from '@cosmjs/tendermint-rpc';
+import { generateMnemonic } from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english';
+
+import {
+  Authenticator,
+  AuthenticatorType,
+  TYPE_URL_BATCH_CANCEL,
+  TYPE_URL_MSG_CANCEL_ORDER,
+  TYPE_URL_MSG_PLACE_ORDER,
+} from '../clients/constants';
+import { type Get } from '../clients/modules/get';
+import LocalWallet from '../clients/modules/local-wallet';
+import { BECH32_PREFIX } from './constants';
+import { deriveHDKeyFromMnemonic } from './onboarding';
+
+export const createNewRandomDydxWallet = async (): Promise<
+  { privateKeyHex: string; mnemonic: string; publicKey: string; address: string } | undefined
+> => {
+  const mnemonic = generateMnemonic(wordlist, 128);
+  const { privateKey: privateKeyRaw } = deriveHDKeyFromMnemonic(mnemonic);
+  const wallet = await LocalWallet.fromMnemonic(mnemonic, BECH32_PREFIX);
+
+  const privateKeyHex = privateKeyRaw != null ? `0x${toHex(privateKeyRaw)}` : undefined;
+  const publicKey = wallet.pubKey;
+  const address = wallet.address;
+
+  if (privateKeyHex == null || publicKey == null || address == null) {
+    return undefined;
+  }
+
+  return {
+    // 12 english words
+    mnemonic,
+    // toHex of the raw private key bits
+    privateKeyHex,
+    // base64, not hex
+    publicKey: publicKey.value,
+    // valid dydx address corresponding to the key pair
+    address,
+  };
+};
+
+// arguments to authorize a given wallet public key to trade on behalf of the user.
+// allows place order, cancel order, batch cancel on subaccount 0 only.
+export const getAuthorizeNewTradingKeyArguments = ({
+  generatedWalletPubKey,
+}: {
+  generatedWalletPubKey: string;
+}): { type: AuthenticatorType; data: Uint8Array } => {
+  const wrapAndEncode64 = (s: string): string => toBase64(new TextEncoder().encode(s));
+
+  const messageFilterSubAuth = [
+    {
+      type: AuthenticatorType.MESSAGE_FILTER,
+      config: wrapAndEncode64(TYPE_URL_MSG_PLACE_ORDER),
+    },
+    {
+      type: AuthenticatorType.MESSAGE_FILTER,
+      config: wrapAndEncode64(TYPE_URL_MSG_CANCEL_ORDER),
+    },
+    {
+      type: AuthenticatorType.MESSAGE_FILTER,
+      config: wrapAndEncode64(TYPE_URL_BATCH_CANCEL),
+    },
+  ];
+
+  const anyOfMessageFilterConfigB64 = wrapAndEncode64(JSON.stringify(messageFilterSubAuth));
+
+  const subAuth = [
+    {
+      type: AuthenticatorType.SIGNATURE_VERIFICATION,
+      config: generatedWalletPubKey,
+    },
+    {
+      type: AuthenticatorType.ANY_OF,
+      config: anyOfMessageFilterConfigB64,
+    },
+    // we limit to cross markets to make it slightly harder to drain user funds on low liquidity markets with trading keys
+    // could undo this in the future if people are angry about it
+    {
+      type: AuthenticatorType.SUBACCOUNT_FILTER,
+      config: wrapAndEncode64('0'),
+    },
+  ];
+
+  const jsonString = JSON.stringify(subAuth);
+  const encodedData = new TextEncoder().encode(jsonString);
+  const topLevelType = AuthenticatorType.ALL_OF;
+
+  return {
+    type: topLevelType,
+    data: encodedData,
+  };
+};
+
+// redeclared to keep sub bundle size small
+type Awaited<T> = T extends Promise<infer U> ? U : T;
+const isTruthy = <T>(n?: T | false | null | undefined | 0): n is T => Boolean(n);
+
+// just parses out keys that match the format created in getAuthorizeNewTradingKeyArguments
+export const getAuthorizedTradingKeysMetadata = (
+  authorizedKeys: Awaited<ReturnType<Get['getAuthenticators']>>['accountAuthenticators'],
+): Array<{ id: string; publicKey: string; address: string }> => {
+  return authorizedKeys
+    .map(({ config, id, type }) => {
+      if (type !== AuthenticatorType.ALL_OF) {
+        return null;
+      }
+      const parsedConfig = JSON.parse(new TextDecoder().decode(config)) as
+        | Authenticator[]
+        | undefined;
+      if (parsedConfig == null) {
+        return null;
+      }
+
+      const publicKey = parsedConfig.find(
+        (t) => t.type === AuthenticatorType.SIGNATURE_VERIFICATION,
+      )?.config;
+      if (publicKey == null || typeof publicKey !== 'string') {
+        return null;
+      }
+
+      const address = toBech32(
+        BECH32_PREFIX,
+        rawSecp256k1PubkeyToRawAddress(fromBase64(publicKey)),
+      );
+      return {
+        id: id.toString(),
+        publicKey,
+        address,
+      };
+    })
+    .filter(isTruthy);
+};