@solana/signers 2.0.0-experimental.efe6f4d → 2.0.0-experimental.f054d90

package/README.md

@@ -336,33 +336,235 @@ assertIsKeyPairSigner({ address: address('1234..5678') }); // ❌ Throws an erro
 
 ## Creating Noop signers
 
-### Functions
-
-#### `createNoopSigner()`
-
-_Coming soon..._
-
-Creates a Noop (No-Operation) signer from a given address. It will return an implementation of both the `MessagePartialSigner` and `TransactionPartialSigner` interfaces that do not sign anything. Namely, signing a transaction or a message will return an empty `SignatureDictionary`.
+For a given address, a Noop (No-Operation) signer can be created to offer an implementation of both the `MessagePartialSigner` and `TransactionPartialSigner` interfaces such that they do not sign anything. Namely, signing a transaction or a message with a `NoopSigner` will return an empty `SignatureDictionary`.
 
 This signer may be useful:
 
 -   For testing purposes.
 -   For indicating that a given account is a signer and taking the responsibility to provide the signature for that account ourselves. For instance, if we need to send the transaction to a server that will sign it and send it for us.
 
+### Types
+
+#### `NoopSigner<TAddress>`
+
+Defines a Noop (No-Operation) signer.
+
+```ts
+const myNoopSigner: NoopSigner;
+myNoopSigner satisfies MessagePartialSigner;
+myNoopSigner satisfies TransactionPartialSigner;
+```
+
+### Functions
+
+#### `createNoopSigner()`
+
+Creates a Noop (No-Operation) signer from a given address.
+
 ```ts
 import { createNoopSigner } from '@solana/signers';
 
-const myAddress = address('1234..5678');
-const myNoopSigner = createNoopSigner(myAddress);
-// ^ MessagePartialSigner<'1234..5678'> & TransactionPartialSigner<'1234..5678'>
+const myNoopSigner = createNoopSigner(address('1234..5678'));
+const [myMessageSignatures] = await myNoopSigner.signMessages([myMessage]); // <- Empty signature dictionary.
+const [myTransactionSignatures] = await myNoopSigner.signTransactions([myTransaction]); // <- Empty signature dictionary.
 ```
 
 ## Storing transaction signers inside instruction account metas
 
+This package defines an alternative definition for account metas that allows us to store `TransactionSigners` inside them. This means each instruction can keep track of its own set of signers and, by extension, so can transactions.
+
+It also provides helper functions that deduplicate and extract signers from instructions and transactions which makes it possible to sign an entire transaction automatically as we will see in the next section.
+
 ### Types
 
-_Coming soon..._
+#### `IAccountSignerMeta`
+
+Alternative `IAccountMeta` definition for signer accounts that allows us to store `TransactionSigners` inside it.
+
+```ts
+const mySignerMeta: IAccountSignerMeta = {
+    address: myTransactionSigner.address,
+    role: AccountRole.READONLY_SIGNER,
+    signer: myTransactionSigner,
+};
+```
+
+#### `IInstructionWithSigners`
+
+Composable type that allows `IAccountSignerMetas` to be used inside the instruction's `accounts` array.
+
+```ts
+const myInstructionWithSigners: IInstruction & IInstructionWithSigners = {
+    programAddress: address('1234..5678'),
+    accounts: [
+        {
+            address: myTransactionSigner.address,
+            role: AccountRole.READONLY_SIGNER,
+            signer: myTransactionSigner,
+        },
+    ],
+};
+```
+
+#### `ITransactionWithSigners`
+
+Composable type that allows `IAccountSignerMetas` to be used inside all of the transaction's account metas.
+
+```ts
+const myTransactionWithSigners: BaseTransaction & ITransactionWithSigners = {
+    instructions: [
+        myInstructionA as IInstruction & IInstructionWithSigners,
+        myInstructionB as IInstruction & IInstructionWithSigners,
+        myInstructionC as IInstruction,
+    ],
+    version: 0,
+};
+```
 
 ### Functions
 
