@exodus/solana-lib 2.3.0 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-lib",
-  "version": "2.3.0",
+  "version": "3.0.0",
   "description": "Exodus internal Solana low-level library",
   "main": "src/index.js",
   "files": [
@@ -23,7 +23,8 @@
     "@exodus/currency": "^2.3.2",
     "@exodus/key-utils": "^3.1.0",
     "@exodus/models": "^10.1.0",
-    "@project-serum/serum": "0.13.64",
+    "@exodus/project-serum-serum": "0.13.64-exodus.0",
+    "@exodus/solana-web3.js": "^1.63.1-exodus.3",
     "bn.js": "^4.11.0",
     "borsh": "^0.7.0",
     "bs58": "^4.0.1",
@@ -39,5 +40,5 @@
     "@solana/web3.js": "^1.90.0",
     "bip39": "^2.6.0"
   },
-  "gitHead": "5be11b271fd14c54f4fe8dd04b146361100e2a4d"
+  "gitHead": "30fdc2a936b6776866467baf926c899e9a236beb"
 }

package/src/index.js

@@ -2,6 +2,7 @@ export * from './constants'
 export * from './encode'
 export * from './keypair'
 export * from './tx'
+export * from './msg'
 export * from './fee-data'
 export {
   TransactionInstruction,

package/src/msg/index.js

@@ -0,0 +1,2 @@
+export { signMessage } from './sign-message-deprecated'
+export { signMessageNew } from './sign-message'

package/src/msg/sign-message-deprecated.js

@@ -0,0 +1,20 @@
+import assert from 'assert'
+import nacl from 'tweetnacl'
+import bs58 from 'bs58'
+
+import { isTransactionMessage } from './validation'
+import { getKeyPairFromPrivateKey } from '../keypair'
+
+/**
+ * @deprecated please use messageSigner
+ */
+export function signMessage({ message, privateKey }) {
+  const { secretKey } = getKeyPairFromPrivateKey(privateKey)
+  const messageBuffer = bs58.decode(message)
+  assert(
+    !isTransactionMessage(messageBuffer),
+    'attempted to sign transaction using message signing'
+  )
+  const signature = nacl.sign.detached(messageBuffer, secretKey)
+  return bs58.encode(signature)
+}

package/src/msg/sign-message.js

@@ -0,0 +1,19 @@
+import assert from 'minimalistic-assert'
+import * as nacl from 'tweetnacl'
+
+import { isTransactionMessage } from './validation'
+
+export const signMessageNew = async ({ privateKey, message }) => {
+  const { rawMessage } = message
+  assert(Buffer.isBuffer(rawMessage), `rawMessage must be buffer`)
+  assert(
+    !isTransactionMessage(rawMessage),
+    `malicious message signing request, was a transaction message`
+  )
+  assert(
+    Buffer.isBuffer(privateKey) || privateKey instanceof Uint8Array,
+    `privateKey is not a Buffer or Uint8Array`
+  )
+
+  return Buffer.from(nacl.sign.detached(rawMessage, privateKey))
+}

package/src/{tx/sign-message.js → msg/validation.js}

@@ -1,10 +1,10 @@
-import assert from 'assert'
-import nacl from 'tweetnacl'
-import bs58 from 'bs58'
-
-import { Message } from '../vendor/message'
-import { getKeyPairFromPrivateKey } from '../keypair'
+import { Message } from '@exodus/solana-web3.js'
 
+/**
+ * Checks if its contains a legacy message.
+ * @param {Uint8Array} data
+ * @returns {boolean}
+ */
 function isLegacyMessage(data) {
   try {
     const message = Message.from(data)
@@ -15,6 +15,11 @@ function isLegacyMessage(data) {
   }
 }
 
+/**
+ * Checks if its contains a versioned message.
+ * @param {Uint8Array} data
+ * @returns {boolean}
+ */
 function isVersionedMessage(data) {
   if (data.length > 1) {
     // We deploy a heuristic to detect transaction messages.
@@ -27,18 +32,12 @@ function isVersionedMessage(data) {
   return false
 }
 
+/**
+ * Check whether a message contains a transaction message.
+ * @param {Uint8Array} data
+ * @returns {boolean}
+ */
 export function isTransactionMessage(data) {
   const messageBuffer = Buffer.from(data)
   return isLegacyMessage(messageBuffer) || isVersionedMessage(messageBuffer)
 }
-
-export default function signMessage({ message, privateKey }) {
-  const { secretKey } = getKeyPairFromPrivateKey(privateKey)
-  const messageBuffer = bs58.decode(message)
-  assert(
-    !isTransactionMessage(messageBuffer),
-    'attempted to sign transaction using message signing'
-  )
-  const signature = nacl.sign.detached(messageBuffer, secretKey)
-  return bs58.encode(signature)
-}

package/src/tx/create-and-sign-tx.js

@@ -1,7 +1,7 @@
 import { createUnsignedTx } from './create-unsigned-tx'
 import { signUnsignedTx } from './sign-unsigned-tx'
 
-export function createAndSignTx(input, privateKey) {
+export async function createAndSignTx(input, privateKey) {
   const unsignedTx = createUnsignedTx(input)
   return signUnsignedTx(unsignedTx, privateKey)
 }

package/src/tx/decode-tx-instructions.js

@@ -1,5 +1,5 @@
 import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '../helpers/spl-token'
-import { MARKETS, TokenInstructions } from '@project-serum/serum'
+import { MARKETS, TokenInstructions } from '@exodus/project-serum-serum'
 import * as BufferLayout from '@exodus/buffer-layout'
 
 import { SystemInstruction, SystemProgram } from './../vendor'

package/src/tx/index.js

@@ -8,4 +8,3 @@ export * from './build-raw-transaction'
 export * from './sign-hardware'
 export * from './prepare-for-signing'
 export { transactionToBase58 } from './common'
-export { default as signMessage } from './sign-message'

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

@@ -1,9 +1,10 @@
 import assert from 'minimalistic-assert'
+import * as nacl from 'tweetnacl'
+import bs58 from 'bs58'
 
 import { prepareForSigning } from './prepare-for-signing'
 import { getKeyPairFromPrivateKey } from '../keypair'
-import { Account } from '../vendor'
-import { AsyncSignerAccount } from './async-account'
+import { PublicKey } from '../vendor'
 import { extractTransaction, isVersionedTransaction } from './common'
 
 /**
@@ -17,49 +18,60 @@ export async function signUnsignedTxWithSigner(unsignedTx, signer) {
 
   const tx = prepareForSigning(unsignedTx)
 
-  const account = new AsyncSignerAccount(signer)
-  await account.updatePublicKey()
-  await _signTx({ tx, account })
+  await _signTx({ tx, signer })
 
   return extractTransaction({ tx })
 }
 
-export function signUnsignedTx(unsignedTx, privateKey) {
+export async function signUnsignedTx(unsignedTx, privateKey) {
   assert(privateKey, 'Please provide a secretKey')
 
   const tx = prepareForSigning(unsignedTx)
 
-  const { secretKey } = getKeyPairFromPrivateKey(privateKey)
-  const account = new Account(secretKey)
-  _signTx({ tx, account })
+  const { secretKey, publicKey } = getKeyPairFromPrivateKey(privateKey)
+  const signer = {
+    getPublicKey: () => publicKey,
+    sign: ({ data }) => nacl.sign.detached(data, secretKey),
+  }
+  await _signTx({ tx, signer })
 
   return extractTransaction({ tx })
 }
 
 // Signs plain tx.
-const _signTx = ({ tx, account }) => {
+const _signTx = async ({ tx, signer }) => {
+  const publicKey = new PublicKey(bs58.encode(Buffer.from(await signer.getPublicKey())))
+
   if (isVersionedTransaction(tx)) {
     // VersionedTransaction
-    return tx.sign([account])
+    return _signVersionedTransaction({ tx, signer, publicKey })
   }
-
   // 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)
+  const foundEmptySignatureSlot = tx.signatures.find(({ publicKey: _publicKey }) =>
+    _publicKey.equals(publicKey)
   )
   if (!foundEmptySignatureSlot) {
     // We could use `setSigners` but maybe this is more robust?
     tx.signatures.push({
-      publicKey: account.publicKey,
+      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)
+  return _signLegacyTransaction({ tx, signer, publicKey })
+}
+
+const _signVersionedTransaction = async ({ tx, signer, publicKey }) => {
+  const messageData = tx.message.serialize()
+  const signature = await signer.sign({ data: messageData })
+  tx.addSignature(publicKey, signature)
+}
+
+const _signLegacyTransaction = async ({ tx, signer, publicKey }) => {
+  const messageData = tx.compileMessage().serialize()
+  const signature = await signer.sign({ data: messageData })
+  tx.addSignature(publicKey, signature)
 }

package/src/vendor/transaction.js

@@ -21,8 +21,6 @@ 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
  *
@@ -436,21 +434,6 @@ 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)

package/src/tx/async-account.js

@@ -1,38 +0,0 @@
-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)
-    }
-  }
-}