@dydxprotocol/v4-client-js 3.0.2 → 3.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dydxprotocol/v4-client-js",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "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);
+};