-_Coming soon..._
+#### `getSignersFromInstruction()`
+
+Extracts and deduplicates all signers stored inside the account metas of an instruction.
+
+```ts
+const mySignerA = { address: address('1111..1111'), signTransactions: async () => {} };
+const mySignerB = { address: address('2222..2222'), signTransactions: async () => {} };
+const myInstructionWithSigners: IInstructionWithSigners = {
+    programAddress: address('1234..5678'),
+    accounts: [
+        { address: mySignerA.address, role: AccountRole.READONLY_SIGNER, signer: mySignerA },
+        { address: mySignerB.address, role: AccountRole.WRITABLE_SIGNER, signer: mySignerB },
+        { address: mySignerA.address, role: AccountRole.WRITABLE_SIGNER, signer: mySignerA },
+    ],
+};
+
+const instructionSigners = getSignersFromInstruction(myInstructionWithSigners);
+// ^ [mySignerA, mySignerB]
+```
+
+#### `getSignersFromTransaction()`
+
+Similarly to `getSignersFromInstruction`, this function extracts and deduplicates all signers stored inside the account metas of all the instructions inside a transaction.
+
+```ts
+const transactionSigners = getSignersFromTransaction(myTransactionWithSigners);
+```
+
+#### `addSignersToInstruction()`
+
+Helper function that adds the provided signers to any of the applicable account metas. For an account meta to match a provided signer it:
+
+-   Must have a signer role (`AccountRole.READONLY_SIGNER` or `AccountRole.WRITABLE_SIGNER`).
+-   Must have the same address as the provided signer.
+-   Must not have an attached signer already.
+
+```ts
+const myInstruction: IInstruction = {
+    accounts: [
+        { address: '1111' as Address, role: AccountRole.READONLY_SIGNER },
+        { address: '2222' as Address, role: AccountRole.WRITABLE_SIGNER },
+    ],
+    // ...
+};
+
+const signerA: TransactionSigner<'1111'>;
+const signerB: TransactionSigner<'2222'>;
+const myInstructionWithSigners = addSignersToInstruction([mySignerA, mySignerB], myInstruction);
+
+// myInstructionWithSigners.accounts[0].signer === mySignerA
+// myInstructionWithSigners.accounts[1].signer === mySignerB
+```
+
+#### `addSignersToTransaction()`
+
+Similarly to `addSignersToInstruction`, this function adds signer to all the applicable account metas of all the instructions inside a transaction.
+
+```ts
+const myTransactionWithSigners = addSignersToTransaction(mySigners, myTransaction);
+```
+
+## Signing transactions with signers
+
+As we've seen in the previous section, we can store and extract `TransactionSigners` from instructions and transactions. This allows us to provide helper methods that sign transactions using the signers stored inside them.
+
+### Functions
+
+#### `partiallySignTransactionWithSigners()`
+
+Extracts all signers inside the provided transaction and uses them to sign it. It first uses all `TransactionModifyingSigners` sequentially before using all `TransactionPartialSigners` in parallel.
+
+If a composite signer implements both interfaces, it will be used as a modifying signer if no other signer implements that interface. Otherwise, it will be used as a partial signer.
+
+```ts
+const mySignedTransaction = await partiallySignTransactionWithSigners(myTransaction);
+```
+
+It also accepts an optional `AbortSignal` that will be propagated to all signers.
+
+```ts
+const mySignedTransaction = await partiallySignTransactionWithSigners(myTransaction, {
+    abortSignal: myAbortController.signal,
+});
+```
+
+Finally, note that this function ignores `TransactionSendingSigners` as it does not send the transaction. See the `signAndSendTransactionWithSigners` function below for more details on how to use sending signers.
+
+#### `signTransactionWithSigners()`
+
+This function works the same as the `partiallySignTransactionWithSigners` function described above except that it also ensures the transaction is fully signed before returning it. An error will be thrown if that's not the case.
+
+```ts
+const mySignedTransaction = await signTransactionWithSigners(myTransaction);
+
+// With additional config.
+const mySignedTransaction = await signTransactionWithSigners(myTransaction, {
+    abortSignal: myAbortController.signal,
+});
+
+// We now know the transaction is fully signed.
+mySignedTransaction satisfies IFullySignedTransaction;
+```
+
+#### `signAndSendTransactionWithSigners()`
+
+Extracts all signers inside the provided transaction and uses them to sign it before sending it immediately to the blockchain. It returns the signature of the sent transaction (i.e. its identifier).
+
+```ts
+const myTransactionSignature = await signAndSendTransactionWithSigners(myTransaction);
+
+// With additional config.
+const myTransactionSignature = await signAndSendTransactionWithSigners(myTransaction, {
+    abortSignal: myAbortController.signal,
+});
+```
+
+Similarly to the `partiallySignTransactionWithSigners` function, it first uses all `TransactionModifyingSigners` sequentially before using all `TransactionPartialSigners` in parallel. It then sends the transaction using the `TransactionSendingSigner` it identified.
+
+Here as well, composite transaction signers are treated such that at least one sending signer is used if any. When a `TransactionSigner` implements more than one interface, use it as a:
+
+-   `TransactionSendingSigner`, if no other `TransactionSendingSigner` exists.
+-   `TransactionModifyingSigner`, if no other `TransactionModifyingSigner` exists.
+-   `TransactionPartialSigner`, otherwise.
+
+The provided transaction must be of type `ITransactionWithSingleSendingSigner` meaning that it must contain exactly one `TransactionSendingSigner` inside its account metas. If more than one composite signers implement the `TransactionSendingSigner` interface, one of them will be selected as the sending signer.
+
+Therefore, you may use the `assertIsTransactionWithSingleSendingSigner()` function to ensure the transaction is of the expected type.
+
+```ts
+assertIsTransactionWithSingleSendingSigner(myTransaction);
+const myTransactionSignature = await signAndSendTransactionWithSigners(myTransaction);
+```
+
+Alternatively, you may use the `isTransactionWithSingleSendingSigner()` function to provide a fallback in case the transaction does not contain any sending signer.
+
+```ts
+let transactionSignature: SignatureBytes;
+if (isTransactionWithSingleSendingSigner(transaction)) {
+    transactionSignature = await signAndSendTransactionWithSigners(transaction);
+} else {
+    const signedTransaction = await signTransactionWithSigners(transaction);
+    const encodedTransaction = getBase64EncodedWireTransaction(signedTransaction);
+    transactionSignature = await rpc.sendTransaction(encodedTransaction).send();
+}
+```

