@solana/signers 2.0.0-experimental.3331786

package/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2018 Solana Labs, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,368 @@
+[![npm][npm-image]][npm-url]
+[![npm-downloads][npm-downloads-image]][npm-url]
+[![semantic-release][semantic-release-image]][semantic-release-url]
+<br />
+[![code-style-prettier][code-style-prettier-image]][code-style-prettier-url]
+
+[code-style-prettier-image]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square
+[code-style-prettier-url]: https://github.com/prettier/prettier
+[npm-downloads-image]: https://img.shields.io/npm/dm/@solana/signers/experimental.svg?style=flat
+[npm-image]: https://img.shields.io/npm/v/@solana/signers/experimental.svg?style=flat
+[npm-url]: https://www.npmjs.com/package/@solana/signers/v/experimental
+[semantic-release-image]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
+[semantic-release-url]: https://github.com/semantic-release/semantic-release
+
+# @solana/signers
+
+This package provides an abstraction layer over signing messages and transactions in Solana. It can be used standalone, but it is also exported as part of the Solana JavaScript SDK [`@solana/web3.js@experimental`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/library).
+
+You can think of signers as an abstract way to sign messages and transactions. This could be using a Crypto KeyPair, a wallet adapter in the browser, a Noop signer for testing purposes, or anything you want. Here's an example using a `CryptoKeyPair` signer:
+
+```ts
+import { pipe } from '@solana/functional';
+import { generateKeyPairSigner } from '@solana/signers';
+import { createTransaction } from '@solana/transactions';
+
+// Generate a key pair signer.
+const mySigner = await generateKeyPairSigner();
+mySigner.address; // Address;
+
+// Sign one or multiple messages.
+const myMessage = createSignableMessage('Hello world!');
+const [messageSignatures] = await mySigner.signMessages([myMessage]);
+
+// Sign one or multiple transactions.
+const myTransaction = pipe(
+    createTransaction({ version: 0 })
+    // Add instructions, fee payer, lifetime, etc.
+);
+const [transactionSignatures] = await mySigner.signTransactions([myTransaction]);
+```
+
+As you can see, this provides a consistent API regardless of how things are being signed behind the scenes. If tomorrow we need to use a browser wallet instead, we'd simply need to swap the `generateKeyPairSigner` function with the signer factory of our choice.
+
+This package offers a total of five different types of signers that may be used in combination when applicable. Three of them allow us to sign transactions whereas the other two are used for regular message signing.
+
+They are separated into three categories:
+
+-   **Partial signers**: Given a message or transaction, provide one or more signatures for it. These signers are not able to modify the given data which allows us to run many of them in parallel.
+-   **Modifying signers**: Can choose to modify a message or transaction before signing it with zero or more private keys. Because modifying a message or transaction invalidates any pre-existing signatures over it, modifying signers must do their work before any other signer.
+-   **Sending signers**: Given a transaction, signs it and sends it immediately to the blockchain. When applicable, the signer may also decide to modify the provided transaction before signing it. This interface accommodates wallets that simply cannot sign a transaction without sending it at the same time. This category of signers does not apply to regular messages.
+
+Thus, we end up with the following interfaces.
+
+|                     | Partial signers            | Modifying signers            | Sending signers            |
+| ------------------- | -------------------------- | ---------------------------- | -------------------------- |
+| `TransactionSigner` | `TransactionPartialSigner` | `TransactionModifyingSigner` | `TransactionSendingSigner` |
+| `MessageSigner`     | `MessagePartialSigner`     | `MessageModifyingSigner`     | N/A                        |
+
+We will go through each of these five signer interfaces and their respective characteristics in the documentation below.
+
+This package also provides the following concrete signer implementations:
+
+-   The `KeyPairSigner` which uses a `CryptoKeyPair` to sign messages and transactions.
+-   The Noop signer which does not sign anything and is mostly useful for testing purposes or for indicating that an account will be signed in a different environment (e.g. sending a transaction to your server so it can sign it).
+
+Additionally, this package allows transaction signers to be stored inside the account meta of an instruction. This allows us to create instructions by passing around signers instead of addresses when applicable which, in turn, allows us to sign an entire transaction automatically without having to scan through its instructions to find the required signers.
+
+In the sections below, we'll go through all the provided signers in more detail before diving into storing signers inside instruction account metas and how to benefit from it.
+
+## Signing messages
+
+### Types
+
+#### `SignableMessage`
+
+Defines a message with any of the signatures that might have already been provided by other signers. This interface allows modifying signers to decide on whether or not they should modify the provided message depending on whether or not signatures already exist for such message. It also helps create a more consistent API by providing a structure analogous to transactions which also keep track of their signature dictionary.
+
+```ts
+type SignableMessage = {
+    content: Uint8Array;
+    signatures: SignatureDictionary; // Record<Address, SignatureBytes>
+};
+```
+
+#### `MessagePartialSigner<TAddress>`
+
+An interface that signs an array of `SignableMessages` without modifying their content. It defines a `signMessages` function that returns a `SignatureDictionary` for each provided message. Such signature dictionaries are expected to be merged with the existing ones if any.
+
+```ts
+const myMessagePartialSigner: MessagePartialSigner<'1234..5678'> = {
+    address: address('1234..5678'),
+    signMessages: async (messages: SignableMessage[]): Promise<SignatureDictionary[]> => {
+        // My custom signing logic.
+    },
+};
+```
+
+**Characteristics**:
+
+-   **Parallel**. When multiple signers sign the same message, we can perform this operation in parallel to obtain all their signatures.
+-   **Flexible order**. The order in which we use these signers for a given message doesn’t matter.
+
+#### `MessageModifyingSigner<TAddress>`
+
+An interface that potentially modifies the content of the provided `SignableMessages` before signing them. E.g. this enables wallets to prefix or suffix nonces to the messages they sign. For each message, instead of returning a `SignatureDirectory`, its `modifyAndSignMessages` function returns its updated `SignableMessage` with a potentially modified content and signature dictionary.
+
+```ts
+const myMessageModifyingSigner: MessageModifyingSigner<'1234..5678'> = {
+    address: address('1234..5678'),
+    modifyAndSignMessages: async (messages: SignableMessage[]): Promise<SignableMessage[]> => {
+        // My custom signing logic.
+    },
+};
+```
+
+**Characteristics**:
+
+-   **Sequential**. Contrary to partial signers, these cannot be executed in parallel as each call can modify the content of the message.
+-   **First signers**. For a given message, a modifying signer must always be used before a partial signer as the former will likely modify the message and thus impact the outcome of the latter.
+-   **Potential conflicts**. If more than one modifying signer is provided, the second signer may invalidate the signature of the first one. However, modifying signers may decide not to modify a message based on the existence of signatures for that message.
+
+#### `MessageSigner<TAddress>`
+
+Union interface that uses any of the available message signers.
+
+```ts
+type MessageSigner<TAddress extends string = string> =
+    | MessagePartialSigner<TAddress>
+    | MessageModifyingSigner<TAddress>;
+```
+
+### Functions
+
+#### `createSignableMessage(content, signatures?)`
+
+Creates a `SignableMessage` from a `Uint8Array` or a UTF-8 string. It optionally accepts a signature dictionary if the message already contains signatures.
+
+```ts
+const myMessage = createSignableMessage(new Uint8Array([1, 2, 3]));
+const myMessageFromText = createSignableMessage('Hello world!');
+const myMessageWithSignatures = createSignableMessage('Hello world!', {
+    '1234..5678': new Uint8Array([1, 2, 3]),
+});
+```
+
+#### Type guards
+
+Each of the message interfaces described above comes with two type guards that allow us to check whether or not a given value is a message signer of the requested type. One that returns a boolean and one that asserts by throwing an error if the provided value is not of the expected interface.
+
+```ts
+const myAddress = address('1234..5678');
+
+isMessagePartialSigner({ address: myAddress, signMessages: async () => {} }); // ✅ true
+isMessagePartialSigner({ address: myAddress }); // ❌ false
+assertIsMessagePartialSigner({ address: myAddress, signMessages: async () => {} }); // ✅ void
+assertIsMessagePartialSigner({ address: myAddress }); // ❌ Throws an error.
+
+isMessageModifyingSigner({ address: myAddress, modifyAndSignMessages: async () => {} }); // ✅ true
+isMessageModifyingSigner({ address: myAddress }); // ❌ false
+assertIsMessageModifyingSigner({ address: myAddress, modifyAndSignMessages: async () => {} }); // ✅ void
+assertIsMessageModifyingSigner({ address: myAddress }); // ❌ Throws an error.
+
+isMessageSigner({ address: myAddress, signMessages: async () => {} }); // ✅ true
+isMessageSigner({ address: myAddress, modifyAndSignMessages: async () => {} }); // ✅ true
+assertIsMessageSigner({ address: myAddress, signMessages: async () => {} }); // ✅ void
+assertIsMessageSigner({ address: myAddress, modifyAndSignMessages: async () => {} }); // ✅ void
+```
+
+## Signing transactions
+
+### Types
+
+#### `TransactionPartialSigner<TAddress>`
+
+An interface that signs an array of `CompilableTransactions` without modifying their content. It defines a `signTransactions` function that returns a `SignatureDictionary` for each provided transaction. Such signature dictionaries are expected to be merged with the existing ones if any.
+
+```ts
+const myTransactionPartialSigner: TransactionPartialSigner<'1234..5678'> = {
+    address: address('1234..5678'),
+    signTransactions: async (transactions: CompilableTransaction[]): Promise<SignatureDictionary[]> => {
+        // My custom signing logic.
+    },
+};
+```
+
+**Characteristics**:
+
+-   **Parallel**. It returns a signature directory for each provided transaction without modifying them, making it possible for multiple partial signers to sign the same transaction in parallel.
+-   **Flexible order**. The order in which we use these signers for a given transaction doesn’t matter.
+
+#### `TransactionModifyingSigner<TAddress>`
+
+An interface that potentially modifies the provided `CompilableTransactions` before signing them. E.g. this enables wallets to inject additional instructions into the transaction before signing them. For each transaction, instead of returning a `SignatureDirectory`, its `modifyAndSignTransactions` function returns an updated `CompilableTransaction` with a potentially modified set of instructions and signature dictionary.
+
+```ts
+const myTransactionModifyingSigner: TransactionModifyingSigner<'1234..5678'> = {
+    address: address('1234..5678'),
+    modifyAndSignTransactions: async <T extends CompilableTransaction>(transactions: T[]): Promise<T[]> => {
+        // My custom signing logic.
+    },
+};
+```
+
+**Characteristics**:
+
+-   **Sequential**. Contrary to partial signers, these cannot be executed in parallel as each call can modify the provided transactions.
+-   **First signers**. For a given transaction, a modifying signer must always be used before a partial signer as the former will likely modify the transaction and thus impact the outcome of the latter.
+-   **Potential conflicts**. If more than one modifying signer is provided, the second signer may invalidate the signature of the first one. However, modifying signers may decide not to modify a transaction based on the existence of signatures for that transaction.
+
+#### `TransactionSendingSigner<TAddress>`
+
+An interface that signs one or multiple transactions before sending them immediately to the blockchain. It defines a `signAndSendTransactions` function that returns the transaction signature (i.e. its identifier) for each provided `CompilableTransaction`. This interface is required for PDA wallets and other types of wallets that don't provide an interface for signing transactions without sending them.
+
+Note that it is also possible for such signers to modify the provided transactions before signing and sending them. This enables use cases where the modified transactions cannot be shared with the app and thus must be sent directly.
+
+```ts
+const myTransactionSendingSigner: TransactionSendingSigner<'1234..5678'> = {
+    address: address('1234..5678'),
+    signAndSendTransactions: async (transactions: CompilableTransaction[]): Promise<SignatureBytes[]> => {
+        // My custom signing logic.
+    },
+};
+```
+
+**Characteristics**:
+
+-   **Single signer**. Since this signer also sends the provided transactions, we can only use a single `TransactionSendingSigner` for a given set of transactions.
+-   **Last signer**. Trivially, that signer must also be the last one used.
+-   **Potential conflicts**. Since signers may decide to modify the given transactions before sending them, they may invalidate previous signatures. However, signers may decide not to modify a transaction based on the existence of signatures for that transaction.
+-   **Potential confirmation**. Whilst this is not required by this interface, it is also worth noting that most wallets will also wait for the transaction to be confirmed (typically with a `confirmed` commitment) before notifying the app that they are done.
+
+#### `TransactionSigner<TAddress>`
+
+Union interface that uses any of the available transaction signers.
+
+```ts
+type TransactionSigner<TAddress extends string = string> =
+    | TransactionPartialSigner<TAddress>
+    | TransactionModifyingSigner<TAddress>
+    | TransactionSendingSigner<TAddress>;
+```
+
+### Functions
+
+#### Type guards
+
+Each of the transaction interfaces described above comes with two type guards that allow us to check whether or not a given value is a transaction signer of the requested type. One that returns a boolean and one that asserts by throwing an error if the provided value is not of the expected interface.
+
+```ts
+const myAddress = address('1234..5678');
+
+isTransactionPartialSigner({ address: myAddress, signTransactions: async () => {} }); // ✅ true
+isTransactionPartialSigner({ address: myAddress }); // ❌ false
+assertIsTransactionPartialSigner({ address: myAddress, signTransactions: async () => {} }); // ✅ void
+assertIsTransactionPartialSigner({ address: myAddress }); // ❌ Throws an error.
+
+isTransactionModifyingSigner({ address: myAddress, modifyAndSignTransactions: async () => {} }); // ✅ true
+isTransactionModifyingSigner({ address: myAddress }); // ❌ false
+assertIsTransactionModifyingSigner({ address: myAddress, modifyAndSignTransactions: async () => {} }); // ✅ void
+assertIsTransactionModifyingSigner({ address: myAddress }); // ❌ Throws an error.
+
+isTransactionSendingSigner({ address: myAddress, signAndSignTransaction: async () => {} }); // ✅ true
+isTransactionSendingSigner({ address: myAddress }); // ❌ false
+assertIsTransactionSendingSigner({ address: myAddress, signAndSignTransaction: async () => {} }); // ✅ void
+assertIsTransactionSendingSigner({ address: myAddress }); // ❌ Throws an error.
+
+isTransactionSigner({ address: myAddress, signTransactions: async () => {} }); // ✅ true
+isTransactionSigner({ address: myAddress, modifyAndSignTransactions: async () => {} }); // ✅ true
+isTransactionSigner({ address: myAddress, signAndSignTransaction: async () => {} }); // ✅ true
+assertIsTransactionSigner({ address: myAddress, signTransactions: async () => {} }); // ✅ void
+assertIsTransactionSigner({ address: myAddress, modifyAndSignTransactions: async () => {} }); // ✅ void
+assertIsTransactionSigner({ address: myAddress, signAndSignTransaction: async () => {} }); // ✅ void
+```
+
+## Creating and generating KeyPair signers
+
+### Types
+
+#### `KeyPairSigner<TAddress>`
+
+Defines a signer that uses a `CryptoKeyPair` to sign messages and transactions. It implements both the `MessagePartialSigner` and `TransactionPartialSigner` interfaces and keeps track of the `CryptoKeyPair` instance used to sign messages and transactions.
+
+```ts
+import { generateKeyPairSigner } from '@solana/signers';
+
+const myKeyPairSigner = generateKeyPairSigner();
+myKeyPairSigner.address; // Address;
+myKeyPairSigner.keyPair; // CryptoKeyPair;
+const [myMessageSignatures] = await myKeyPairSigner.signMessages([myMessage]);
+const [myTransactionSignatures] = await myKeyPairSigner.signTransactions([myTransaction]);
+```
+
+### Functions
+
+#### `createSignerFromKeyPair()`
+
+Creates a `KeyPairSigner` from a provided Crypto KeyPair. The `signMessages` and `signTransactions` functions of the returned signer will use the private key of the provided key pair to sign messages and transactions. Note that both the `signMessages` and `signTransactions` implementations are parallelized, meaning that they will sign all provided messages and transactions in parallel.
+
+```ts
+import { generateKeyPair } from '@solana/keys';
+import { createSignerFromKeyPair, KeyPairSigner } from '@solana/signers';
+
+const myKeyPair: CryptoKeyPair = await generateKeyPair();
+const myKeyPairSigner: KeyPairSigner = await createSignerFromKeyPair(myKeyPair);
+```
+
+#### `generateKeyPairSigner()`
+
+A convenience function that generates a new Crypto KeyPair and immediately creates a `KeyPairSigner` from it.
+
+```ts
+import { generateKeyPairSigner } from '@solana/signers';
+
+const myKeyPairSigner = await generateKeyPairSigner();
+```
+
+#### `isKeyPairSigner()`
+
+A type guard that returns `true` if the provided value is a `KeyPairSigner`.
+
+```ts
+const myKeyPairSigner = await generateKeyPairSigner();
+isKeyPairSigner(myKeyPairSigner); // ✅ true
+isKeyPairSigner({ address: address('1234..5678') }); // ❌ false
+```
+
+#### `assertIsKeyPairSigner()`
+
+A type guard that throws an error if the provided value is not a `KeyPairSigner`.
+
+```ts
+const myKeyPairSigner = await generateKeyPairSigner();
+assertIsKeyPairSigner(myKeyPairSigner); // ✅ void
+assertIsKeyPairSigner({ address: address('1234..5678') }); // ❌ Throws an error.
+```
+
+## 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`.
+
+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.
+
+```ts
+import { createNoopSigner } from '@solana/signers';
+
+const myAddress = address('1234..5678');
+const myNoopSigner = createNoopSigner(myAddress);
+// ^ MessagePartialSigner<'1234..5678'> & TransactionPartialSigner<'1234..5678'>
+```
+
+## Storing transaction signers inside instruction account metas
+
+### Types
+
+_Coming soon..._
+
+### Functions
+
+_Coming soon..._

