Attempt MultiSign

BitteProtocol · bh2smith · Nov 6, 2024 · Nov 6, 2024 · Nov 6, 2024 · Jan 15, 2025
commit 550d5db97806dedd7c3fe7ee3a6b141ff02489ee
diff --git a/examples/send-eth.ts b/examples/send-eth.ts
@@ -1,16 +1,16 @@
 import dotenv from "dotenv";
-import { SEPOLIA_CHAIN_ID, setupNearEthAdapter } from "./setup";
+import { setupNearEthAdapter } from "./setup";
 dotenv.config();
 
 const run = async (): Promise<void> => {
   const evm = await setupNearEthAdapter();
-  await evm.signAndSendTransaction({
-    // Sending to self.
-    to: evm.address,
-    // THIS IS ONE WEI!
-    value: 1n,
-    chainId: SEPOLIA_CHAIN_ID,
-  });
+  console.log(evm.address);
+  // throw new Error("You foked up");
+  const transactions = [
+    { to: evm.address, value: 1n, chainId: 97 },
+    { to: evm.address, value: 1n, chainId: 1301 },
+  ];
+  await evm.signAndSendTransaction(transactions);
 };
 
 run();
diff --git a/src/chains/ethereum.ts b/src/chains/ethereum.ts
@@ -32,6 +32,7 @@ export class NearEthAdapter {
   readonly mpcContract: IMpcContract;
   readonly address: Address;
   readonly derivationPath: string;
+  readonly keyVersion: number;
   readonly beta: Beta;
 
   private constructor(config: {
@@ -41,6 +42,7 @@ export class NearEthAdapter {
   }) {
     this.mpcContract = config.mpcContract;
     this.derivationPath = config.derivationPath;
+    this.keyVersion = 0;
     this.address = config.sender;
     this.beta = new Beta(this);
   }
@@ -103,16 +105,29 @@ export class NearEthAdapter {
    * Note that the signature request is a recursive function.
    */
   async signAndSendTransaction(
-    txData: BaseTx,
+    txData: BaseTx[],
     nearGas?: bigint
-  ): Promise<Hash> {
-    const { transaction, signArgs } = await this.createTxPayload(txData);
+  ): Promise<Hash[]> {
+    // Note that chainIds must be all different or
+    // we have to make special consideration for the nonces.
+    const txArray = await Promise.all(
+      txData.map((tx) => this.createTxPayload(tx))
+    );
+
     console.log(`Requesting signature from ${this.mpcContract.accountId()}`);
-    const signature = await this.mpcContract.requestSignature(
-      signArgs,
+    const signatures = await this.mpcContract.requestMulti(
+      txArray.map((tx) => tx.signArgs),
       nearGas
     );
-    return broadcastSignedTransaction({ transaction, signature });
+    const transactions = txArray.map((tx) => tx.transaction);
+    return Promise.all(
+      transactions.map((transaction, i) =>
+        broadcastSignedTransaction({
+          transaction,
+          signature: signatures[i]!,
+        })
+      )
+    );
   }
 
   /**

diff --git a/src/mpcContract.ts b/src/mpcContract.ts
@@ -113,6 +113,34 @@ export class MpcContract implements IMpcContract {
     return transformSignature(mpcSig);
   };
 
+  requestMulti = async (
+    signArgs: SignArgs[],
+    gas?: bigint
+  ): Promise<Signature[]> => {
+    const transaction = await this.encodeMulti(signArgs, gas);
+
+    const result = await this.connectedAccount.signAndSendTransaction({
+      receiverId: transaction.receiverId,
+      actions: transaction.actions.map((action) => {
+        return {
+          enum: action.type,
+          functionCall: {
+            methodName: action.params.methodName,
+            args: Buffer.from(JSON.stringify(action.params.args)),
+            gas: BigInt(action.params.gas),
+            deposit: BigInt(action.params.deposit),
+          },
+        };
+      }),
+    });
+
+    // Extract signatures from each receipt outcome in order
+    const mpcSigs = result.receipts_outcome.map(
+      (receipt) => receipt.outcome.status as MPCSignature
+    );
+    return mpcSigs.map(transformSignature);
+  };
+
   async encodeSignatureRequestTx(
     signArgs: SignArgs,
     gas?: bigint
@@ -133,6 +161,30 @@ export class MpcContract implements IMpcContract {
       ],
     };
   }
+
+  async encodeMulti(
+    signArgs: SignArgs[],
+    gas?: bigint
+  ): Promise<FunctionCallTransaction<{ request: SignArgs }>> {
+    const deposit = await this.getDeposit();
+    return {
+      signerId: this.connectedAccount.accountId,
+      receiverId: this.contract.contractId,
+      actions: signArgs.map((args) => {
+        return {
+          type: "FunctionCall",
+          params: {
+            methodName: "sign",
+            args: {
+              request: args,
+            },
+            gas: gasOrDefault(gas),
+            deposit,
+          },
+        };
+      }),
+    };
+  }
 }
 
 function gasOrDefault(gas?: bigint): string {
@@ -149,8 +201,13 @@ export interface IMpcContract {
   deriveEthAddress(derivationPath: string): Promise<Address>;
   getDeposit(): Promise<string>;
   requestSignature(signArgs: SignArgs, gas?: bigint): Promise<Signature>;
+  requestMulti(signArgs: SignArgs[], gas?: bigint): Promise<Signature[]>;
   encodeSignatureRequestTx(
     signArgs: SignArgs,
     gas?: bigint
   ): Promise<FunctionCallTransaction<{ request: SignArgs }>>;
+  encodeMulti(
+    signArgs: SignArgs[],
+    gas?: bigint
+  ): Promise<FunctionCallTransaction<{ request: SignArgs }>>;
 }
diff --git a/src/utils/mock-sign.ts b/src/utils/mock-sign.ts
@@ -48,6 +48,15 @@ export class MockMpcContract implements IMpcContract {
         "0x4f3edf983ac636a65a842ce7c78d9aa706d3b113bce9c46f30d7d21715b23b1d"
     );
   }
+  requestMulti(_signArgs: SignArgs[], _gas?: bigint): Promise<Signature[]> {
+    throw new Error("Method not implemented.");
+  }
+  encodeMulti(
+    _signArgs: SignArgs[],
+    _gas?: bigint
+  ): Promise<FunctionCallTransaction<{ request: SignArgs }>> {
+    throw new Error("Method not implemented.");
+  }
 
   accountId(): string {
     return "mock-mpc.offline";