@dydxprotocol/v4-client-js 1.16.3 → 1.18.0

package/examples/constants.ts

@@ -15,6 +15,8 @@ export const DYDX_LOCAL_ADDRESS = 'dydx199tqg4wdlnu4qjlxchpd7seg454937hjrknju4';
 export const DYDX_LOCAL_MNEMONIC =
   'merge panther lobster crazy road hollow amused security before critic about cliff exhibit cause coyote talent happy where lion river tobacco option coconut small';
 
+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';
+
 export const MARKET_BTC_USD: string = 'BTC-USD';
 export const PERPETUAL_PAIR_BTC_USD: number = 0;
 

package/examples/permissioned_keys_example.ts

@@ -0,0 +1,110 @@
+import { TextEncoder } from 'util';
+
+import { toBase64 } from '@cosmjs/encoding';
+import { Order_TimeInForce } from '@dydxprotocol/v4-proto/src/codegen/dydxprotocol/clob/order';
+
+import { BECH32_PREFIX } from '../src';
+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';
+
+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 network = Network.staging();
+  const client = await CompositeClient.connect(network);
+  client.setSelectedGasDenom(SelectedGasDenom.NATIVE);
+
+  console.log('**Client**');
+  console.log(client);
+
+  const subaccount1 = new SubaccountInfo(wallet1, 0);
+  const subaccount2 = new SubaccountInfo(wallet2, 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!);
+  // Last element in authenticators array is the most recently created
+  const lastElement = authenticators.accountAuthenticators.length - 1;
+  const authenticatorID = authenticators.accountAuthenticators[lastElement].id;
+
+  // Placing order using subaccount2 for subaccount1 succeeds
+  console.log("** Placing order with authenticator **");
+  await placeOrder(client, subaccount2, subaccount1, authenticatorID);
+
+  // Remove authenticator
+  console.log("** Removing authenticator **");
+  await removeAuthenticator(client, subaccount1, authenticatorID);
+
+  // Placing an order using subaccount2 will now fail
+  console.log("** Placing order with invalid authenticator should fail **");
+  await placeOrder(client, subaccount2, subaccount1, authenticatorID);
+}
+
+async function removeAuthenticator(client: CompositeClient,subaccount: SubaccountInfo, id: Long): Promise<void> {
+  await client.removeAuthenticator(subaccount, id);
+}
+
+async function addAuthenticator(client: CompositeClient, subaccount: SubaccountInfo, authedPubKey:string): Promise<void> {
+  const subAuthenticators = [{
+    type: AuthenticatorType.SIGNATURE_VERIFICATION,
+    config: authedPubKey,
+  },
+  {
+    type: AuthenticatorType.MESSAGE_FILTER,
+    config: toBase64(new TextEncoder().encode("/dydxprotocol.clob.MsgPlaceOrder")),
+  },
+];
+
+  const jsonString = JSON.stringify(subAuthenticators);
+  const encodedData = new TextEncoder().encode(jsonString);
+
+  await client.addAuthenticator(subaccount, AuthenticatorType.ALL_OF, encodedData);
+}
+
+async function placeOrder(client: CompositeClient, fromAccount: SubaccountInfo, forAccount: SubaccountInfo, authenticatorId: Long): 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 clientId = Math.floor(Math.random() * 10000);
+
+    const tx = await client.placeShortTermOrder(
+      fromAccount,
+      'ETH-USD',
+      side,
+      price,
+      0.01,
+      clientId,
+      goodTilBlock,
+      timeInForce,
+      false,
+      undefined,
+      {
+        authenticators: [authenticatorId],
+        accountForOrder: forAccount,
+      }
+    );
+    console.log('**Order Tx**');
+    console.log(Buffer.from(tx.hash).toString('hex'));
+  } catch (error) {
+    console.log(error.message);
+  }
+}
+
+test()
+  .then(() => {})
+  .catch((error) => {
+    console.log(error.message);
+  });

package/examples/websocket_orderbook_example.ts