package/dist/index.browser.cjs

@@ -0,0 +1,138 @@
+'use strict';
+
+var addresses = require('@solana/addresses');
+var keys = require('@solana/keys');
+var transactions = require('@solana/transactions');
+
+// src/keypair-signer.ts
+
+// src/message-partial-signer.ts
+function isMessagePartialSigner(value) {
+  return "signMessages" in value && typeof value.signMessages === "function";
+}
+function assertIsMessagePartialSigner(value) {
+  if (!isMessagePartialSigner(value)) {
+    throw new Error("The provided value does not implement the MessagePartialSigner interface");
+  }
+}
+
+// src/transaction-partial-signer.ts
+function isTransactionPartialSigner(value) {
+  return "signTransactions" in value && typeof value.signTransactions === "function";
+}
+function assertIsTransactionPartialSigner(value) {
+  if (!isTransactionPartialSigner(value)) {
+    throw new Error("The provided value does not implement the TransactionPartialSigner interface");
+  }
+}
+
+// src/keypair-signer.ts
+function isKeyPairSigner(value) {
+  return "keyPair" in value && typeof value.keyPair === "object" && isMessagePartialSigner(value) && isTransactionPartialSigner(value);
+}
+function assertIsKeyPairSigner(value) {
+  if (!isKeyPairSigner(value)) {
+    throw new Error("The provided value does not implement the KeyPairSigner interface");
+  }
+}
+async function createSignerFromKeyPair(keyPair) {
+  const address = await addresses.getAddressFromPublicKey(keyPair.publicKey);
+  const out = {
+    address,
+    keyPair,
+    signMessages: (messages) => Promise.all(
+      messages.map(
+        async (message) => Object.freeze({ [address]: await keys.signBytes(keyPair.privateKey, message.content) })
+      )
+    ),
+    signTransactions: (transactions$1) => Promise.all(
+      transactions$1.map(async (transaction) => {
+        const signedTransaction = await transactions.partiallySignTransaction([keyPair], transaction);
+        return Object.freeze({ [address]: signedTransaction.signatures[address] });
+      })
+    )
+  };
+  return Object.freeze(out);
+}
+async function generateKeyPairSigner() {
+  return createSignerFromKeyPair(await keys.generateKeyPair());
+}
+function isMessageModifyingSigner(value) {
+  return addresses.isAddress(value.address) && "modifyAndSignMessages" in value && typeof value.modifyAndSignMessages === "function";
+}
+function assertIsMessageModifyingSigner(value) {
+  if (!isMessageModifyingSigner(value)) {
+    throw new Error("The provided value does not implement the MessageModifyingSigner interface");
+  }
+}
+
+// src/message-signer.ts
+function isMessageSigner(value) {
+  return isMessagePartialSigner(value) || isMessageModifyingSigner(value);
+}
+function assertIsMessageSigner(value) {
+  if (!isMessageSigner(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/transaction-modifying-signer.ts
+function isTransactionModifyingSigner(value) {
+  return "modifyAndSignTransactions" in value && typeof value.modifyAndSignTransactions === "function";
+}
+function assertIsTransactionModifyingSigner(value) {
+  if (!isTransactionModifyingSigner(value)) {
+    throw new Error("The provided value does not implement the TransactionModifyingSigner interface");
+  }
+}
+
+// src/transaction-sending-signer.ts
+function isTransactionSendingSigner(value) {
+  return "signAndSendTransactions" in value && typeof value.signAndSendTransactions === "function";
+}
+function assertIsTransactionSendingSigner(value) {
+  if (!isTransactionSendingSigner(value)) {
+    throw new Error("The provided value does not implement the TransactionSendingSigner interface");
+  }
+}
+
+// src/transaction-signer.ts
+function isTransactionSigner(value) {
+  return isTransactionPartialSigner(value) || isTransactionModifyingSigner(value) || isTransactionSendingSigner(value);
+}
+function assertIsTransactionSigner(value) {
+  if (!isTransactionSigner(value)) {
+    throw new Error("The provided value does not implement any of the TransactionSigner interfaces");
+  }
+}
+
+exports.assertIsKeyPairSigner = assertIsKeyPairSigner;
+exports.assertIsMessageModifyingSigner = assertIsMessageModifyingSigner;
+exports.assertIsMessagePartialSigner = assertIsMessagePartialSigner;
+exports.assertIsMessageSigner = assertIsMessageSigner;
+exports.assertIsTransactionModifyingSigner = assertIsTransactionModifyingSigner;
+exports.assertIsTransactionPartialSigner = assertIsTransactionPartialSigner;
+exports.assertIsTransactionSendingSigner = assertIsTransactionSendingSigner;
+exports.assertIsTransactionSigner = assertIsTransactionSigner;
+exports.createSignableMessage = createSignableMessage;
+exports.createSignerFromKeyPair = createSignerFromKeyPair;
+exports.generateKeyPairSigner = generateKeyPairSigner;
+exports.isKeyPairSigner = isKeyPairSigner;
+exports.isMessageModifyingSigner = isMessageModifyingSigner;
+exports.isMessagePartialSigner = isMessagePartialSigner;
+exports.isMessageSigner = isMessageSigner;
+exports.isTransactionModifyingSigner = isTransactionModifyingSigner;
+exports.isTransactionPartialSigner = isTransactionPartialSigner;
+exports.isTransactionSendingSigner = isTransactionSendingSigner;
+exports.isTransactionSigner = isTransactionSigner;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.browser.cjs.map

package/dist/index.browser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/keypair-signer.ts","../src/message-partial-signer.ts","../src/transaction-partial-signer.ts","../src/message-modifying-signer.ts","../src/message-signer.ts","../../text-encoding-impl/src/index.browser.ts","../src/signable-message.ts","../src/transaction-modifying-signer.ts","../src/transaction-sending-signer.ts","../src/transaction-signer.ts"],"names":["TextDecoder","TextEncoder"],"mappings":"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","sourcesContent":["import { Address, getAddressFromPublicKey } from '@solana/addresses';\nimport { generateKeyPair, signBytes } from '@solana/keys';\nimport { partiallySignTransaction } from '@solana/transactions';\n\nimport { isMessagePartialSigner, MessagePartialSigner } from './message-partial-signer';\nimport { isTransactionPartialSigner, TransactionPartialSigner } from './transaction-partial-signer';\n\n/** Defines a signer capable of signing messages and transactions using a CryptoKeyPair. */\nexport type KeyPairSigner<TAddress extends string = string> = MessagePartialSigner<TAddress> &\n    TransactionPartialSigner<TAddress> & { keyPair: CryptoKeyPair };\n\n/** Checks whether the provided value implements the {@link KeyPairSigner} interface. */\nexport function isKeyPairSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): value is KeyPairSigner<TAddress> {\n    return (\n        'keyPair' in value &&\n        typeof value.keyPair === 'object' &&\n        isMessagePartialSigner(value) &&\n        isTransactionPartialSigner(value)\n    );\n}\n\n/** Asserts that the provided value implements the {@link KeyPairSigner} interface. */\nexport function assertIsKeyPairSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): asserts value is KeyPairSigner<TAddress> {\n    if (!isKeyPairSigner(value)) {\n        // TODO: Coded error.\n        throw new Error('The provided value does not implement the KeyPairSigner interface');\n    }\n}\n\n/** Creates a KeyPairSigner from the provided Crypto KeyPair. */\nexport async function createSignerFromKeyPair(keyPair: CryptoKeyPair): Promise<KeyPairSigner> {\n    const address = await getAddressFromPublicKey(keyPair.publicKey);\n    const out: KeyPairSigner = {\n        address,\n        keyPair,\n        signMessages: messages =>\n            Promise.all(\n                messages.map(async message =>\n                    Object.freeze({ [address]: await signBytes(keyPair.privateKey, message.content) })\n                )\n            ),\n        signTransactions: transactions =>\n            Promise.all(\n                transactions.map(async transaction => {\n                    const signedTransaction = await partiallySignTransaction([keyPair], transaction);\n                    return Object.freeze({ [address]: signedTransaction.signatures[address] });\n                })\n            ),\n    };\n\n    return Object.freeze(out);\n}\n\n/** Securely generates a signer capable of signing messages and transactions using a Crypto KeyPair. */\nexport async function generateKeyPairSigner(): Promise<KeyPairSigner> {\n    return createSignerFromKeyPair(await generateKeyPair());\n}\n","import { Address } from '@solana/addresses';\n\nimport { SignableMessage } from './signable-message';\nimport { SignatureDictionary } from './types';\n\n/** Defines a signer capable of signing messages. */\nexport type MessagePartialSigner<TAddress extends string = string> = Readonly<{\n    address: Address<TAddress>;\n    signMessages(messages: readonly SignableMessage[]): Promise<readonly SignatureDictionary[]>;\n}>;\n\n/** Checks whether the provided value implements the {@link MessagePartialSigner} interface. */\nexport function isMessagePartialSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): value is MessagePartialSigner<TAddress> {\n    return 'signMessages' in value && typeof value.signMessages === 'function';\n}\n\n/** Asserts that the provided value implements the {@link MessagePartialSigner} interface. */\nexport function assertIsMessagePartialSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): asserts value is MessagePartialSigner<TAddress> {\n    if (!isMessagePartialSigner(value)) {\n        // TODO: Coded error.\n        throw new Error('The provided value does not implement the MessagePartialSigner interface');\n    }\n}\n","import { Address } from '@solana/addresses';\nimport { CompilableTransaction } from '@solana/transactions';\n\nimport { SignatureDictionary } from './types';\n\n/** Defines a signer capable of signing transactions. */\nexport type TransactionPartialSigner<TAddress extends string = string> = Readonly<{\n    address: Address<TAddress>;\n    signTransactions(transactions: readonly CompilableTransaction[]): Promise<readonly SignatureDictionary[]>;\n}>;\n\n/** Checks whether the provided value implements the {@link TransactionPartialSigner} interface. */\nexport function isTransactionPartialSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): value is TransactionPartialSigner<TAddress> {\n    return 'signTransactions' in value && typeof value.signTransactions === 'function';\n}\n\n/** Asserts that the provided value implements the {@link TransactionPartialSigner} interface. */\nexport function assertIsTransactionPartialSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): asserts value is TransactionPartialSigner<TAddress> {\n    if (!isTransactionPartialSigner(value)) {\n        // TODO: Coded error.\n        throw new Error('The provided value does not implement the TransactionPartialSigner interface');\n    }\n}\n","import { Address, isAddress } from '@solana/addresses';\n\nimport { SignableMessage } from './signable-message';\n\n/** Defines a signer capable of signing messages. */\nexport type MessageModifyingSigner<TAddress extends string = string> = Readonly<{\n    address: Address<TAddress>;\n    modifyAndSignMessages(messages: readonly SignableMessage[]): Promise<readonly SignableMessage[]>;\n}>;\n\n/** Checks whether the provided value implements the {@link MessageModifyingSigner} interface. */\nexport function isMessageModifyingSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): value is MessageModifyingSigner<TAddress> {\n    return (\n        isAddress(value.address) &&\n        'modifyAndSignMessages' in value &&\n        typeof value.modifyAndSignMessages === 'function'\n    );\n}\n\n/** Asserts that the provided value implements the {@link MessageModifyingSigner} interface. */\nexport function assertIsMessageModifyingSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): asserts value is MessageModifyingSigner<TAddress> {\n    if (!isMessageModifyingSigner(value)) {\n        // TODO: Coded error.\n        throw new Error('The provided value does not implement the MessageModifyingSigner interface');\n    }\n}\n","import { Address } from '@solana/addresses';\n\nimport { isMessageModifyingSigner, MessageModifyingSigner } from './message-modifying-signer';\nimport { isMessagePartialSigner, MessagePartialSigner } from './message-partial-signer';\n\n/** Defines a signer capable of signing messages. */\nexport type MessageSigner<TAddress extends string = string> =\n    | MessagePartialSigner<TAddress>\n    | MessageModifyingSigner<TAddress>;\n\n/** Checks whether the provided value implements the {@link MessageSigner} interface. */\nexport function isMessageSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): value is MessageSigner<TAddress> {\n    return isMessagePartialSigner(value) || isMessageModifyingSigner(value);\n}\n\n/** Asserts that the provided value implements the {@link MessageSigner} interface. */\nexport function assertIsMessageSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): asserts value is MessageSigner<TAddress> {\n    if (!isMessageSigner(value)) {\n        // TODO: Coded error.\n        throw new Error('The provided value does not implement any of the MessageSigner interfaces');\n    }\n}\n","export const TextDecoder = globalThis.TextDecoder;\nexport const TextEncoder = globalThis.TextEncoder;\n","import { TextEncoder } from 'text-encoding-impl';\n\nimport { SignatureDictionary } from './types';\n\n/** Defines a message that needs signing and its current set of signatures if any. */\nexport type SignableMessage = Readonly<{\n    content: Uint8Array;\n    signatures: SignatureDictionary;\n}>;\n\n/**\n * Creates a signable message from a provided content.\n * If a string is provided, it will be UTF-8 encoded.\n */\nexport function createSignableMessage(\n    content: string | Uint8Array,\n    signatures: SignatureDictionary = {}\n): SignableMessage {\n    return Object.freeze({\n        content: typeof content === 'string' ? new TextEncoder().encode(content) : content,\n        signatures: Object.freeze({ ...signatures }),\n    });\n}\n","import { Address } from '@solana/addresses';\nimport { CompilableTransaction } from '@solana/transactions';\n\n/** Defines a signer capable of signing transactions. */\nexport type TransactionModifyingSigner<TAddress extends string = string> = Readonly<{\n    address: Address<TAddress>;\n    modifyAndSignTransactions<TTransaction extends CompilableTransaction>(\n        transactions: readonly TTransaction[]\n    ): Promise<readonly TTransaction[]>;\n}>;\n\n/** Checks whether the provided value implements the {@link TransactionModifyingSigner} interface. */\nexport function isTransactionModifyingSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): value is TransactionModifyingSigner<TAddress> {\n    return 'modifyAndSignTransactions' in value && typeof value.modifyAndSignTransactions === 'function';\n}\n\n/** Asserts that the provided value implements the {@link TransactionModifyingSigner} interface. */\nexport function assertIsTransactionModifyingSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): asserts value is TransactionModifyingSigner<TAddress> {\n    if (!isTransactionModifyingSigner(value)) {\n        // TODO: Coded error.\n        throw new Error('The provided value does not implement the TransactionModifyingSigner interface');\n    }\n}\n","import { Address } from '@solana/addresses';\nimport { SignatureBytes } from '@solana/keys';\nimport { CompilableTransaction } from '@solana/transactions';\n\n/** Defines a signer capable of signing and sending transactions simultaneously. */\nexport type TransactionSendingSigner<TAddress extends string = string> = Readonly<{\n    address: Address<TAddress>;\n    signAndSendTransactions(transactions: readonly CompilableTransaction[]): Promise<readonly SignatureBytes[]>;\n}>;\n\n/** Checks whether the provided value implements the {@link TransactionSendingSigner} interface. */\nexport function isTransactionSendingSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): value is TransactionSendingSigner<TAddress> {\n    return 'signAndSendTransactions' in value && typeof value.signAndSendTransactions === 'function';\n}\n\n/** Asserts that the provided value implements the {@link TransactionSendingSigner} interface. */\nexport function assertIsTransactionSendingSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): asserts value is TransactionSendingSigner<TAddress> {\n    if (!isTransactionSendingSigner(value)) {\n        // TODO: Coded error.\n        throw new Error('The provided value does not implement the TransactionSendingSigner interface');\n    }\n}\n","import { Address } from '@solana/addresses';\n\nimport { isTransactionModifyingSigner, TransactionModifyingSigner } from './transaction-modifying-signer';\nimport { isTransactionPartialSigner, TransactionPartialSigner } from './transaction-partial-signer';\nimport { isTransactionSendingSigner, TransactionSendingSigner } from './transaction-sending-signer';\n\n/** Defines a signer capable of signing transactions. */\nexport type TransactionSigner<TAddress extends string = string> =\n    | TransactionPartialSigner<TAddress>\n    | TransactionModifyingSigner<TAddress>\n    | TransactionSendingSigner<TAddress>;\n\n/** Checks whether the provided value implements the {@link TransactionSigner} interface. */\nexport function isTransactionSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): value is TransactionSigner<TAddress> {\n    return (\n        isTransactionPartialSigner(value) || isTransactionModifyingSigner(value) || isTransactionSendingSigner(value)\n    );\n}\n\n/** Asserts that the provided value implements the {@link TransactionSigner} interface. */\nexport function assertIsTransactionSigner<TAddress extends string>(value: {\n    address: Address<TAddress>;\n    [key: string]: unknown;\n}): asserts value is TransactionSigner<TAddress> {\n    if (!isTransactionSigner(value)) {\n        // TODO: Coded error.\n        throw new Error('The provided value does not implement any of the TransactionSigner interfaces');\n    }\n}\n"]}