@dydxprotocol/v4-client-js 2.4.0 → 2.5.1

package/examples/constants.ts

@@ -17,6 +17,9 @@ export const DYDX_LOCAL_MNEMONIC =
 
 export const DYDX_TEST_MNEMONIC_2 = 'movie yard still copper exile wear brisk chest ride dizzy novel future menu finish radar lunar claim hub middle force turtle mouse frequent embark';
 
+// dydx1fxu2ndxwju2evh28js0cflkxn5wxzvlhw4gec5
+export const DYDX_TEST_MNEMONIC_3 = 'crane poverty boil edit response weasel quick almost fringe able upon benefit boil boat narrow innocent enter cradle tongue toward luggage awful mention column';
+
 export const MARKET_BTC_USD: string = 'BTC-USD';
 export const PERPETUAL_PAIR_BTC_USD: number = 0;
 

package/examples/permissioned_keys_example.ts

@@ -8,11 +8,12 @@ import { CompositeClient } from '../src/clients/composite-client';
 import { AuthenticatorType, Network, OrderSide, 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 } from './constants';
+import { DYDX_TEST_MNEMONIC, DYDX_TEST_MNEMONIC_2, DYDX_TEST_MNEMONIC_3 } 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 client = await CompositeClient.connect(network);
@@ -23,28 +24,53 @@ async function test(): Promise<void> {
 
   const subaccount1 = new SubaccountInfo(wallet1, 0);
   const subaccount2 = new SubaccountInfo(wallet2, 0);
+  const subaccount3 = new SubaccountInfo(wallet3, 0);
 
   // Change second wallet pubkey
   // Add an authenticator to allow wallet2 to place orders
   console.log("** Adding authenticator **");
-  await addAuthenticator(client, subaccount1, wallet2.pubKey!.value);
-
-  const authenticators = await client.getAuthenticators(wallet1.address!);
+  // Record authenticator count before adding
+  const authsBefore = await client.getAuthenticators(wallet1.address!);
+  const beforeCount = authsBefore.accountAuthenticators.length;
+  console.log(`Authenticators before: ${beforeCount}`);
+  await addTestAuthenticator(client, subaccount1, wallet2.pubKey!.value);
+
+  console.log("** Waiting 3 seconds for txn to be confirmed **");
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+
+  const authsAfter = await client.getAuthenticators(wallet1.address!);
+  const afterCount = authsAfter.accountAuthenticators.length;
+  console.log(`Authenticators after: ${afterCount}`);
+  if (afterCount !== beforeCount + 1) {
+    console.error('Authenticator count did not increment by 1.');
+    process.exit(1);
+  } else {
+    console.log('Authenticator count incremented by 1 as expected.');
+  }
   // Last element in authenticators array is the most recently created
-  const lastElement = authenticators.accountAuthenticators.length - 1;
-  const authenticatorID = authenticators.accountAuthenticators[lastElement].id;
+  const lastElement = authsAfter.accountAuthenticators.length - 1;
+  const newAuthenticatorID = authsAfter.accountAuthenticators[lastElement].id;
+
+  console.log(`New authenticator ID: ${newAuthenticatorID}`);
 
   // Placing order using subaccount2 for subaccount1 succeeds
-  console.log("** Placing order with authenticator **");
-  await placeOrder(client, subaccount2, subaccount1, authenticatorID);
+  console.log("** Placing order for subaccount1 with subaccount2 + authenticator, should succeed **");
+  await placeOrder(client, subaccount2, subaccount1, newAuthenticatorID);
+
+  // Placing order using subaccount3 for subaccount1 should fail
+  console.log("** Placing order for subaccount1 with subaccount3 + authenticator, should fail **");
+  await placeOrder(client, subaccount3, subaccount1, newAuthenticatorID);
 
   // Remove authenticator
   console.log("** Removing authenticator **");
-  await removeAuthenticator(client, subaccount1, authenticatorID);
+  await removeAuthenticator(client, subaccount1, newAuthenticatorID);
 
+  console.log("** Waiting 3 seconds for txn to be confirmed **");
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+  
   // Placing an order using subaccount2 will now fail
-  console.log("** Placing order with invalid authenticator should fail **");
-  await placeOrder(client, subaccount2, subaccount1, authenticatorID);
+  console.log("** Placing order with removed authenticator should fail **");
+  await placeOrder(client, subaccount2, subaccount1, newAuthenticatorID);
 }
 
 async function removeAuthenticator(
@@ -55,38 +81,41 @@ async function removeAuthenticator(
   await client.removeAuthenticator(subaccount, id);
 }
 
-async function addAuthenticator(
+async function addTestAuthenticator(
   client: CompositeClient,
   subaccount: SubaccountInfo,
   authedPubKey: string,
 ): Promise<void> {
-  const subAuth = [ {
-    type: AuthenticatorType.SIGNATURE_VERIFICATION,
-    config: authedPubKey,
-  },
-  {
-    type: AuthenticatorType.ANY_OF,
-    config: [
+  const msgType = (s: string): string => toBase64(new TextEncoder().encode(s));
+  const anyOfSubAuth = [
     {
       type: AuthenticatorType.MESSAGE_FILTER,
-      config: toBase64(new TextEncoder().encode('/dydxprotocol.clob.MsgPlaceOrder')),
+      config: msgType('/dydxprotocol.clob.MsgPlaceOrder'),
     },
     {
       type: AuthenticatorType.MESSAGE_FILTER,
-      config: toBase64(new TextEncoder().encode('/dydxprotocol.clob.MsgPlaceOrder')),
+      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);
 
-  try {
-    await client.addAuthenticator(subaccount, AuthenticatorType.ALL_OF, encodedData);
-  } catch (error) {
-    console.log(error.message);
-  }
+  await client.addAuthenticator(subaccount, AuthenticatorType.ALL_OF, encodedData);
 }
 
 async function placeOrder(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dydxprotocol/v4-client-js",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "description": "General client library for the new dYdX system (v4 decentralized)",
   "main": "build/cjs/src/index.js",
   "module": "build/esm/src/index.js",
@@ -62,6 +62,7 @@
     "cosmjs-types": "^0.9.0",
     "ethereum-cryptography": "^2.0.0",
     "ethers": "^6.6.1",
+    "https-proxy-agent": "^7.0.6",
     "long": "^4.0.0",
     "protobufjs": ">=6.11.4",
     "ws": "^8.14.2"

package/src/clients/composite-client.ts

@@ -1084,7 +1084,7 @@ export class CompositeClient {
           console.log(err);
         });
     });
-    const signature = await this.sign(wallet, () => msgs, true);
+    const signature = await this.sign(subaccount.wallet, () => msgs, true);
 
     return Buffer.from(signature).toString('base64');
   }
@@ -1414,34 +1414,41 @@ export class CompositeClient {
   }
 
   validateAuthenticator(authenticator: Authenticator): boolean {
-    function checkAuthenticator(auth: Authenticator): boolean {
-      if (auth.type === AuthenticatorType.SIGNATURE_VERIFICATION) {
-        return true; // A SignatureVerification authenticator is safe.
+    const decodeCompositeConfig = (config: unknown): Authenticator[] | null => {
+      if (Array.isArray(config)) {
+        return config as Authenticator[];
       }
-
-      if (!Array.isArray(auth.config)) {
-        return false; // Unsafe case: a non-array config for a composite authenticator
+      if (typeof config === 'string') {
+        try {
+          const decoded = Buffer.from(config, 'base64').toString('utf8');
+          const parsed = JSON.parse(decoded);
+          return Array.isArray(parsed) ? (parsed as Authenticator[]) : null;
+        } catch {
+          return null;
+        }
       }
+      return null;
+    };
 
-      if (auth.type === AuthenticatorType.ANY_OF) {
-        // ANY_OF is safe only if ALL sub-authenticators return true
-        return auth.config.every((nestedAuth) => checkAuthenticator(nestedAuth));
+    const checkAuthenticator = (auth: Authenticator): boolean => {
+      if (auth.type === AuthenticatorType.SIGNATURE_VERIFICATION) {
+        return true;
       }
 
-      if (auth.type === AuthenticatorType.ALL_OF) {
-        // ALL_OF is safe if at least one sub-authenticator returns true
-        return auth.config.some((nestedAuth) => checkAuthenticator(nestedAuth));
+      if (auth.type === AuthenticatorType.ANY_OF || auth.type === AuthenticatorType.ALL_OF) {
+        const subAuthenticators = decodeCompositeConfig(auth.config);
+        if (subAuthenticators == null) {
+          return false;
+        }
+        if (auth.type === AuthenticatorType.ANY_OF) {
+          return subAuthenticators.every((nested) => checkAuthenticator(nested));
+        }
+        return subAuthenticators.some((nested) => checkAuthenticator(nested));
       }
 
-      // If it's a base-case authenticator but not SignatureVerification, it's unsafe
-      return false;
-    }
-
-    // The top-level authenticator must pass validation
-    if (!checkAuthenticator(authenticator)) {
       return false;
-    }
+    };
 
-    return true;
+    return checkAuthenticator(authenticator);
   }
 }

package/src/clients/constants.ts

@@ -1,4 +1,5 @@
 import { PageRequest } from '@dydxprotocol/v4-proto/src/codegen/cosmos/base/query/v1beta1/pagination';
+import { AxiosProxyConfig } from 'axios';
 import Long from 'long';
 
 import { BroadcastOptions, DenomConfig } from './types';
@@ -243,10 +244,12 @@ export const PAGE_REQUEST: PageRequest = {
 export class IndexerConfig {
   public restEndpoint: string;
   public websocketEndpoint: string;
+  public proxy?: AxiosProxyConfig;
 
-  constructor(restEndpoint: string, websocketEndpoint: string) {
+  constructor(restEndpoint: string, websocketEndpoint: string, proxy?: AxiosProxyConfig) {
     this.restEndpoint = restEndpoint;
     this.websocketEndpoint = websocketEndpoint;
+    this.proxy = proxy;
   }
 }
 

package/src/clients/indexer-client.ts

@@ -19,10 +19,10 @@ export class IndexerClient {
     this.config = config;
     this.apiTimeout = apiTimeout ?? DEFAULT_API_TIMEOUT;
 
-    this._markets = new MarketsClient(config.restEndpoint);
-    this._account = new AccountClient(config.restEndpoint);
-    this._utility = new UtilityClient(config.restEndpoint);
-    this._vault = new VaultClient(config.restEndpoint);
+    this._markets = new MarketsClient(config.restEndpoint, apiTimeout, config.proxy);
+    this._account = new AccountClient(config.restEndpoint, apiTimeout, config.proxy);
+    this._utility = new UtilityClient(config.restEndpoint, apiTimeout, config.proxy);
+    this._vault = new VaultClient(config.restEndpoint, apiTimeout, config.proxy);
   }
 
   /**

package/src/clients/modules/rest.ts

@@ -1,24 +1,30 @@
+import axios, { AxiosInstance, AxiosProxyConfig } from 'axios';
+
 import { DEFAULT_API_TIMEOUT } from '../constants';
 import { generateQueryPath } from '../helpers/request-helpers';
-import { RequestMethod, Response, request } from '../lib/axios';
+import { Response } from '../lib/axios';
 import { Data } from '../types';
 
 export default class RestClient {
   readonly host: string;
   readonly apiTimeout: Number;
+  readonly axiosInstance: AxiosInstance;
 
-  constructor(host: string, apiTimeout?: Number | null) {
+  constructor(host: string, apiTimeout?: Number | null, proxy?: AxiosProxyConfig) {
     if (host.endsWith('/')) {
       this.host = host.slice(0, -1);
     } else {
       this.host = host;
     }
     this.apiTimeout = apiTimeout || DEFAULT_API_TIMEOUT;
+    this.axiosInstance = axios.create({
+      proxy,
+    });
   }
 
   async get(requestPath: string, params: {} = {}): Promise<Data> {
     const url = `${this.host}${generateQueryPath(requestPath, params)}`;
-    const response = await request(url);
+    const response = await this.axiosInstance.get(url);
     return response.data;
   }
 
@@ -29,6 +35,6 @@ export default class RestClient {
     headers: {} = {},
   ): Promise<Response> {
     const url = `${this.host}${generateQueryPath(requestPath, params)}`;
-    return request(url, RequestMethod.POST, body, headers);
+    return this.axiosInstance.post(url, body, { headers });
   }
 }

package/src/clients/socket-client.ts

@@ -1,5 +1,7 @@
+import { HttpsProxyAgent } from 'https-proxy-agent';
 import WebSocket, { ErrorEvent, MessageEvent } from 'ws';
 
+import { getProxyAgent } from '../lib/utils';
 import { IndexerConfig } from './constants';
 
 enum OutgoingMessageTypes {
@@ -37,6 +39,7 @@ export enum CandlesResolution {
 export class SocketClient {
   private url: string;
   private ws?: WebSocket;
+  private proxyAgent?: HttpsProxyAgent<string>;
   private onOpenCallback?: () => void;
   private onCloseCallback?: () => void;
   private onMessageCallback?: (event: MessageEvent) => void;
@@ -51,6 +54,7 @@ export class SocketClient {
     onErrorCallback: (event: ErrorEvent) => void,
   ) {
     this.url = config.websocketEndpoint;
+    this.proxyAgent = config.proxy ? getProxyAgent(config.proxy) : undefined;
     this.onOpenCallback = onOpenCallback;
     this.onCloseCallback = onCloseCallback;
     this.onMessageCallback = onMessageCallback;
@@ -58,7 +62,9 @@ export class SocketClient {
   }
 
   connect(): void {
-    this.ws = new WebSocket(this.url);
+    this.ws = new WebSocket(this.url, {
+      agent: this.proxyAgent,
+    });
     this.ws.addEventListener('open', this.handleOpen.bind(this));
     this.ws.addEventListener('close', this.handleClose.bind(this));
     this.ws.addEventListener('message', this.handleMessage.bind(this));

package/src/lib/utils.ts

@@ -1,3 +1,6 @@
+import { AxiosProxyConfig } from 'axios';
+import { HttpsProxyAgent } from 'https-proxy-agent';
+
 import { MAX_UINT_32 } from '../clients/constants';
 
 /**
@@ -74,3 +77,8 @@ export function calculateClockOffsetFromFetchDateHeader(
 
   return Math.floor(offset);
 }
+
+export function getProxyAgent(proxy: AxiosProxyConfig): HttpsProxyAgent<string> {
+  const auth = proxy.auth ? `${proxy.auth.username}:${proxy.auth.password}@` : '';
+  return new HttpsProxyAgent(`${proxy.protocol}://${auth}${proxy.host}:${proxy.port}`);
+}