package/dist/index.browser.cjs

@@ -1,10 +1,78 @@
 'use strict';
 
+var instructions = require('@solana/instructions');
+var transactions = require('@solana/transactions');
 var addresses = require('@solana/addresses');
 var keys = require('@solana/keys');
-var transactions = require('@solana/transactions');
 
-// src/keypair-signer.ts
+// src/deduplicate-signers.ts
+function deduplicateSigners(signers) {
+  const deduplicated = {};
+  signers.forEach((signer) => {
+    if (!deduplicated[signer.address]) {
+      deduplicated[signer.address] = signer;
+    } else if (deduplicated[signer.address] !== signer) {
+      throw new Error(
+        `Multiple distinct signers were identified for address "${signer.address}". Please ensure that you are using the same signer instance for each address.`
+      );
+    }
+  });
+  return Object.values(deduplicated);
+}
+
+// src/account-signer-meta.ts
+function getSignersFromInstruction(instruction) {
+  return deduplicateSigners(
+    (instruction.accounts ?? []).flatMap((account) => "signer" in account ? account.signer : [])
+  );
+}
+function getSignersFromTransaction(transaction) {
+  return deduplicateSigners([
+    ...transaction.feePayerSigner ? [transaction.feePayerSigner] : [],
+    ...transaction.instructions.flatMap(getSignersFromInstruction)
+  ]);
+}
+function addSignersToInstruction(signers, instruction) {
+  if (!instruction.accounts || instruction.accounts.length === 0) {
+    return instruction;
+  }
+  const signerByAddress = new Map(deduplicateSigners(signers).map((signer) => [signer.address, signer]));
+  return Object.freeze({
+    ...instruction,
+    accounts: instruction.accounts.map((account) => {
+      const signer = signerByAddress.get(account.address);
+      if (!instructions.isSignerRole(account.role) || "signer" in account || !signer) {
+        return account;
+      }
+      return Object.freeze({ ...account, signer });
+    })
+  });
+}
+function addSignersToTransaction(signers, transaction) {
+  if (transaction.instructions.length === 0) {
+    return transaction;
+  }
+  return Object.freeze({
+    ...transaction,
+    instructions: transaction.instructions.map((instruction) => addSignersToInstruction(signers, instruction))
+  });
+}
+function setTransactionFeePayerSigner(feePayerSigner, transaction) {
+  if ("feePayer" in transaction && feePayerSigner.address === transaction.feePayer) {
+    if ("feePayerSigner" in transaction)
+      return transaction;
+    const out2 = { ...transaction, feePayerSigner };
+    Object.freeze(out2);
+    return out2;
+  }
+  const out = {
+    ...transactions.getUnsignedTransaction(transaction),
+    feePayer: feePayerSigner.address,
+    feePayerSigner
+  };
+  Object.freeze(out);
+  return out;
+}
 
 // src/message-partial-signer.ts
 function isMessagePartialSigner(value) {
@@ -57,6 +125,9 @@ async function createSignerFromKeyPair(keyPair) {
 async function generateKeyPairSigner() {
   return createSignerFromKeyPair(await keys.generateKeyPair());
 }
+async function createKeyPairSignerFromBytes(bytes, extractable) {
+  return createSignerFromKeyPair(await keys.createKeyPairFromBytes(bytes, extractable));
+}
 function isMessageModifyingSigner(value) {
   return addresses.isAddress(value.address) && "modifyAndSignMessages" in value && typeof value.modifyAndSignMessages === "function";
 }
@@ -75,14 +146,15 @@ function assertIsMessageSigner(value) {
     throw new Error("The provided value does not implement any of the MessageSigner interfaces");
   }
 }
-var o = globalThis.TextEncoder;
 
-// src/signable-message.ts
-function createSignableMessage(content, signatures = {}) {
-  return Object.freeze({
-    content: typeof content === "string" ? new o().encode(content) : content,
-    signatures: Object.freeze({ ...signatures })
-  });
+// src/noop-signer.ts
+function createNoopSigner(address) {
+  const out = {
+    address,
+    signMessages: async (messages) => messages.map(() => Object.freeze({})),
+    signTransactions: async (transactions) => transactions.map(() => Object.freeze({}))
+  };
+  return Object.freeze(out);
 }
 
 // src/transaction-modifying-signer.ts
@@ -115,6 +187,137 @@ function assertIsTransactionSigner(value) {
   }
 }
 
+// src/sign-transaction.ts
+async function partiallySignTransactionWithSigners(transaction, config = {}) {
+  const { partialSigners, modifyingSigners } = categorizeTransactionSigners(
+    deduplicateSigners(getSignersFromTransaction(transaction).filter(isTransactionSigner)),
+    { identifySendingSigner: false }
+  );
+  return signModifyingAndPartialTransactionSigners(transaction, modifyingSigners, partialSigners, config.abortSignal);
+}
+async function signTransactionWithSigners(transaction, config = {}) {
+  const signedTransaction = await partiallySignTransactionWithSigners(transaction, config);
+  transactions.assertTransactionIsFullySigned(signedTransaction);
+  return signedTransaction;
+}
+async function signAndSendTransactionWithSigners(transaction, config = {}) {
+  const abortSignal = config.abortSignal;
+  const { partialSigners, modifyingSigners, sendingSigner } = categorizeTransactionSigners(
+    deduplicateSigners(getSignersFromTransaction(transaction).filter(isTransactionSigner))
+  );
+  abortSignal?.throwIfAborted();
+  const signedTransaction = await signModifyingAndPartialTransactionSigners(
+    transaction,
+    modifyingSigners,
+    partialSigners,
+    abortSignal
+  );
+  if (!sendingSigner) {
+    throw new Error(
+      "No `TransactionSendingSigner` was identified. Please provide a valid `ITransactionWithSingleSendingSigner` transaction."
+    );
+  }
+  abortSignal?.throwIfAborted();
+  const [signature] = await sendingSigner.signAndSendTransactions([signedTransaction], { abortSignal });
+  abortSignal?.throwIfAborted();
+  return signature;
+}
+function categorizeTransactionSigners(signers, config = {}) {
+  const identifySendingSigner = config.identifySendingSigner ?? true;
+  const sendingSigner = identifySendingSigner ? identifyTransactionSendingSigner(signers) : null;
+  const otherSigners = signers.filter(
+    (signer) => signer !== sendingSigner && (isTransactionModifyingSigner(signer) || isTransactionPartialSigner(signer))
+  );
+  const modifyingSigners = identifyTransactionModifyingSigners(otherSigners);
+  const partialSigners = otherSigners.filter(isTransactionPartialSigner).filter((signer) => !modifyingSigners.includes(signer));
+  return Object.freeze({ modifyingSigners, partialSigners, sendingSigner });
+}
+function identifyTransactionSendingSigner(signers) {
+  const sendingSigners = signers.filter(isTransactionSendingSigner);
+  if (sendingSigners.length === 0)
+    return null;
+  const sendingOnlySigners = sendingSigners.filter(
+    (signer) => !isTransactionModifyingSigner(signer) && !isTransactionPartialSigner(signer)
+  );
+  if (sendingOnlySigners.length > 0) {
+    return sendingOnlySigners[0];
+  }
+  return sendingSigners[0];
+}
+function identifyTransactionModifyingSigners(signers) {
+  const modifyingSigners = signers.filter(isTransactionModifyingSigner);
+  if (modifyingSigners.length === 0)
+    return [];
+  const nonPartialSigners = modifyingSigners.filter((signer) => !isTransactionPartialSigner(signer));
+  if (nonPartialSigners.length > 0)
+    return nonPartialSigners;
+  return [modifyingSigners[0]];
+}
+async function signModifyingAndPartialTransactionSigners(transaction, modifyingSigners = [], partialSigners = [], abortSignal) {
+  const modifiedTransaction = await modifyingSigners.reduce(
+    async (transaction2, modifyingSigner) => {
+      abortSignal?.throwIfAborted();
+      const [tx] = await modifyingSigner.modifyAndSignTransactions([await transaction2], { abortSignal });
+      return Object.freeze(tx);
+    },
+    Promise.resolve(transaction)
+  );
+  abortSignal?.throwIfAborted();
+  const signatureDictionaries = await Promise.all(
+    partialSigners.map(async (partialSigner) => {
+      const [signatures] = await partialSigner.signTransactions([modifiedTransaction], { abortSignal });
+      return signatures;
+    })
+  );
+  const signedTransaction = {
+    ...modifiedTransaction,
+    signatures: Object.freeze(
+      signatureDictionaries.reduce((signatures, signatureDictionary) => {
+        return { ...signatures, ...signatureDictionary };
+      }, modifiedTransaction.signatures ?? {})
+    )
+  };
+  return Object.freeze(signedTransaction);
+}
+var o = globalThis.TextEncoder;
+
+// src/signable-message.ts
+function createSignableMessage(content, signatures = {}) {
+  return Object.freeze({
+    content: typeof content === "string" ? new o().encode(content) : content,
+    signatures: Object.freeze({ ...signatures })
+  });
+}
+
+// src/transaction-with-single-sending-signer.ts
+function isTransactionWithSingleSendingSigner(transaction) {
+  try {
+    assertIsTransactionWithSingleSendingSigner(transaction);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertIsTransactionWithSingleSendingSigner(transaction) {
+  const signers = getSignersFromTransaction(transaction);
+  const sendingSigners = signers.filter(isTransactionSendingSigner);
+  if (sendingSigners.length === 0) {
+    const error = new Error("No `TransactionSendingSigner` was identified.");
+    error.name = "MissingTransactionSendingSignerError";
+    throw error;
+  }
+  const sendingOnlySigners = sendingSigners.filter(
+    (signer) => !isTransactionPartialSigner(signer) && !isTransactionModifyingSigner(signer)
+  );
+  if (sendingOnlySigners.length > 1) {
+    const error = new Error("More than one `TransactionSendingSigner` was identified.");
+    error.name = "MultipleTransactionSendingSignersError";
+    throw error;
+  }
+}
+
+exports.addSignersToInstruction = addSignersToInstruction;
+exports.addSignersToTransaction = addSignersToTransaction;
 exports.assertIsKeyPairSigner = assertIsKeyPairSigner;
 exports.assertIsMessageModifyingSigner = assertIsMessageModifyingSigner;
 exports.assertIsMessagePartialSigner = assertIsMessagePartialSigner;
@@ -123,9 +326,14 @@ exports.assertIsTransactionModifyingSigner = assertIsTransactionModifyingSigner;
 exports.assertIsTransactionPartialSigner = assertIsTransactionPartialSigner;
 exports.assertIsTransactionSendingSigner = assertIsTransactionSendingSigner;
 exports.assertIsTransactionSigner = assertIsTransactionSigner;
+exports.assertIsTransactionWithSingleSendingSigner = assertIsTransactionWithSingleSendingSigner;
+exports.createKeyPairSignerFromBytes = createKeyPairSignerFromBytes;
+exports.createNoopSigner = createNoopSigner;
 exports.createSignableMessage = createSignableMessage;
 exports.createSignerFromKeyPair = createSignerFromKeyPair;
 exports.generateKeyPairSigner = generateKeyPairSigner;
+exports.getSignersFromInstruction = getSignersFromInstruction;
+exports.getSignersFromTransaction = getSignersFromTransaction;
 exports.isKeyPairSigner = isKeyPairSigner;
 exports.isMessageModifyingSigner = isMessageModifyingSigner;
 exports.isMessagePartialSigner = isMessagePartialSigner;
@@ -134,5 +342,10 @@ exports.isTransactionModifyingSigner = isTransactionModifyingSigner;
 exports.isTransactionPartialSigner = isTransactionPartialSigner;
 exports.isTransactionSendingSigner = isTransactionSendingSigner;
 exports.isTransactionSigner = isTransactionSigner;
+exports.isTransactionWithSingleSendingSigner = isTransactionWithSingleSendingSigner;
+exports.partiallySignTransactionWithSigners = partiallySignTransactionWithSigners;
+exports.setTransactionFeePayerSigner = setTransactionFeePayerSigner;
+exports.signAndSendTransactionWithSigners = signAndSendTransactionWithSigners;
+exports.signTransactionWithSigners = signTransactionWithSigners;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.cjs.map