@exodus/solana-lib 2.1.0 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -33,8 +33,11 @@
     "tweetnacl": "^1.0.3"
   },
   "devDependencies": {
-    "@exodus/solana-meta": "^1.0.7",
-    "@solana/web3.js": "^1.90.0"
+    "@exodus/key-identifier": "1.0.0",
+    "@exodus/keychain": "^6.2.0",
+    "@exodus/solana-meta": "^1.1.0",
+    "@solana/web3.js": "^1.90.0",
+    "bip39": "^2.6.0"
   },
-  "gitHead": "84f77ed9720dcdabb8057ed9170f45fcb4f9eff9"
+  "gitHead": "85fd61e1f2f77aff4c32b5684eb5f4845f06794a"
 }

package/src/tx/async-account.js

@@ -0,0 +1,38 @@
+import { PublicKey } from '../vendor/publickey'
+
+export class AsyncSignerAccount {
+  #publicKey
+  #asyncSigner
+
+  /**
+   * Create a new AsyncSignerAccount object
+   *
+   * @param asyncSigner A signer object: `{ sign, getPublicKey }`
+   */
+  constructor(asyncSigner) {
+    if (!asyncSigner) throw new Error('please provide a signer object to async signer')
+
+    this.#asyncSigner = asyncSigner
+    this.updatePublicKey().catch((err) =>
+      console.error('error getting public key from signer', err)
+    )
+  }
+
+  get publicKey() {
+    if (!this.#publicKey) throw new Error('public key not yet available in async signer')
+    return this.#publicKey
+  }
+
+  get secretKey() {
+    throw new Error('secret key not available from async signer')
+  }
+
+  sign = async (signData) => this.#asyncSigner.sign({ data: signData })
+
+  updatePublicKey = async () => {
+    if (!this.#publicKey) {
+      const publicKey = await this.#asyncSigner.getPublicKey()
+      this.#publicKey = new PublicKey(publicKey)
+    }
+  }
+}

package/src/tx/sign-unsigned-tx.js

@@ -3,44 +3,63 @@ import assert from 'minimalistic-assert'
 import { prepareForSigning } from './prepare-for-signing'
 import { getKeyPairFromPrivateKey } from '../keypair'
 import { Account } from '../vendor'
+import { AsyncSignerAccount } from './async-account'
 import { extractTransaction, isVersionedTransaction } from './common'
 
+/**
+ *
+ * @param {*} unsignedTx
+ * @param {Object} asyncSigner object: `{ sign: async (buffer) => Promise<>, getPublicKey: async () => Promise<any>}`
+ * @returns
+ */
+export async function signUnsignedTxWithSigner(unsignedTx, signer) {
+  assert(signer, 'Please provide a signer')
+
+  const tx = prepareForSigning(unsignedTx)
+
+  const account = new AsyncSignerAccount(signer)
+  await account.updatePublicKey()
+  await _signTx({ tx, account })
+
+  return extractTransaction({ tx })
+}
+
 export function signUnsignedTx(unsignedTx, privateKey) {
   assert(privateKey, 'Please provide a secretKey')
 
   const tx = prepareForSigning(unsignedTx)
 
-  _signTx({ tx, privateKey })
+  const { secretKey } = getKeyPairFromPrivateKey(privateKey)
+  const account = new Account(secretKey)
+  _signTx({ tx, account })
 
   return extractTransaction({ tx })
 }
 
 // Signs plain tx.
-const _signTx = ({ tx, privateKey }) => {
-  const { secretKey } = getKeyPairFromPrivateKey(privateKey)
-  const account = new Account(secretKey)
+const _signTx = ({ tx, account }) => {
   if (isVersionedTransaction(tx)) {
     // VersionedTransaction
-    tx.sign([account])
-  } else {
-    // Legacy Transactions
-
-    // Some transactions that we construct internally are technically not complete.
-    // They don't contain the empty signature slot for the public key.
-    const foundEmptySignatureSlot = tx.signatures.find(({ publicKey }) =>
-      publicKey.equals(account.publicKey)
-    )
-    if (!foundEmptySignatureSlot) {
-      // We could use `setSigners` but maybe this is more robust?
-      tx.signatures.push({
-        publicKey: account.publicKey,
-        signature: null,
-      })
-    }
-
-    // We need to use `partialSign()` here because legacy `sign()` will
-    // delete all existing signatures which isn't great if we're
-    // signing a transaction that already has signatures.
-    tx.partialSign(account)
+    return tx.sign([account])
   }
+
+  // Legacy Transactions
+
+  // Some transactions that we construct internally are technically not complete.
+  // They don't contain the empty signature slot for the public key.
+  const foundEmptySignatureSlot = tx.signatures.find(({ publicKey }) =>
+    publicKey.equals(account.publicKey)
+  )
+  if (!foundEmptySignatureSlot) {
+    // We could use `setSigners` but maybe this is more robust?
+    tx.signatures.push({
+      publicKey: account.publicKey,
+      signature: null,
+    })
+  }
+
+  // We need to use `partialSign()` here because legacy `sign()` will
+  // delete all existing signatures which isn't great if we're
+  // signing a transaction that already has signatures.
+  return tx.partialSign(account)
 }

package/src/vendor/transaction.js

@@ -21,6 +21,8 @@ import * as shortvec from './utils/shortvec-encoding'
 const DEFAULT_SIGNATURE = Buffer.alloc(64).fill(0)
 const SIGNATURE_LENGTH = 64
 
+const isAsyncAccount = (signer) => signer.sign && signer.publicKey && signer.updatePublicKey
+
 /**
  * Account metadata used to define instructions
  *
@@ -412,7 +414,7 @@ export class Transaction {
         publicKey: signer.publicKey,
       }))
 
-    this.partialSign(...signers)
+    return this.partialSign(...signers)
   }
 
   /**
@@ -434,6 +436,21 @@ export class Transaction {
     })
 
     const signData = message.serialize()
+
+    const isAsyncSign = signers.some(isAsyncAccount)
+    if (isAsyncSign) {
+      return Promise.all(
+        signers.map(async (signer) => ({
+          signature: isAsyncAccount(signer)
+            ? await signer.sign(signData) // Promise
+            : nacl.sign.detached(signData, signer.secretKey),
+          publicKey: signer.publicKey,
+        }))
+      ).then((signatures) =>
+        signatures.forEach(({ publicKey, signature }) => this.addSignature(publicKey, signature))
+      )
+    }
+
     signers.forEach((signer) => {
       const signature = nacl.sign.detached(signData, signer.secretKey)
       this.addSignature(signer.publicKey, signature)