@solana/transactions 2.0.0-experimental.e1ca396 → 2.0.0-experimental.e374ac6

package/README.md

@@ -30,7 +30,7 @@ const transferTransaction = pipe(
     createTransaction({ version: 0 }),
     tx => setTransactionFeePayer(myAddress, tx),
     tx => setTransactionLifetimeUsingBlockhash(latestBlockhash, tx),
-    tx => appendTransactionInstruction(createTransferInstruction(myAddress, toAddress, amountInLamports), tx)
+    tx => appendTransactionInstruction(createTransferInstruction(myAddress, toAddress, amountInLamports), tx),
 );
 ```
 
@@ -144,7 +144,7 @@ const nonce =
 
 const durableNonceTransaction = setTransactionLifetimeUsingDurableNonce(
     { nonce, nonceAccountAddress, nonceAuthorityAddress },
-    tx
+    tx,
 );
 ```
 
@@ -210,14 +210,18 @@ const memoTransaction = appendTransactionInstruction(
         data: new TextEncoder().encode('Hello world!'),
         programAddress: address('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
     },
-    tx
+    tx,
 );
 ```
 
+If you'd like to add multiple instructions to a transaction at once, you may use the `appendTransactionInstructions` function instead which accepts an array of instructions.
+
 #### `prependTransactionInstruction()`
 
 Given an instruction, this method will return a new transaction with that instruction having been added to the beginning of the list of existing instructions.
 
+If you'd like to prepend multiple instructions to a transaction at once, you may use the `prependTransactionInstructions` function instead which accepts an array of instructions.
+
 See [`appendTransactionInstruction()`](#appendtransactioninstruction) for an example of how to use this function.
 
 ## Signing transactions

package/dist/index.browser.cjs

@@ -1,14 +1,36 @@
 'use strict';
 
+var errors = require('@solana/errors');
 var codecsStrings = require('@solana/codecs-strings');
 var addresses = require('@solana/addresses');
+var functional = require('@solana/functional');
 var codecsCore = require('@solana/codecs-core');
 var codecsDataStructures = require('@solana/codecs-data-structures');
 var codecsNumbers = require('@solana/codecs-numbers');
-var functional = require('@solana/functional');
 var keys = require('@solana/keys');
 
 // src/blockhash.ts
+var base58Encoder;
+function assertIsBlockhash(putativeBlockhash) {
+  if (!base58Encoder)
+    base58Encoder = codecsStrings.getBase58Encoder();
+  if (
+    // Lowest value (32 bytes of zeroes)
+    putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
+    putativeBlockhash.length > 44
+  ) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__BLOCKHASH_STRING_LENGTH_OUT_OF_RANGE, {
+      actualLength: putativeBlockhash.length
+    });
+  }
+  const bytes = base58Encoder.encode(putativeBlockhash);
+  const numBytes = bytes.byteLength;
+  if (numBytes !== 32) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__BLOCKHASH_BYTE_LENGTH_OUT_OF_RANGE, {
+      actualLength: numBytes
+    });
+  }
+}
 
 // src/unsigned-transaction.ts
 function getUnsignedTransaction(transaction) {
@@ -25,29 +47,6 @@ function getUnsignedTransaction(transaction) {
 }
 
 // src/blockhash.ts
-var base58Encoder;
-function assertIsBlockhash(putativeBlockhash) {
-  if (!base58Encoder)
-    base58Encoder = codecsStrings.getBase58Encoder();
-  try {
-    if (
-      // Lowest value (32 bytes of zeroes)
-      putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
-      putativeBlockhash.length > 44
-    ) {
-      throw new Error("Expected input string to decode to a byte array of length 32.");
-    }
-    const bytes = base58Encoder.encode(putativeBlockhash);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
-      cause: e
-    });
-  }
-}
 function isTransactionWithBlockhashLifetime(transaction) {
   const lifetimeConstraintShapeMatches = "lifetimeConstraint" in transaction && typeof transaction.lifetimeConstraint.blockhash === "string" && typeof transaction.lifetimeConstraint.lastValidBlockHeight === "bigint";
   if (!lifetimeConstraintShapeMatches)
@@ -61,7 +60,7 @@ function isTransactionWithBlockhashLifetime(transaction) {
 }
 function assertIsTransactionWithBlockhashLifetime(transaction) {
   if (!isTransactionWithBlockhashLifetime(transaction)) {
-    throw new Error("Transaction does not have a blockhash lifetime");
+    throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION_EXPECTED_BLOCKHASH_LIFETIME);
   }
 }
 function setTransactionLifetimeUsingBlockhash(blockhashLifetimeConstraint, transaction) {
@@ -87,8 +86,6 @@ function createTransaction({
   Object.freeze(out);
   return out;
 }
-
-// ../instructions/dist/index.browser.js
 var AccountRole = /* @__PURE__ */ ((AccountRole2) => {
   AccountRole2[AccountRole2["WRITABLE_SIGNER"] = /* 3 */
   3] = "WRITABLE_SIGNER";
@@ -110,13 +107,11 @@ function isWritableRole(role) {
 function mergeRoles(roleA, roleB) {
   return roleA | roleB;
 }
-
-// src/durable-nonce.ts
 var RECENT_BLOCKHASHES_SYSVAR_ADDRESS = "SysvarRecentB1ockHashes11111111111111111111";
 var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
 function assertIsDurableNonceTransaction(transaction) {
   if (!isDurableNonceTransaction(transaction)) {
-    throw new Error("Transaction is not a durable nonce transaction");
+    throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION_EXPECTED_NONCE_LIFETIME);
   }
 }
 function createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress) {
@@ -202,21 +197,181 @@ function setTransactionFeePayer(feePayer, transaction) {
 
 // src/instructions.ts
 function appendTransactionInstruction(instruction, transaction) {
+  return appendTransactionInstructions([instruction], transaction);
+}
+function appendTransactionInstructions(instructions, transaction) {
   const out = {
     ...getUnsignedTransaction(transaction),
-    instructions: [...transaction.instructions, instruction]
+    instructions: [...transaction.instructions, ...instructions]
   };
   Object.freeze(out);
   return out;
 }
 function prependTransactionInstruction(instruction, transaction) {
+  return prependTransactionInstructions([instruction], transaction);
+}
+function prependTransactionInstructions(instructions, transaction) {
   const out = {
     ...getUnsignedTransaction(transaction),
-    instructions: [instruction, ...transaction.instructions]
+    instructions: [...instructions, ...transaction.instructions]
   };
   Object.freeze(out);
   return out;
 }
+
+// src/decompile-transaction.ts
+function getAccountMetas(message) {
+  const { header } = message;
+  const numWritableSignerAccounts = header.numSignerAccounts - header.numReadonlySignerAccounts;
+  const numWritableNonSignerAccounts = message.staticAccounts.length - header.numSignerAccounts - header.numReadonlyNonSignerAccounts;
+  const accountMetas = [];
+  let accountIndex = 0;
+  for (let i = 0; i < numWritableSignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.WRITABLE_SIGNER
+    });
+    accountIndex++;
+  }
+  for (let i = 0; i < header.numReadonlySignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.READONLY_SIGNER
+    });
+    accountIndex++;
+  }
+  for (let i = 0; i < numWritableNonSignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.WRITABLE
+    });
+    accountIndex++;
+  }
+  for (let i = 0; i < header.numReadonlyNonSignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.READONLY
+    });
+    accountIndex++;
+  }
+  return accountMetas;
+}
+function getAddressLookupMetas(compiledAddressTableLookups, addressesByLookupTableAddress) {
+  const compiledAddressTableLookupAddresses = compiledAddressTableLookups.map((l) => l.lookupTableAddress);
+  const missing = compiledAddressTableLookupAddresses.filter((a) => addressesByLookupTableAddress[a] === void 0);
+  if (missing.length > 0) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_CONTENTS_MISSING, {
+      lookupTableAddresses: missing
+    });
+  }
+  const readOnlyMetas = [];
+  const writableMetas = [];
+  for (const lookup of compiledAddressTableLookups) {
+    const addresses = addressesByLookupTableAddress[lookup.lookupTableAddress];
+    const highestIndex = Math.max(...lookup.readableIndices, ...lookup.writableIndices);
+    if (highestIndex >= addresses.length) {
+      throw new errors.SolanaError(
+        errors.SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_INDEX_OUT_OF_RANGE,
+        {
+          highestKnownIndex: addresses.length - 1,
+          highestRequestedIndex: highestIndex,
+          lookupTableAddress: lookup.lookupTableAddress
+        }
+      );
+    }
+    const readOnlyForLookup = lookup.readableIndices.map((r) => ({
+      address: addresses[r],
+      addressIndex: r,
+      lookupTableAddress: lookup.lookupTableAddress,
+      role: AccountRole.READONLY
+    }));
+    readOnlyMetas.push(...readOnlyForLookup);
+    const writableForLookup = lookup.writableIndices.map((w) => ({
+      address: addresses[w],
+      addressIndex: w,
+      lookupTableAddress: lookup.lookupTableAddress,
+      role: AccountRole.WRITABLE
+    }));
+    writableMetas.push(...writableForLookup);
+  }
+  return [...writableMetas, ...readOnlyMetas];
+}
+function convertInstruction(instruction, accountMetas) {
+  const programAddress = accountMetas[instruction.programAddressIndex]?.address;
+  if (!programAddress) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND, {
+      index: instruction.programAddressIndex
+    });
+  }
+  const accounts = instruction.accountIndices?.map((accountIndex) => accountMetas[accountIndex]);
+  const { data } = instruction;
+  return {
+    programAddress,
+    ...accounts && accounts.length ? { accounts } : {},
+    ...data && data.length ? { data } : {}
+  };
+}
+function getLifetimeConstraint(messageLifetimeToken, firstInstruction, lastValidBlockHeight) {
+  if (!firstInstruction || !isAdvanceNonceAccountInstruction(firstInstruction)) {
+    return {
+      blockhash: messageLifetimeToken,
+      lastValidBlockHeight: lastValidBlockHeight ?? 2n ** 64n - 1n
+      // U64 MAX
+    };
+  } else {
+    const nonceAccountAddress = firstInstruction.accounts[0].address;
+    addresses.assertIsAddress(nonceAccountAddress);
+    const nonceAuthorityAddress = firstInstruction.accounts[2].address;
+    addresses.assertIsAddress(nonceAuthorityAddress);
+    return {
+      nonce: messageLifetimeToken,
+      nonceAccountAddress,
+      nonceAuthorityAddress
+    };
+  }
+}
+function convertSignatures(compiledTransaction) {
+  const {
+    compiledMessage: { staticAccounts },
+    signatures
+  } = compiledTransaction;
+  return signatures.reduce((acc, sig, index) => {
+    const allZeros = sig.every((byte) => byte === 0);
+    if (allZeros)
+      return acc;
+    const address = staticAccounts[index];
+    return { ...acc, [address]: sig };
+  }, {});
+}
+function decompileTransaction(compiledTransaction, config) {
+  const { compiledMessage } = compiledTransaction;
+  const feePayer = compiledMessage.staticAccounts[0];
+  if (!feePayer) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION_FAILED_TO_DECOMPILE_FEE_PAYER_MISSING);
+  }
+  const accountMetas = getAccountMetas(compiledMessage);
+  const accountLookupMetas = "addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups !== void 0 && compiledMessage.addressTableLookups.length > 0 ? getAddressLookupMetas(compiledMessage.addressTableLookups, config?.addressesByLookupTableAddress ?? {}) : [];
+  const transactionMetas = [...accountMetas, ...accountLookupMetas];
+  const instructions = compiledMessage.instructions.map(
+    (compiledInstruction) => convertInstruction(compiledInstruction, transactionMetas)
+  );
+  const firstInstruction = instructions[0];
+  const lifetimeConstraint = getLifetimeConstraint(
+    compiledMessage.lifetimeToken,
+    firstInstruction,
+    config?.lastValidBlockHeight
+  );
+  const signatures = convertSignatures(compiledTransaction);
+  return functional.pipe(
+    createTransaction({ version: compiledMessage.version }),
+    (tx) => setTransactionFeePayer(feePayer, tx),
+    (tx) => instructions.reduce((acc, instruction) => {
+      return appendTransactionInstruction(instruction, acc);
+    }, tx),
+    (tx) => "blockhash" in lifetimeConstraint ? setTransactionLifetimeUsingBlockhash(lifetimeConstraint, tx) : setTransactionLifetimeUsingDurableNonce(lifetimeConstraint, tx),
+    (tx) => Object.keys(signatures).length > 0 ? { ...tx, signatures } : tx
+  );
+}
 function upsert(addressMap, address, update) {
   addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });
 }
@@ -233,13 +388,13 @@ function getAddressMapFromInstructions(feePayer, instructions) {
         if (isWritableRole(entry.role)) {
           switch (entry[TYPE]) {
             case 0 /* FEE_PAYER */:
-              throw new Error(
-                `This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and set as the fee payer. Program addresses may not pay fees.`
-              );
+              throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION_INVOKED_PROGRAMS_CANNOT_PAY_FEES, {
+                programAddress: instruction.programAddress
+              });
             default:
-              throw new Error(
-                `This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and marked writable. Program addresses may not be writable.`
-              );
+              throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION_INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE, {
+                programAddress: instruction.programAddress
+              });
           }
         }
         if (entry[TYPE] === 2 /* STATIC */) {
@@ -304,8 +459,11 @@ function getAddressMapFromInstructions(feePayer, instructions) {
                 addressesOfInvokedPrograms.has(account.address)
               ) {
                 if (isWritableRole(accountMeta.role)) {
-                  throw new Error(
-                    `This transaction includes an address (\`${account.address}\`) which is both invoked and marked writable. Program addresses may not be writable.`
+                  throw new errors.SolanaError(
+                    errors.SOLANA_ERROR__TRANSACTION_INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE,
+                    {
+                      programAddress: account.address
+                    }
                   );
                 }
                 if (entry.role !== nextRole) {
@@ -595,7 +753,9 @@ function getTransactionVersionEncoder() {
         return offset;
       }
       if (value < 0 || value > 127) {
-        throw new Error(`Transaction version must be in the range [0, 127]. \`${value}\` given.`);
+        throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION_VERSION_NUMBER_OUT_OF_RANGE, {
+          actualVersion: value
+        });
       }
       bytes.set([value | VERSION_FLAG_MASK], offset);
       return offset + 1;