@@ -0,0 +1,252 @@
+import { Network } from '../src/clients/constants';
+import { SocketClient } from '../src/clients/socket-client';
+
+function test(): void {
+    let orderBookBidList: [number, number, number][] = [];
+    let orderBookAskList: [number, number, number][] = [];
+
+    const mySocket = new SocketClient(
+        Network.mainnet().indexerConfig,
+        () => {
+            console.log('socket opened');
+
+            mySocket.subscribeToOrderbook('ETH-USD');
+        },
+        () => {
+            console.log('socket closed');
+        },
+        (message) => {
+            try {
+                if (typeof message.data === "string") {
+                    const jsonString = message.data;
+                    const parsingData = JSON.parse(jsonString);
+                    const messageId = parsingData.message_id;
+                    const orderBookDataList = parsingData.contents;
+
+                    if (orderBookDataList instanceof Array) {
+                        // common orderBook data;
+                        [orderBookBidList, orderBookAskList] = updateOrderBook(
+                            orderBookDataList,
+                            orderBookBidList,
+                            orderBookAskList,
+                            messageId,
+                        );
+
+                        // sort
+                        orderBookBidList = sortByNthElementDesc(
+                            orderBookBidList,
+                            0,
+                        );
+                        orderBookAskList = sortByNthElementAsc(
+                            orderBookAskList,
+                            0,
+                        );
+
+                        // resolving crossed orderBook
+                        if (
+                            orderBookBidList &&
+                            orderBookAskList &&
+                            orderBookBidList.length > 0 &&
+                            orderBookAskList.length > 0 &&
+                            orderBookBidList[0][0] >= orderBookAskList[0][0]
+                        ) {
+                            [orderBookBidList, orderBookAskList] =
+                                resolveCrossedOrderBook(
+                                    orderBookBidList,
+                                    orderBookAskList,
+                                );
+                        }
+
+                        printOrderBook(orderBookBidList, orderBookAskList);
+
+                        if (orderBookBidList.length > 300) {
+                            orderBookBidList.splice(50);
+                        }
+
+                        if (orderBookAskList.length > 300) {
+                            orderBookAskList.splice(50);
+                        }
+                    } else if (
+                        orderBookDataList !== null &&
+                        orderBookDataList !== undefined
+                    ) {
+                        // initial OrderBook data
+                        setInitialOrderBook(
+                            orderBookDataList,
+                            orderBookBidList,
+                            orderBookAskList,
+                            messageId,
+                        );
+                    }
+                }
+            } catch (e) {
+                console.error('Error parsing JSON message:', e);
+            }
+        },
+        (event) => {
+            console.error('Encountered error:', event.message);
+        },
+    );
+
+    mySocket.connect();
+}
+
+const sortByNthElementAsc = (arr: [number, number, number][], n: number): [number, number, number][] => {
+    return arr.sort((a, b) => {
+        if (a[n] < b[n]) return -1;
+        if (a[n] > b[n]) return 1;
+        return 0;
+    });
+};
+const sortByNthElementDesc = (arr: [number, number, number][], n: number): [number, number, number][] => {
+    return arr.sort((a, b) => {
+        if (a[n] > b[n]) return -1;
+        if (a[n] < b[n]) return 1;
+        return 0;
+    });
+};
+
+const printOrderBook = (
+    orderBookBidList: [number, number, number][],
+    orderBookAskList: [number, number, number][],
+): void => {
+    // print
+    console.log(`OrderBook for ETH-USD:`);
+    console.log(`Price     Qty`);
+    for (let i = 4; i > -1; i--) {
+        const priceStr = String(orderBookAskList[i][0]);
+        const spaces = createSpaces(10 - priceStr.length);
+        console.log(`${priceStr}${spaces}${orderBookAskList[i][1]}`);
+    }
+    console.log('---------------------');
+    for (let i = 0; i < 5; i++) {
+        const priceStr = String(orderBookBidList[i][0]);
+        const spaces = createSpaces(10 - priceStr.length);
+        console.log(`${priceStr}${spaces}${orderBookBidList[i][1]}`);
+    }
+    console.log('');
+};
+
+function createSpaces(count: number): string {
+    if(count <= 0 ){
+        return "";
+    }
+
+    let spaces = "";
+    for (let i = 0; i < count; i++) {
+        spaces += " ";
+    }
+    return spaces;
+}
+
+const resolveCrossedOrderBook = (
+    orderBookBidList: [number, number, number][],
+    orderBookAskList: [number, number, number][],
+): [[number, number, number][], [number, number, number][]] => {
+    while (orderBookBidList[0][0] >= orderBookAskList[0][0]) {
+        if (orderBookBidList[0][2] < orderBookAskList[0][2]) {
+            orderBookBidList.shift();
+        } else if (orderBookBidList[0][2] > orderBookAskList[0][2]) {
+            orderBookAskList.shift();
+        } else {
+            if (orderBookBidList[0][1] > orderBookAskList[0][1]) {
+                orderBookBidList[0][1] -= orderBookAskList[0][1];
+                orderBookAskList.shift();
+            } else if (orderBookBidList[0][1] < orderBookAskList[0][1]) {
+                orderBookAskList[0][1] -= orderBookBidList[0][1];
+                orderBookBidList.shift();
+            } else {
+                orderBookAskList.shift();
+                orderBookBidList.shift();
+            }
+        }
+    }
+
+    return [orderBookBidList, orderBookAskList];
+};
+const setInitialOrderBook = (
+    orderBookDataList: { bids: []; asks: [] },
+    orderBookBidList: [number, number, number][],
+    orderBookAskList: [number, number, number][],
+    messageId: number,
+): void => {
+    orderBookDataList.bids.forEach((item: { price: string; size: string }) => {
+        orderBookBidList.push([Number(item.price), Number(item.size), messageId]);
+    });
+
+    orderBookDataList.asks.forEach((item: { price: string; size: string }) => {
+        orderBookAskList.push([Number(item.price), Number(item.size), messageId]);
+    });
+};
+
+const updateOrderBook = (
+    orderBookDataList: { bids: [[]]; asks: [[]] }[],
+    orderBookBidList: [number, number, number][],
+    orderBookAskList: [number, number, number][],
+    messageId: number,
+): [[number, number, number][], [number, number, number][]] => {
+    orderBookDataList.forEach((entry: { bids: [[]]; asks: [[]] }) => {
+        if (entry.bids !== null && entry.bids !== undefined) {
+            const flattened = entry.bids.reduce((acc: any[], val: any[]) => acc.concat(val), []);
+            const entryBidPrice = Number(flattened[0]);
+            const entryBidSize = Number(flattened[1]);
+
+            // remove prices with zero Qty
+            if (entryBidSize === 0) {
+                for (let i = orderBookBidList.length - 1; i >= 0; i--) {
+                    if (orderBookBidList[i][0] === entryBidPrice) {
+                        orderBookBidList.splice(i, 1);
+                    }
+                }
+            } else {
+                // The price that already exists in the order book is modified only Qty
+                if (
+                    orderBookBidList.some((innerArray) => innerArray[0] === entryBidPrice)
+                ) {
+                    orderBookBidList.forEach((item, index) => {
+                        if (item[0] === entryBidPrice) {
+                            orderBookBidList[index][1] = entryBidSize;
+                            orderBookBidList[index][2] = messageId;
+                        }
+                    });
+                } else {
+                    // Add new data to order book
+                    orderBookBidList.push([entryBidPrice, entryBidSize, messageId]);
+                }
+            }
+        }
+        if (entry.asks !== null && entry.asks !== undefined) {
+            const flattened = entry.asks.reduce((acc: any[], val: any[]) => acc.concat(val), []);
+            const entryAskPrice = Number(flattened[0]);
+            const entryAskSize = Number(flattened[1]);
+
+            if (entryAskSize === 0) {
+                // remove prices with zero Qty
+                for (let i = orderBookAskList.length - 1; i >= 0; i--) {
+                    if (orderBookAskList[i][0] === entryAskPrice) {
+                        orderBookAskList.splice(i, 1);
+                    }
+                }
+            } else {
+                // The price that already exists in the order book is modified only Qty
+                if (
+                    orderBookAskList.some((innerArray) => innerArray[0] === entryAskPrice)
+                ) {
+                    orderBookAskList.forEach((item, index) => {
+                        if (item[0] === entryAskPrice) {
+                            orderBookAskList[index][1] = entryAskSize;
+                            orderBookAskList[index][2] = messageId;
+                        }
+                    });
+                } else {
+                    // Add new data to order book
+                    orderBookAskList.push([entryAskPrice, entryAskSize, messageId]);
+                }
+            }
+        }
+    });
+
+    return [orderBookBidList, orderBookAskList];
+};
+
+test();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dydxprotocol/v4-client-js",
-  "version": "1.16.3",
+  "version": "1.18.0",
   "description": "General client library for the new dYdX system (v4 decentralized)",
   "main": "build/src/index.js",
   "scripts": {
@@ -38,8 +38,8 @@
     "@cosmjs/stargate": "^0.32.1",
     "@cosmjs/tendermint-rpc": "^0.32.1",
     "@cosmjs/utils": "^0.32.1",
+    "@dydxprotocol/v4-proto": "8.0.0",
     "@osmonauts/lcd": "^0.6.0",
-    "@dydxprotocol/v4-proto": "7.0.0-dev.0",
     "@scure/bip32": "^1.1.5",
     "@scure/bip39": "^1.1.1",
     "axios": "1.1.3",

package/src/clients/composite-client.ts

@@ -5,6 +5,7 @@ import {
   BroadcastTxAsyncResponse,
   BroadcastTxSyncResponse,
 } from '@cosmjs/tendermint-rpc/build/tendermint37';
+import { GetAuthenticatorsResponse } from '@dydxprotocol/v4-proto/src/codegen/dydxprotocol/accountplus/query';
 import {
   Order_ConditionType,
   Order_TimeInForce,
@@ -17,6 +18,7 @@ import { bigIntToBytes } from '../lib/helpers';
 import { isStatefulOrder, verifyOrderFlags } from '../lib/validation';
 import { GovAddNewMarketParams, OrderFlags } from '../types';
 import {
+  AuthenticatorType,
   Network,
   OrderExecution,
   OrderSide,
@@ -66,6 +68,11 @@ export interface OrderBatchWithMarketId {
   clientIds: number[];
 }
 
+export interface PermissionedKeysAccountAuth {
+  authenticators: Long[];
+  accountForOrder: SubaccountInfo;
+}
+
 export class CompositeClient {
   public readonly network: Network;
   public gasDenom: SelectedGasDenom = SelectedGasDenom.USDC;
@@ -151,6 +158,7 @@ export class CompositeClient {
     memo?: string,
     broadcastMode?: BroadcastMode,
     account?: () => Promise<Account>,
+    authenticators?: Long[],
   ): Promise<BroadcastTxAsyncResponse | BroadcastTxSyncResponse | IndexedTx> {
     return this.validatorClient.post.send(
       wallet,
@@ -160,6 +168,8 @@ export class CompositeClient {
       memo,
       broadcastMode,
       account,
+      undefined,
+     authenticators,
     );
   }
 
@@ -297,10 +307,15 @@ export class CompositeClient {
     timeInForce: Order_TimeInForce,
     reduceOnly: boolean,
     memo?: string,
+    permissionedKeysAccountAuth?: PermissionedKeysAccountAuth,
   ): Promise<BroadcastTxAsyncResponse | BroadcastTxSyncResponse | IndexedTx> {
+    // For permissioned orders, use the permissioning account details instead of the subaccount
+    // This allows placing orders on behalf of another account when using permissioned keys
+    const accountForOrder = permissionedKeysAccountAuth ? permissionedKeysAccountAuth.accountForOrder : subaccount;
     const msgs: Promise<EncodeObject[]> = new Promise((resolve, reject) => {
+
       const msg = this.placeShortTermOrderMessage(
-        subaccount,
+        accountForOrder,
         marketId,
         side,
         price,
@@ -311,14 +326,16 @@ export class CompositeClient {
         reduceOnly,
       );
       msg
-        .then((it) => resolve([it]))
+        .then((it) => {
+          resolve([it]);
+        })
         .catch((err) => {
           console.log(err);
           reject(err);
         });
     });
     const account: Promise<Account> = this.validatorClient.post.account(
-      subaccount.address,
+      accountForOrder.address,
       undefined,
     );
     return this.send(
@@ -329,6 +346,7 @@ export class CompositeClient {
       memo,
       undefined,
       () => account,
+      permissionedKeysAccountAuth?.authenticators,
     );
   }
 
@@ -1217,4 +1235,23 @@ export class CompositeClient {
   ): Promise<BroadcastTxAsyncResponse | BroadcastTxSyncResponse | IndexedTx> {
     return this.validatorClient.post.createMarketPermissionless(ticker, subaccount, broadcastMode, gasAdjustment, memo);
   }
+
+  async addAuthenticator(
+    subaccount: SubaccountInfo,
+    authenticatorType: AuthenticatorType,
+    data: Uint8Array,
+  ): Promise<BroadcastTxAsyncResponse | BroadcastTxSyncResponse | IndexedTx> {
+    return this.validatorClient.post.addAuthenticator(subaccount, authenticatorType, data)
+  }
+
+  async removeAuthenticator(
+    subaccount: SubaccountInfo,
+    id: Long,
+  ): Promise<BroadcastTxAsyncResponse | BroadcastTxSyncResponse | IndexedTx> {
+    return this.validatorClient.post.removeAuthenticator(subaccount, id)
+  }
+
+  async getAuthenticators(address: string): Promise<GetAuthenticatorsResponse>{
+    return this.validatorClient.get.getAuthenticators(address);
+  }
 }

package/src/clients/constants.ts

@@ -116,6 +116,10 @@ export const TYPE_URL_MSG_UNDELEGATE = '/cosmos.staking.v1beta1.MsgUndelegate';
 export const TYPE_URL_MSG_WITHDRAW_DELEGATOR_REWARD =
   '/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward';
 
+// x/accountplus
+export const TYPE_URL_MSG_ADD_AUTHENTICATOR = '/dydxprotocol.accountplus.MsgAddAuthenticator'
+export const TYPE_URL_MSG_REMOVE_AUTHENTICATOR = '/dydxprotocol.accountplus.MsgRemoveAuthenticator'
+
 // ------------ Chain Constants ------------
 // The following are same across different networks / deployments.
 export const GOV_MODULE_ADDRESS = 'dydx10d07y265gmmuvt4z0w9aw880jnsr700jnmapky';
@@ -196,6 +200,17 @@ export enum PnlTickInterval {
   day = 'day',
 }
 
+// ----------- Authenticators -------------
+
+export enum AuthenticatorType {
+  ALL_OF = 'AllOf',
+  ANY_OF = 'AnyOf',
+  SIGNATURE_VERIFICATION = 'SignatureVerification',
+  MESSAGE_FILTER = 'MessageFilter',
+  CLOB_PAIR_ID_FILTER = 'ClobPairIdFilter',
+  SUBACCOUNT_FILTER = 'SubaccountFilter',
+}
+
 export enum TradingRewardAggregationPeriod {
   DAILY = 'DAILY',
   WEEKLY = 'WEEKLY',
@@ -285,7 +300,7 @@ export class Network {
     const indexerConfig = new IndexerConfig(IndexerApiHost.STAGING, IndexerWSHost.STAGING);
     const validatorConfig = new ValidatorConfig(
       ValidatorApiHost.STAGING,
-      TESTNET_CHAIN_ID,
+      STAGING_CHAIN_ID,
       {
         CHAINTOKEN_DENOM: 'adv4tnt',
         USDC_DENOM: 'ibc/8E27BA2D5493AF5636760E354E46004562C46AB7EC0CC4C1CA14E9E20E2545B5',

package/src/clients/lib/registry.ts

@@ -1,5 +1,6 @@
 import { GeneratedType, Registry } from '@cosmjs/proto-signing';
 import { defaultRegistryTypes } from '@cosmjs/stargate';
+import { MsgAddAuthenticator, MsgRemoveAuthenticator } from '@dydxprotocol/v4-proto/src/codegen/dydxprotocol/accountplus/tx';
 import { MsgRegisterAffiliate } from '@dydxprotocol/v4-proto/src/codegen/dydxprotocol/affiliates/tx';
 import {
   MsgPlaceOrder,
@@ -38,6 +39,8 @@ import {
   TYPE_URL_MSG_WITHDRAW_FROM_MEGAVAULT,
   TYPE_URL_MSG_REGISTER_AFFILIATE,
   TYPE_URL_MSG_CREATE_MARKET_PERMISSIONLESS,
+  TYPE_URL_MSG_ADD_AUTHENTICATOR,
+  TYPE_URL_MSG_REMOVE_AUTHENTICATOR,
 } from '../constants';
 
 export const registry: ReadonlyArray<[string, GeneratedType]> = [];
@@ -74,6 +77,11 @@ export function generateRegistry(): Registry {
     // affiliates
     [TYPE_URL_MSG_REGISTER_AFFILIATE, MsgRegisterAffiliate as GeneratedType],
 
+
+    // authentication
+    [TYPE_URL_MSG_ADD_AUTHENTICATOR, MsgAddAuthenticator as GeneratedType],
+    [TYPE_URL_MSG_REMOVE_AUTHENTICATOR, MsgRemoveAuthenticator as GeneratedType],
+
     // default types
     ...defaultRegistryTypes,
   ]);

package/src/clients/modules/composer.ts

@@ -7,6 +7,7 @@ import {
   MsgDelegate,
   MsgUndelegate,
 } from '@dydxprotocol/v4-proto/src/codegen/cosmos/staking/v1beta1/tx';
+import { MsgAddAuthenticator, MsgRemoveAuthenticator } from '@dydxprotocol/v4-proto/src/codegen/dydxprotocol/accountplus/tx';
 import { MsgRegisterAffiliate } from '@dydxprotocol/v4-proto/src/codegen/dydxprotocol/affiliates/tx';
 import { ClobPair_Status } from '@dydxprotocol/v4-proto/src/codegen/dydxprotocol/clob/clob_pair';
 import {
@@ -52,6 +53,9 @@ import {
   TYPE_URL_MSG_DEPOSIT_TO_MEGAVAULT,
   TYPE_URL_MSG_WITHDRAW_FROM_MEGAVAULT,
   TYPE_URL_MSG_CREATE_MARKET_PERMISSIONLESS,
+  TYPE_URL_MSG_ADD_AUTHENTICATOR,
+  TYPE_URL_MSG_REMOVE_AUTHENTICATOR,
+  AuthenticatorType,
 } from '../constants';
 import { DenomConfig } from '../types';
 import {
@@ -105,6 +109,7 @@ export class Composer {
       orderFlags,
       clobPairId,
     };
+
     const order: Order = {
       orderId,
       side,
@@ -575,6 +580,40 @@ export class Composer {
     }
   }
 
+  // ----------- x/accountplus --------
+
+  public composeMsgAddAuthenticator(
+    address: string,
+    authenticatorType: AuthenticatorType,
+    data: Uint8Array,
+  ): EncodeObject {
+    const msg: MsgAddAuthenticator = {
+      sender: address,
+      authenticatorType,
+      data,
+    }
+
+    return {
+      typeUrl: TYPE_URL_MSG_ADD_AUTHENTICATOR,
+      value: msg,
+    }
+  }
+
+  public composeMsgRemoveAuthenticator(
+    address: string,
+    id: Long,
+  ): EncodeObject {
+    const msg: MsgRemoveAuthenticator = {
+      sender: address,
+      id,
+    }
+
+    return {
+      typeUrl: TYPE_URL_MSG_REMOVE_AUTHENTICATOR,
+      value: msg,
+    }
+  }
+
   // ------------ util ------------
   public validateGoodTilBlockAndTime(
     orderFlags: number,

package/src/clients/modules/get.ts

@@ -7,6 +7,7 @@ import {
   TxExtension,
   QueryAbciResponse,
 } from '@cosmjs/stargate';
+import { GetAuthenticatorsRequest, GetAuthenticatorsResponse } from '@dydxprotocol/v4-proto/src/codegen/dydxprotocol/accountplus/query';
 import * as AuthModule from 'cosmjs-types/cosmos/auth/v1beta1/query';
 import * as BankModule from 'cosmjs-types/cosmos/bank/v1beta1/query';
 import { Any } from 'cosmjs-types/google/protobuf/any';
@@ -610,6 +611,21 @@ export class Get {
     return AffiliateModule.AffiliateWhitelistResponse.decode(data);
   }
 
+  async getAuthenticators(address: string): Promise<GetAuthenticatorsResponse> {
+    const requestData = Uint8Array.from(
+      GetAuthenticatorsRequest.encode({
+        account: address,
+      }).finish(),
+    );
+
+    const data = await this.sendQuery(
+      '/dydxprotocol.accountplus.Query/GetAuthenticators',
+      requestData,
+    );
+
+    return GetAuthenticatorsResponse.decode(data);
+  }
+
   private async sendQuery(requestUrl: string, requestData: Uint8Array): Promise<Uint8Array> {
     // eslint-disable-next-line max-len
     const resp: QueryAbciResponse = await this.stargateQueryClient.queryAbci(