@dydxprotocol/v4-client-js 1.15.0 → 1.16.0

package/src/clients/modules/signer.ts

@@ -1,10 +1,15 @@
-import { EncodeObject } from '@cosmjs/proto-signing';
+import { Secp256k1Pubkey } from '@cosmjs/amino';
+import { fromBase64 } from '@cosmjs/encoding';
+import { Int53 } from '@cosmjs/math';
+import { EncodeObject, encodePubkey, makeAuthInfoBytes, makeSignDoc, OfflineDirectSigner } from '@cosmjs/proto-signing';
 import { SigningStargateClient, StdFee } from '@cosmjs/stargate';
-import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+import { TxExtension } from '@dydxprotocol/v4-proto/src/codegen/dydxprotocol/accountplus/tx';
+import { TxBody, TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+import { Any } from 'cosmjs-types/google/protobuf/any';
 import Long from 'long';
 import protobuf from 'protobufjs';
 
-import { UserError } from '../lib/errors';
+import { generateRegistry } from '../lib/registry';
 import { TransactionOptions } from '../types';
 
 // Required for encoding and decoding queries that are of type Long.
@@ -17,10 +22,16 @@ protobuf.configure();
 export class TransactionSigner {
   readonly address: string;
   readonly stargateSigningClient: SigningStargateClient;
+  readonly offlineSigner: OfflineDirectSigner;
 
-  constructor(address: string, stargateSigningClient: SigningStargateClient) {
+  constructor(
+    address: string,
+    stargateSigningClient: SigningStargateClient,
+    offlineSigner: OfflineDirectSigner,
+  ) {
     this.address = address;
     this.stargateSigningClient = stargateSigningClient;
+    this.offlineSigner = offlineSigner;
   }
 
   /**
@@ -35,18 +46,73 @@ export class TransactionSigner {
     transactionOptions: TransactionOptions,
     fee?: StdFee,
     memo: string = '',
+    publicKey?: Secp256k1Pubkey,
   ): Promise<Uint8Array> {
-    // Verify there is either a fee or a path to getting the fee present.
-    if (fee === undefined) {
-      throw new UserError('fee cannot be undefined');
+    if (!fee) {
+      throw new Error('Fee cannot be undefined');
     }
 
-    // Sign, encode and return the transaction.
-    const rawTx: TxRaw = await this.stargateSigningClient.sign(this.address, messages, fee, memo, {
-      accountNumber: transactionOptions.accountNumber,
-      sequence: transactionOptions.sequence,
-      chainId: transactionOptions.chainId,
+    const registry = generateRegistry();
+
+    // Encode the messages
+    const encodedMessages = messages.map((msg) => registry.encodeAsAny(msg));
+
+    // Encode the TxExtension message
+    const txExtension = TxExtension.encode({
+      selectedAuthenticators: transactionOptions.authenticators ?? [],
+    }).finish();
+
+    // Create the non-critical extension message
+    const nonCriticalExtensionOptions: Any[] = [
+      Any.fromPartial({
+        typeUrl: '/dydxprotocol.accountplus.TxExtension',
+        value: txExtension,
+      }),
+    ];
+
+    // Construct the TxBody
+    const txBody: TxBody = TxBody.fromPartial({
+      messages: encodedMessages,
+      memo,
+      extensionOptions: [],
+      nonCriticalExtensionOptions,
     });
-    return Uint8Array.from(TxRaw.encode(rawTx).finish());
+
+    // Encode the TxBody
+    const txBodyBytes = TxBody.encode(txBody).finish();
+
+    if (!publicKey) {
+      throw new Error('Public key cannot be undefined');
+    }
+    const pubkey = encodePubkey(publicKey); // Use the public key of the signer
+
+    const gasLimit = Int53.fromString(String(fee.gas)).toNumber();
+    const authInfoBytes = makeAuthInfoBytes(
+      [{ pubkey, sequence: transactionOptions.sequence }],
+      fee.amount,
+      gasLimit,
+      undefined,
+      undefined,
+    );
+
+    // Create the SignDoc
+    const signDoc = makeSignDoc(
+      txBodyBytes,
+      authInfoBytes,
+      transactionOptions.chainId,
+      transactionOptions.accountNumber,
+    );
+
+    // Use OfflineSigner to sign the transaction
+    const signerAddress = this.address;
+    const { signed, signature } = await this.offlineSigner.signDirect(signerAddress, signDoc);
+
+    const txRaw = TxRaw.fromPartial({
+      bodyBytes: signed.bodyBytes,
+      authInfoBytes: signed.authInfoBytes,
+      signatures: [fromBase64(signature.signature)],
+    });
+
+    return Uint8Array.from(TxRaw.encode(txRaw).finish());
   }
 }

package/src/clients/types.ts

@@ -29,6 +29,7 @@ export interface PartialTransactionOptions {
 // Information for signing a transaction while offline.
 export interface TransactionOptions extends PartialTransactionOptions {
   sequence: number;
+  authenticators?: Long[];
 }
 
 // OrderFlags, just a number in proto, defined as enum for convenience