@@ -682,12 +842,15 @@ function getCompiledMessageEncoder() {
   });
 }
 function getCompiledMessageDecoder() {
-  return codecsCore.mapDecoder(codecsDataStructures.getStructDecoder(getPreludeStructDecoderTuple()), ({ addressTableLookups, ...restOfMessage }) => {
-    if (restOfMessage.version === "legacy" || !addressTableLookups?.length) {
-      return restOfMessage;
+  return codecsCore.mapDecoder(
+    codecsDataStructures.getStructDecoder(getPreludeStructDecoderTuple()),
+    ({ addressTableLookups, ...restOfMessage }) => {
+      if (restOfMessage.version === "legacy" || !addressTableLookups?.length) {
+        return restOfMessage;
+      }
+      return { ...restOfMessage, addressTableLookups };
     }
-    return { ...restOfMessage, addressTableLookups };
-  });
+  );
 }
 function getCompiledMessageCodec() {
   return codecsCore.combineCodec(getCompiledMessageEncoder(), getCompiledMessageDecoder());
@@ -710,116 +873,6 @@ function getCompiledTransaction(transaction) {
     signatures
   };
 }
-function getAccountMetas(message) {
-  const { header } = message;
-  const numWritableSignerAccounts = header.numSignerAccounts - header.numReadonlySignerAccounts;
-  const numWritableNonSignerAccounts = message.staticAccounts.length - header.numSignerAccounts - header.numReadonlyNonSignerAccounts;
-  const accountMetas = [];
-  let accountIndex = 0;
-  for (let i = 0; i < numWritableSignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.WRITABLE_SIGNER
-    });
-    accountIndex++;
-  }
-  for (let i = 0; i < header.numReadonlySignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.READONLY_SIGNER
-    });
-    accountIndex++;
-  }
-  for (let i = 0; i < numWritableNonSignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.WRITABLE
-    });
-    accountIndex++;
-  }
-  for (let i = 0; i < header.numReadonlyNonSignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.READONLY
-    });
-    accountIndex++;
-  }
-  return accountMetas;
-}
-function convertInstruction(instruction, accountMetas) {
-  const programAddress = accountMetas[instruction.programAddressIndex]?.address;
-  if (!programAddress) {
-    throw new Error(`Could not find program address at index ${instruction.programAddressIndex}`);
-  }
-  const accounts = instruction.accountIndices?.map((accountIndex) => accountMetas[accountIndex]);
-  const { data } = instruction;
-  return {
-    programAddress,
-    ...accounts && accounts.length ? { accounts } : {},
-    ...data && data.length ? { data } : {}
-  };
-}
-function getLifetimeConstraint(messageLifetimeToken, firstInstruction, lastValidBlockHeight) {
-  if (!firstInstruction || !isAdvanceNonceAccountInstruction(firstInstruction)) {
-    return {
-      blockhash: messageLifetimeToken,
-      lastValidBlockHeight: lastValidBlockHeight ?? 2n ** 64n - 1n
-      // U64 MAX
-    };
-  } else {
-    const nonceAccountAddress = firstInstruction.accounts[0].address;
-    addresses.assertIsAddress(nonceAccountAddress);
-    const nonceAuthorityAddress = firstInstruction.accounts[2].address;
-    addresses.assertIsAddress(nonceAuthorityAddress);
-    return {
-      nonce: messageLifetimeToken,
-      nonceAccountAddress,
-      nonceAuthorityAddress
-    };
-  }
-}
-function convertSignatures(compiledTransaction) {
-  const {
-    compiledMessage: { staticAccounts },
-    signatures
-  } = compiledTransaction;
-  return signatures.reduce((acc, sig, index) => {
-    const allZeros = sig.every((byte) => byte === 0);
-    if (allZeros)
-      return acc;
-    const address = staticAccounts[index];
-    return { ...acc, [address]: sig };
-  }, {});
-}
-function decompileTransaction(compiledTransaction, lastValidBlockHeight) {
-  const { compiledMessage } = compiledTransaction;
-  if ("addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups.length > 0) {
-    throw new Error("Cannot convert transaction with addressTableLookups");
-  }
-  const feePayer = compiledMessage.staticAccounts[0];
-  if (!feePayer)
-    throw new Error("No fee payer set in CompiledTransaction");
-  const accountMetas = getAccountMetas(compiledMessage);
-  const instructions = compiledMessage.instructions.map(
-    (compiledInstruction) => convertInstruction(compiledInstruction, accountMetas)
-  );
-  const firstInstruction = instructions[0];
-  const lifetimeConstraint = getLifetimeConstraint(
-    compiledMessage.lifetimeToken,
-    firstInstruction,
-    lastValidBlockHeight
-  );
-  const signatures = convertSignatures(compiledTransaction);
-  return functional.pipe(
-    createTransaction({ version: compiledMessage.version }),
-    (tx) => setTransactionFeePayer(feePayer, tx),
-    (tx) => instructions.reduce((acc, instruction) => {
-      return appendTransactionInstruction(instruction, acc);
-    }, tx),
-    (tx) => "blockhash" in lifetimeConstraint ? setTransactionLifetimeUsingBlockhash(lifetimeConstraint, tx) : setTransactionLifetimeUsingDurableNonce(lifetimeConstraint, tx),
-    (tx) => compiledTransaction.signatures.length ? { ...tx, signatures } : tx
-  );
-}
 
 // src/serializers/transaction.ts
 function getCompiledTransactionEncoder() {
@@ -842,14 +895,14 @@ function getCompiledTransactionDecoder() {
 function getTransactionEncoder() {
   return codecsCore.mapEncoder(getCompiledTransactionEncoder(), getCompiledTransaction);
 }
-function getTransactionDecoder(lastValidBlockHeight) {
+function getTransactionDecoder(config) {
   return codecsCore.mapDecoder(
     getCompiledTransactionDecoder(),
-    (compiledTransaction) => decompileTransaction(compiledTransaction, lastValidBlockHeight)
+    (compiledTransaction) => decompileTransaction(compiledTransaction, config)
   );
 }
-function getTransactionCodec(lastValidBlockHeight) {
-  return codecsCore.combineCodec(getTransactionEncoder(), getTransactionDecoder(lastValidBlockHeight));
+function getTransactionCodec(config) {
+  return codecsCore.combineCodec(getTransactionEncoder(), getTransactionDecoder(config));
 }
 var base58Decoder;
 function getSignatureFromTransaction(transaction) {
@@ -857,9 +910,7 @@ function getSignatureFromTransaction(transaction) {
     base58Decoder = codecsStrings.getBase58Decoder();
   const signatureBytes = transaction.signatures[transaction.feePayer];
   if (!signatureBytes) {
-    throw new Error(
-      "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer."
-    );
+    throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION_SIGNATURE_NOT_COMPUTABLE);
   }
   const transactionSignature = base58Decoder.decode(signatureBytes);
   return transactionSignature;
@@ -892,11 +943,17 @@ async function signTransaction(keyPairs, transaction) {
 function assertTransactionIsFullySigned(transaction) {
   const signerAddressesFromInstructions = transaction.instructions.flatMap((i) => i.accounts?.filter((a) => isSignerRole(a.role)) ?? []).map((a) => a.address);
   const requiredSigners = /* @__PURE__ */ new Set([transaction.feePayer, ...signerAddressesFromInstructions]);
+  const missingSigs = [];
   requiredSigners.forEach((address) => {
     if (!transaction.signatures[address]) {
-      throw new Error(`Transaction is missing signature for address \`${address}\``);
+      missingSigs.push(address);
     }
   });
+  if (missingSigs.length > 0) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION_MISSING_SIGNATURES, {
+      addresses: missingSigs
+    });
+  }
 }
 function getBase64EncodedWireTransaction(transaction) {
   const wireTransactionBytes = getTransactionEncoder().encode(transaction);
@@ -904,23 +961,27 @@ function getBase64EncodedWireTransaction(transaction) {
 }
 
 exports.appendTransactionInstruction = appendTransactionInstruction;
-exports.assertIsBlockhash = assertIsBlockhash;
+exports.appendTransactionInstructions = appendTransactionInstructions;
 exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
 exports.assertIsTransactionWithBlockhashLifetime = assertIsTransactionWithBlockhashLifetime;
 exports.assertTransactionIsFullySigned = assertTransactionIsFullySigned;
 exports.compileMessage = compileMessage;
 exports.createTransaction = createTransaction;
+exports.decompileTransaction = decompileTransaction;
 exports.getBase64EncodedWireTransaction = getBase64EncodedWireTransaction;
 exports.getCompiledMessageCodec = getCompiledMessageCodec;
 exports.getCompiledMessageDecoder = getCompiledMessageDecoder;
 exports.getCompiledMessageEncoder = getCompiledMessageEncoder;
+exports.getCompiledTransactionDecoder = getCompiledTransactionDecoder;
 exports.getSignatureFromTransaction = getSignatureFromTransaction;
 exports.getTransactionCodec = getTransactionCodec;
 exports.getTransactionDecoder = getTransactionDecoder;
 exports.getTransactionEncoder = getTransactionEncoder;
+exports.getUnsignedTransaction = getUnsignedTransaction;
 exports.isAdvanceNonceAccountInstruction = isAdvanceNonceAccountInstruction;
 exports.partiallySignTransaction = partiallySignTransaction;
 exports.prependTransactionInstruction = prependTransactionInstruction;
+exports.prependTransactionInstructions = prependTransactionInstructions;
 exports.setTransactionFeePayer = setTransactionFeePayer;
 exports.setTransactionLifetimeUsingBlockhash = setTransactionLifetimeUsingBlockhash;
 exports.setTransactionLifetimeUsingDurableNonce = setTransactionLifetimeUsingDurableNonce;