@solana/signers 5.2.0-canary-20260107104556 → 5.2.0-canary-20260107104941

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/dist/index.browser.cjs.map +1 -1
  2. package/dist/index.browser.mjs.map +1 -1
  3. package/dist/index.native.mjs.map +1 -1
  4. package/dist/index.node.cjs.map +1 -1
  5. package/dist/index.node.mjs.map +1 -1
  6. package/dist/types/fee-payer-signer.d.ts +10 -5
  7. package/dist/types/fee-payer-signer.d.ts.map +1 -1
  8. package/package.json +10 -10
package/dist/index.browser.cjs.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"sources":["../src/deduplicate-signers.ts","../src/transaction-modifying-signer.ts","../src/transaction-partial-signer.ts","../src/transaction-sending-signer.ts","../src/transaction-signer.ts","../src/account-signer-meta.ts","../src/add-signers.ts","../src/fee-payer-signer.ts","../src/message-partial-signer.ts","../src/keypair-signer.ts","../src/message-modifying-signer.ts","../src/message-signer.ts","../src/noop-signer.ts","../src/offchain-message-signer.ts","../src/sign-offchain-message.ts","../src/transaction-with-single-sending-signer.ts","../src/sign-transaction.ts","../../text-encoding-impl/src/index.browser.ts","../src/signable-message.ts"],"names":["SolanaError","SOLANA_ERROR__SIGNER__ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS","SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER","SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER","SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER","SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER","isSignerRole","SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_PARTIAL_SIGNER","SOLANA_ERROR__SIGNER__EXPECTED_KEY_PAIR_SIGNER","getAddressFromPublicKey","signBytes","transactions","partiallySignTransaction","generateKeyPair","createKeyPairFromBytes","createKeyPairFromPrivateKeyBytes","isAddress","SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_MODIFYING_SIGNER","SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_SIGNER","assertIsFullySignedOffchainMessageEnvelope","compileOffchainMessageEnvelope","offchainMessageEnvelope","SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING","SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS","assertIsFullySignedTransaction","compileTransaction","transaction","TextEncoder"],"mappings":"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","file":"index.browser.cjs","sourcesContent":["import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS, SolanaError } from '@solana/errors';\n\nimport { MessageSigner } from './message-signer';\nimport { TransactionSigner } from './transaction-signer';\n\n/**\n * Removes all duplicated {@link MessageSigner | MessageSigners} and\n * {@link TransactionSigner | TransactionSigners} from a provided array\n * by comparing their {@link Address | addresses}.\n *\n * @internal\n */\nexport function deduplicateSigners<TSigner extends MessageSigner | TransactionSigner>(\n signers: readonly TSigner[],\n): readonly TSigner[] {\n const deduplicated: Record<Address, TSigner> = {};\n signers.forEach(signer => {\n if (!deduplicated[signer.address]) {\n deduplicated[signer.address] = signer;\n } else if (deduplicated[signer.address] !== signer) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS, {\n address: signer.address,\n });\n }\n });\n return Object.values(deduplicated);\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER, SolanaError } from '@solana/errors';\nimport { Transaction, TransactionWithinSizeLimit, TransactionWithLifetime } from '@solana/transactions';\n\nimport { BaseTransactionSignerConfig } from './types';\n\n/**\n * The configuration to optionally provide when calling the\n * {@link TransactionModifyingSigner#modifyAndSignTransactions | modifyAndSignTransactions} method.\n *\n * @see {@link BaseTransactionSignerConfig}\n */\nexport type TransactionModifyingSignerConfig = BaseTransactionSignerConfig;\n\n/**\n * A signer interface that potentially modifies the provided {@link Transaction | Transactions}\n * before signing them.\n *\n * For instance, this enables wallets to inject additional instructions into the\n * transaction before signing them. For each transaction, instead of returning a\n * {@link SignatureDictionary}, its\n * {@link TransactionModifyingSigner#modifyAndSignTransactions | modifyAndSignTransactions} function\n * returns an updated {@link Transaction} with a potentially modified set of instructions and\n * signature dictionary. The returned transaction must be within the transaction size limit,\n * and include a `lifetimeConstraint`.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * const signer: TransactionModifyingSigner<'1234..5678'> = {\n * address: address('1234..5678'),\n * modifyAndSignTransactions: async (\n * transactions: Transaction[]\n * ): Promise<(Transaction & TransactionWithinSizeLimit & TransactionWithLifetime)[]> => {\n * // My custom signing logic.\n * },\n * };\n * ```\n *\n * @remarks\n * Here are the main characteristics of this signer interface:\n *\n * - **Sequential**. Contrary to partial signers, these cannot be executed in\n * parallel as each call can modify the provided transactions.\n * - **First signers**. For a given transaction, a modifying signer must always\n * be used before a partial signer as the former will likely modify the\n * transaction and thus impact the outcome of the latter.\n * - **Potential conflicts**. If more than one modifying signer is provided,\n * the second signer may invalidate the signature of the first one. However,\n * modifying signers may decide not to modify a transaction based on the\n * existence of signatures for that transaction.\n *\n * @see {@link isTransactionModifyingSigner}\n * @see {@link assertIsTransactionModifyingSigner}\n */\nexport type TransactionModifyingSigner<TAddress extends string = string> = Readonly<{\n address: Address<TAddress>;\n modifyAndSignTransactions(\n transactions: readonly (Transaction | (Transaction & TransactionWithLifetime))[],\n config?: TransactionModifyingSignerConfig,\n ): Promise<readonly (Transaction & TransactionWithinSizeLimit & TransactionWithLifetime)[]>;\n}>;\n\n/**\n * Checks whether the provided value implements the {@link TransactionModifyingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isTransactionModifyingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isTransactionModifyingSigner({ address, modifyAndSignTransactions: async () => {} }); // true\n * isTransactionModifyingSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsTransactionModifyingSigner}\n */\nexport function isTransactionModifyingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is TransactionModifyingSigner<TAddress> {\n return 'modifyAndSignTransactions' in value && typeof value.modifyAndSignTransactions === 'function';\n}\n\n/**\n * Asserts that the provided value implements the {@link TransactionModifyingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsTransactionModifyingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsTransactionModifyingSigner({ address, modifyAndSignTransactions: async () => {} }); // void\n * assertIsTransactionModifyingSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isTransactionModifyingSigner}\n */\nexport function assertIsTransactionModifyingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is TransactionModifyingSigner<TAddress> {\n if (!isTransactionModifyingSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER, SolanaError } from '@solana/errors';\nimport { Transaction, TransactionWithinSizeLimit, TransactionWithLifetime } from '@solana/transactions';\n\nimport { BaseTransactionSignerConfig, SignatureDictionary } from './types';\n\n/**\n * The configuration to optionally provide when calling the\n * {@link TransactionPartialSigner#signTransactions | signTransactions} method.\n *\n * @see {@link BaseTransactionSignerConfig}\n */\nexport type TransactionPartialSignerConfig = BaseTransactionSignerConfig;\n\n/**\n * A signer interface that signs an array of {@link Transaction | Transactions}\n * without modifying their content. It defines a\n * {@link TransactionPartialSigner#signTransactions | signTransactions}\n * function that returns a {@link SignatureDictionary} for each provided transaction.\n *\n * Such signature dictionaries are expected to be merged with the existing ones if any.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * const signer: TransactionPartialSigner<'1234..5678'> = {\n * address: address('1234..5678'),\n * signTransactions: async (\n * transactions: Transaction[]\n * ): Promise<SignatureDictionary[]> => {\n * // My custom signing logic.\n * },\n * };\n * ```\n *\n * @remarks\n * Here are the main characteristics of this signer interface:\n *\n * - **Parallel**. It returns a signature dictionary for each provided\n * transaction without modifying them, making it possible for multiple\n * partial signers to sign the same transaction in parallel.\n * - **Flexible order**. The order in which we use these signers for\n * a given transaction doesn’t matter.\n *\n * @see {@link isTransactionPartialSigner}\n * @see {@link assertIsTransactionPartialSigner}\n */\nexport type TransactionPartialSigner<TAddress extends string = string> = Readonly<{\n address: Address<TAddress>;\n signTransactions(\n transactions: readonly (Transaction & TransactionWithinSizeLimit & TransactionWithLifetime)[],\n config?: TransactionPartialSignerConfig,\n ): Promise<readonly SignatureDictionary[]>;\n}>;\n\n/**\n * Checks whether the provided value implements the {@link TransactionPartialSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isTransactionPartialSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isTransactionPartialSigner({ address, signTransactions: async () => {} }); // true\n * isTransactionPartialSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsTransactionPartialSigner}\n */\nexport function isTransactionPartialSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is TransactionPartialSigner<TAddress> {\n return 'signTransactions' in value && typeof value.signTransactions === 'function';\n}\n\n/**\n * Asserts that the provided value implements the {@link TransactionPartialSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsTransactionPartialSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsTransactionPartialSigner({ address, signTransactions: async () => {} }); // void\n * assertIsTransactionPartialSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isTransactionPartialSigner}\n */\nexport function assertIsTransactionPartialSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is TransactionPartialSigner<TAddress> {\n if (!isTransactionPartialSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER, SolanaError } from '@solana/errors';\nimport { SignatureBytes } from '@solana/keys';\nimport { Transaction, TransactionWithLifetime } from '@solana/transactions';\n\nimport { BaseTransactionSignerConfig } from './types';\n\n/**\n * The configuration to optionally provide when calling the\n * {@link TransactionSendingSignerConfig#signAndSendTransactions | signAndSendTransactions} method.\n *\n * @see {@link BaseTransactionSignerConfig}\n */\nexport type TransactionSendingSignerConfig = BaseTransactionSignerConfig;\n\n/**\n * A signer interface that signs one or multiple transactions\n * before sending them immediately to the blockchain.\n *\n * It defines a {@link TransactionSendingSignerConfig#signAndSendTransactions | signAndSendTransactions}\n * function that returns the transaction signature (i.e. its identifier) for each provided\n * {@link Transaction}.\n *\n * This interface is required for PDA wallets and other types of wallets that don't provide an\n * interface for signing transactions without sending them.\n *\n * Note that it is also possible for such signers to modify the provided transactions\n * before signing and sending them. This enables use cases where the modified transactions\n * cannot be shared with the app and thus must be sent directly.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * const myTransactionSendingSigner: TransactionSendingSigner<'1234..5678'> = {\n * address: address('1234..5678'),\n * signAndSendTransactions: async (transactions: Transaction[]): Promise<SignatureBytes[]> => {\n * // My custom signing logic.\n * },\n * };\n * ```\n *\n * @remarks\n * Here are the main characteristics of this signer interface:\n *\n * - **Single signer**. Since this signer also sends the provided transactions,\n * we can only use a single {@link TransactionSendingSigner} for a given set of transactions.\n * - **Last signer**. Trivially, that signer must also be the last one used.\n * - **Potential conflicts**. Since signers may decide to modify the given\n * transactions before sending them, they may invalidate previous signatures.\n * However, signers may decide not to modify a transaction based\n * on the existence of signatures for that transaction.\n * - **Potential confirmation**. Whilst this is not required by this interface,\n * it is also worth noting that most wallets will also wait for the transaction\n * to be confirmed (typically with a `confirmed` commitment)\n * before notifying the app that they are done.\n *\n * @see {@link isTransactionSendingSigner}\n * @see {@link assertIsTransactionSendingSigner}\n */\nexport type TransactionSendingSigner<TAddress extends string = string> = Readonly<{\n address: Address<TAddress>;\n signAndSendTransactions(\n transactions: readonly (Transaction | (Transaction & TransactionWithLifetime))[],\n config?: TransactionSendingSignerConfig,\n ): Promise<readonly SignatureBytes[]>;\n}>;\n\n/**\n * Checks whether the provided value implements the {@link TransactionSendingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isTransactionSendingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isTransactionSendingSigner({ address, signAndSendTransactions: async () => {} }); // true\n * isTransactionSendingSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsTransactionSendingSigner}\n */\nexport function isTransactionSendingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is TransactionSendingSigner<TAddress> {\n return 'signAndSendTransactions' in value && typeof value.signAndSendTransactions === 'function';\n}\n\n/**\n * Asserts that the provided value implements the {@link TransactionSendingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsTransactionSendingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsTransactionSendingSigner({ address, signAndSendTransactions: async () => {} }); // void\n * assertIsTransactionSendingSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isTransactionSendingSigner}\n */\nexport function assertIsTransactionSendingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is TransactionSendingSigner<TAddress> {\n if (!isTransactionSendingSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER, SolanaError } from '@solana/errors';\n\nimport { isTransactionModifyingSigner, TransactionModifyingSigner } from './transaction-modifying-signer';\nimport { isTransactionPartialSigner, TransactionPartialSigner } from './transaction-partial-signer';\nimport { isTransactionSendingSigner, TransactionSendingSigner } from './transaction-sending-signer';\n\n/**\n * Defines a signer capable of signing transactions.\n *\n * @see {@link TransactionModifyingSigner} For signers that can modify transactions before signing them.\n * @see {@link TransactionPartialSigner} For signers that can be used in parallel.\n * @see {@link TransactionSendingSigner} For signers that send transactions after signing them.\n * @see {@link isTransactionSigner}\n * @see {@link assertIsTransactionSigner}\n */\nexport type TransactionSigner<TAddress extends string = string> =\n | TransactionModifyingSigner<TAddress>\n | TransactionPartialSigner<TAddress>\n | TransactionSendingSigner<TAddress>;\n\n/**\n * Checks whether the provided value implements the {@link TransactionSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isTransactionSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isTransactionSigner({ address, signTransactions: async () => {} }); // true\n * isTransactionSigner({ address, modifyAndSignTransactions: async () => {} }); // true\n * isTransactionSigner({ address, signAndSendTransactions: async () => {} }); // true\n * isTransactionSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsTransactionSigner}\n */\nexport function isTransactionSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is TransactionSigner<TAddress> {\n return (\n isTransactionPartialSigner(value) || isTransactionModifyingSigner(value) || isTransactionSendingSigner(value)\n );\n}\n\n/**\n * Asserts that the provided value implements the {@link TransactionSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsTransactionSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsTransactionSigner({ address, signTransactions: async () => {} }); // void\n * assertIsTransactionSigner({ address, modifyAndSignTransactions: async () => {} }); // void\n * assertIsTransactionSigner({ address, signAndSendTransactions: async () => {} }); // void\n * assertIsTransactionSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isTransactionSigner}\n */\nexport function assertIsTransactionSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is TransactionSigner<TAddress> {\n if (!isTransactionSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { AccountLookupMeta, AccountMeta, AccountRole, Instruction } from '@solana/instructions';\nimport {\n BaseTransactionMessage,\n TransactionMessageWithFeePayer,\n TransactionVersion,\n} from '@solana/transaction-messages';\n\nimport { deduplicateSigners } from './deduplicate-signers';\nimport { TransactionMessageWithFeePayerSigner } from './fee-payer-signer';\nimport { isTransactionSigner, TransactionSigner } from './transaction-signer';\n\n/**\n * An extension of the {@link AccountMeta} type that allows us to store {@link TransactionSigner | TransactionSigners} inside it.\n *\n * Note that, because this type represents a signer, it must use one the following two roles:\n * - {@link AccountRole.READONLY_SIGNER}\n * - {@link AccountRole.WRITABLE_SIGNER}\n *\n * @typeParam TAddress - Supply a string literal to define an account having a particular address.\n * @typeParam TSigner - Optionally provide a narrower type for the {@link TransactionSigner} to use within the account meta.\n *\n * @interface\n *\n * @example\n * ```ts\n * import { AccountRole } from '@solana/instructions';\n * import { generateKeyPairSigner, AccountSignerMeta } from '@solana/signers';\n *\n * const signer = await generateKeyPairSigner();\n * const account: AccountSignerMeta = {\n * address: signer.address,\n * role: AccountRole.READONLY_SIGNER,\n * signer,\n * };\n * ```\n */\nexport interface AccountSignerMeta<\n TAddress extends string = string,\n TSigner extends TransactionSigner<TAddress> = TransactionSigner<TAddress>,\n> extends AccountMeta<TAddress> {\n readonly role: AccountRole.READONLY_SIGNER | AccountRole.WRITABLE_SIGNER;\n readonly signer: TSigner;\n}\n\n/**\n * A union type that supports base account metas as well as {@link AccountSignerMeta | signer account metas}.\n */\ntype AccountMetaWithSigner<TSigner extends TransactionSigner = TransactionSigner> =\n | AccountLookupMeta\n | AccountMeta\n | AccountSignerMeta<string, TSigner>;\n\n/**\n * Composable type that allows {@link AccountSignerMeta | AccountSignerMetas} to be used inside the instruction's `accounts` array\n *\n * @typeParam TSigner - Optionally provide a narrower type for {@link TransactionSigner | TransactionSigners}.\n * @typeParam TAccounts - Optionally provide a narrower type for the account metas.\n *\n * @interface\n *\n * @example\n * ```ts\n * import { AccountRole, Instruction } from '@solana/instructions';\n * import { generateKeyPairSigner, InstructionWithSigners } from '@solana/signers';\n *\n * const [authority, buffer] = await Promise.all([\n * generateKeyPairSigner(),\n * generateKeyPairSigner(),\n * ]);\n * const instruction: Instruction & InstructionWithSigners = {\n * programAddress: address('1234..5678'),\n * accounts: [\n * // The authority is a signer account.\n * {\n * address: authority.address,\n * role: AccountRole.READONLY_SIGNER,\n * signer: authority,\n * },\n * // The buffer is a writable account.\n * { address: buffer.address, role: AccountRole.WRITABLE },\n * ],\n * };\n * ```\n */\nexport type InstructionWithSigners<\n TSigner extends TransactionSigner = TransactionSigner,\n TAccounts extends readonly AccountMetaWithSigner<TSigner>[] = readonly AccountMetaWithSigner<TSigner>[],\n> = Pick<Instruction<string, TAccounts>, 'accounts'>;\n\n/**\n * A {@link BaseTransactionMessage} type extension that accept {@link TransactionSigner | TransactionSigners}.\n *\n * Namely, it allows:\n * - a {@link TransactionSigner} to be used as the fee payer and\n * - {@link InstructionWithSigners} to be used in its instructions.\n *\n *\n * @typeParam TAddress - Supply a string literal to define an account having a particular address.\n * @typeParam TSigner - Optionally provide a narrower type for {@link TransactionSigner | TransactionSigners}.\n * @typeParam TAccounts - Optionally provide a narrower type for the account metas.\n *\n * @example\n * ```ts\n * import { Instruction } from '@solana/instructions';\n * import { BaseTransactionMessage } from '@solana/transaction-messages';\n * import { generateKeyPairSigner, InstructionWithSigners, TransactionMessageWithSigners } from '@solana/signers';\n *\n * const signer = await generateKeyPairSigner();\n * const firstInstruction: Instruction = { ... };\n * const secondInstruction: InstructionWithSigners = { ... };\n * const transactionMessage: BaseTransactionMessage & TransactionMessageWithSigners = {\n * feePayer: signer,\n * instructions: [firstInstruction, secondInstruction],\n * }\n * ```\n */\nexport type TransactionMessageWithSigners<\n TAddress extends string = string,\n TSigner extends TransactionSigner<TAddress> = TransactionSigner<TAddress>,\n TAccounts extends readonly AccountMetaWithSigner<TSigner>[] = readonly AccountMetaWithSigner<TSigner>[],\n> = Partial<TransactionMessageWithFeePayer<TAddress> | TransactionMessageWithFeePayerSigner<TAddress, TSigner>> &\n Pick<\n BaseTransactionMessage<TransactionVersion, Instruction & InstructionWithSigners<TSigner, TAccounts>>,\n 'instructions'\n >;\n\n/**\n * Extracts and deduplicates all {@link TransactionSigner | TransactionSigners} stored\n * inside the account metas of an {@link InstructionWithSigners | instruction}.\n *\n * Any extracted signers that share the same {@link Address} will be de-duplicated.\n *\n * @typeParam TSigner - Optionally provide a narrower type for {@link TransactionSigner | TransactionSigners}.\n *\n * @example\n * ```ts\n * import { InstructionWithSigners, getSignersFromInstruction } from '@solana/signers';\n *\n * const signerA = { address: address('1111..1111'), signTransactions: async () => {} };\n * const signerB = { address: address('2222..2222'), signTransactions: async () => {} };\n * const instructionWithSigners: InstructionWithSigners = {\n * accounts: [\n * { address: signerA.address, signer: signerA, ... },\n * { address: signerB.address, signer: signerB, ... },\n * { address: signerA.address, signer: signerA, ... },\n * ],\n * };\n *\n * const instructionSigners = getSignersFromInstruction(instructionWithSigners);\n * // ^ [signerA, signerB]\n * ```\n */\nexport function getSignersFromInstruction<TSigner extends TransactionSigner = TransactionSigner>(\n instruction: InstructionWithSigners<TSigner>,\n): readonly TSigner[] {\n return deduplicateSigners(\n (instruction.accounts ?? []).flatMap(account => ('signer' in account ? account.signer : [])),\n );\n}\n\n/**\n * Extracts and deduplicates all {@link TransactionSigner | TransactionSigners} stored\n * inside a given {@link TransactionMessageWithSigners | transaction message}.\n *\n * This includes any {@link TransactionSigner | TransactionSigners} stored\n * as the fee payer or in the instructions of the transaction message.\n *\n * Any extracted signers that share the same {@link Address} will be de-duplicated.\n *\n * @typeParam TAddress - Supply a string literal to define an account having a particular address.\n * @typeParam TSigner - Optionally provide a narrower type for {@link TransactionSigner | TransactionSigners}.\n * @typeParam TTransactionMessage - The inferred type of the transaction message provided.\n *\n * @example\n * ```ts\n * import { Instruction } from '@solana/instructions';\n * import { InstructionWithSigners, TransactionMessageWithSigners, getSignersFromTransactionMessage } from '@solana/signers';\n *\n * const signerA = { address: address('1111..1111'), signTransactions: async () => {} };\n * const signerB = { address: address('2222..2222'), signTransactions: async () => {} };\n * const firstInstruction: Instruction & InstructionWithSigners = {\n * programAddress: address('1234..5678'),\n * accounts: [{ address: signerA.address, signer: signerA, ... }],\n * };\n * const secondInstruction: Instruction & InstructionWithSigners = {\n * programAddress: address('1234..5678'),\n * accounts: [{ address: signerB.address, signer: signerB, ... }],\n * };\n * const transactionMessage: TransactionMessageWithSigners = {\n * feePayer: signerA,\n * instructions: [firstInstruction, secondInstruction],\n * }\n *\n * const transactionSigners = getSignersFromTransactionMessage(transactionMessage);\n * // ^ [signerA, signerB]\n * ```\n */\nexport function getSignersFromTransactionMessage<\n TAddress extends string = string,\n TSigner extends TransactionSigner<TAddress> = TransactionSigner<TAddress>,\n TTransactionMessage extends TransactionMessageWithSigners<TAddress, TSigner> = TransactionMessageWithSigners<\n TAddress,\n TSigner\n >,\n>(transaction: TTransactionMessage): readonly TSigner[] {\n return deduplicateSigners([\n ...(transaction.feePayer && isTransactionSigner(transaction.feePayer) ? [transaction.feePayer as TSigner] : []),\n ...transaction.instructions.flatMap(getSignersFromInstruction),\n ]);\n}\n","import { Address } from '@solana/addresses';\nimport { Instruction, isSignerRole } from '@solana/instructions';\nimport { BaseTransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\n\nimport { AccountSignerMeta, InstructionWithSigners, TransactionMessageWithSigners } from './account-signer-meta';\nimport { deduplicateSigners } from './deduplicate-signers';\nimport { isTransactionSigner, TransactionSigner } from './transaction-signer';\n\n/**\n * Attaches the provided {@link TransactionSigner | TransactionSigners} to the\n * account metas of an instruction when applicable.\n *\n * For an account meta to match a provided signer it:\n * - Must have a signer role ({@link AccountRole.READONLY_SIGNER} or {@link AccountRole.WRITABLE_SIGNER}).\n * - Must have the same address as the provided signer.\n * - Must not have an attached signer already.\n *\n * @typeParam TInstruction - The inferred type of the instruction provided.\n *\n * @example\n * ```ts\n * import { AccountRole, Instruction } from '@solana/instructions';\n * import { addSignersToInstruction, TransactionSigner } from '@solana/signers';\n *\n * const instruction: Instruction = {\n * accounts: [\n * { address: '1111' as Address, role: AccountRole.READONLY_SIGNER },\n * { address: '2222' as Address, role: AccountRole.WRITABLE_SIGNER },\n * ],\n * // ...\n * };\n *\n * const signerA: TransactionSigner<'1111'>;\n * const signerB: TransactionSigner<'2222'>;\n * const instructionWithSigners = addSignersToInstruction(\n * [signerA, signerB],\n * instruction\n * );\n *\n * // instructionWithSigners.accounts[0].signer === signerA\n * // instructionWithSigners.accounts[1].signer === signerB\n * ```\n */\nexport function addSignersToInstruction<TInstruction extends Instruction>(\n signers: TransactionSigner[],\n instruction: TInstruction | (InstructionWithSigners & TInstruction),\n): InstructionWithSigners & TInstruction {\n if (!instruction.accounts || instruction.accounts.length === 0) {\n return instruction as InstructionWithSigners & TInstruction;\n }\n\n const signerByAddress = new Map(deduplicateSigners(signers).map(signer => [signer.address, signer]));\n return Object.freeze({\n ...instruction,\n accounts: instruction.accounts.map(account => {\n const signer = signerByAddress.get(account.address);\n if (!isSignerRole(account.role) || 'signer' in account || !signer) {\n return account;\n }\n return Object.freeze({ ...account, signer } as AccountSignerMeta);\n }),\n });\n}\n\n/**\n * Attaches the provided {@link TransactionSigner | TransactionSigners} to the\n * account metas of all instructions inside a transaction message and/or\n * the transaction message fee payer, when applicable.\n *\n * For an account meta to match a provided signer it:\n * - Must have a signer role ({@link AccountRole.READONLY_SIGNER} or {@link AccountRole.WRITABLE_SIGNER}).\n * - Must have the same address as the provided signer.\n * - Must not have an attached signer already.\n *\n * @typeParam TTransactionMessage - The inferred type of the transaction message provided.\n *\n * @example\n * ```ts\n * import { AccountRole, Instruction } from '@solana/instructions';\n * import { BaseTransactionMessage } from '@solana/transaction-messages';\n * import { addSignersToTransactionMessage, TransactionSigner } from '@solana/signers';\n *\n * const instructionA: Instruction = {\n * accounts: [{ address: '1111' as Address, role: AccountRole.READONLY_SIGNER }],\n * // ...\n * };\n * const instructionB: Instruction = {\n * accounts: [{ address: '2222' as Address, role: AccountRole.WRITABLE_SIGNER }],\n * // ...\n * };\n * const transactionMessage: BaseTransactionMessage = {\n * instructions: [instructionA, instructionB],\n * // ...\n * }\n *\n * const signerA: TransactionSigner<'1111'>;\n * const signerB: TransactionSigner<'2222'>;\n * const transactionMessageWithSigners = addSignersToTransactionMessage(\n * [signerA, signerB],\n * transactionMessage\n * );\n *\n * // transactionMessageWithSigners.instructions[0].accounts[0].signer === signerA\n * // transactionMessageWithSigners.instructions[1].accounts[0].signer === signerB\n * ```\n */\nexport function addSignersToTransactionMessage<TTransactionMessage extends BaseTransactionMessage>(\n signers: TransactionSigner[],\n transactionMessage: TTransactionMessage | (TransactionMessageWithSigners & TTransactionMessage),\n): TransactionMessageWithSigners & TTransactionMessage {\n const feePayerSigner = hasAddressOnlyFeePayer(transactionMessage)\n ? signers.find(signer => signer.address === transactionMessage.feePayer.address)\n : undefined;\n\n if (!feePayerSigner && transactionMessage.instructions.length === 0) {\n return transactionMessage as TransactionMessageWithSigners & TTransactionMessage;\n }\n\n return Object.freeze({\n ...transactionMessage,\n ...(feePayerSigner ? { feePayer: feePayerSigner } : null),\n instructions: transactionMessage.instructions.map(instruction => addSignersToInstruction(signers, instruction)),\n });\n}\n\nfunction hasAddressOnlyFeePayer(\n message: BaseTransactionMessage & Partial<TransactionMessageWithFeePayer>,\n): message is BaseTransactionMessage & { feePayer: { address: Address } } {\n return (\n !!message &&\n 'feePayer' in message &&\n !!message.feePayer &&\n typeof message.feePayer.address === 'string' &&\n !isTransactionSigner(message.feePayer)\n );\n}\n","import { BaseTransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\n\nimport { TransactionSigner } from './transaction-signer';\n\n/**\n * Alternative to {@link TransactionMessageWithFeePayer} that uses a {@link TransactionSigner} for the fee payer.\n *\n * @typeParam TAddress - Supply a string literal to define a fee payer having a particular address.\n * @typeParam TSigner - Optionally provide a narrower type for the {@link TransactionSigner}.\n *\n * @example\n * ```ts\n * import { BaseTransactionMessage } from '@solana/transaction-messages';\n * import { generateKeyPairSigner, TransactionMessageWithFeePayerSigner } from '@solana/signers';\n *\n * const transactionMessage: BaseTransactionMessage & TransactionMessageWithFeePayerSigner = {\n * feePayer: await generateKeyPairSigner(),\n * instructions: [],\n * version: 0,\n * };\n * ```\n */\nexport interface TransactionMessageWithFeePayerSigner<\n TAddress extends string = string,\n TSigner extends TransactionSigner<TAddress> = TransactionSigner<TAddress>,\n> {\n readonly feePayer: TSigner;\n}\n\n/**\n * Sets the fee payer of a {@link BaseTransactionMessage | transaction message}\n * using a {@link TransactionSigner}.\n *\n * @typeParam TFeePayerAddress - Supply a string literal to define a fee payer having a particular address.\n * @typeParam TTransactionMessage - The inferred type of the transaction message provided.\n *\n * @example\n * ```ts\n * import { pipe } from '@solana/functional';\n * import { generateKeyPairSigner, setTransactionMessageFeePayerSigner } from '@solana/signers';\n * import { createTransactionMessage } from '@solana/transaction-messages';\n *\n * const feePayer = await generateKeyPairSigner();\n * const transactionMessage = pipe(\n * createTransactionMessage({ version: 0 }),\n * message => setTransactionMessageFeePayerSigner(signer, message),\n * );\n * ```\n */\nexport function setTransactionMessageFeePayerSigner<\n TFeePayerAddress extends string,\n TTransactionMessage extends BaseTransactionMessage &\n Partial<TransactionMessageWithFeePayer | TransactionMessageWithFeePayerSigner>,\n>(\n feePayer: TransactionSigner<TFeePayerAddress>,\n transactionMessage: TTransactionMessage,\n): Omit<TTransactionMessage, 'feePayer'> & TransactionMessageWithFeePayerSigner<TFeePayerAddress> {\n Object.freeze(feePayer);\n const out = { ...transactionMessage, feePayer };\n Object.freeze(out);\n return out;\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_PARTIAL_SIGNER, SolanaError } from '@solana/errors';\n\nimport { SignableMessage } from './signable-message';\nimport { BaseSignerConfig, SignatureDictionary } from './types';\n\n/**\n * The configuration to optionally provide when calling the\n * {@link MessagePartialSigner#signMessages | signMessages} method.\n *\n * @see {@link BaseSignerConfig}\n */\nexport type MessagePartialSignerConfig = BaseSignerConfig;\n\n/**\n * A signer interface that signs an array of {@link SignableMessage | SignableMessages}\n * without modifying their content.\n *\n * It defines a {@link MessagePartialSigner#signMessages | signMessages} function\n * that returns a {@link SignatureDictionary} for each provided message.\n * Such signature dictionaries are expected to be merged with the existing ones if any.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * const signer: MessagePartialSigner<'1234..5678'> = {\n * address: address('1234..5678'),\n * signMessages: async (\n * messages: SignableMessage[]\n * ): Promise<SignatureDictionary[]> => {\n * // My custom signing logic.\n * },\n * };\n * ```\n *\n * @remarks\n * Here are the main characteristics of this signer interface:\n *\n * - **Parallel**. When multiple signers sign the same message, we can\n * perform this operation in parallel to obtain all their signatures.\n * - **Flexible order**. The order in which we use these signers\n * for a given message doesn’t matter.\n *\n * @see {@link SignableMessage}\n * @see {@link createSignableMessage}\n * @see {@link isMessagePartialSigner}\n * @see {@link assertIsMessagePartialSigner}\n */\nexport type MessagePartialSigner<TAddress extends string = string> = Readonly<{\n address: Address<TAddress>;\n signMessages(\n messages: readonly SignableMessage[],\n config?: MessagePartialSignerConfig,\n ): Promise<readonly SignatureDictionary[]>;\n}>;\n\n/**\n * Checks whether the provided value implements the {@link MessagePartialSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isMessagePartialSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isMessagePartialSigner({ address, signMessages: async () => {} }); // true\n * isMessagePartialSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsMessagePartialSigner}\n */\nexport function isMessagePartialSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is MessagePartialSigner<TAddress> {\n return 'signMessages' in value && typeof value.signMessages === 'function';\n}\n\n/**\n * Asserts that the provided value implements the {@link MessagePartialSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsMessagePartialSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsMessagePartialSigner({ address, signMessages: async () => {} }); // void\n * assertIsMessagePartialSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isMessagePartialSigner}\n */\nexport function assertIsMessagePartialSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is MessagePartialSigner<TAddress> {\n if (!isMessagePartialSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_PARTIAL_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address, getAddressFromPublicKey } from '@solana/addresses';\nimport { ReadonlyUint8Array } from '@solana/codecs-core';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_KEY_PAIR_SIGNER, SolanaError } from '@solana/errors';\nimport { createKeyPairFromBytes, createKeyPairFromPrivateKeyBytes, 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/**\n * Defines a signer that uses a {@link CryptoKeyPair} to sign messages and transactions.\n *\n * It implements both the {@link MessagePartialSigner} and {@link TransactionPartialSigner}\n * interfaces and keeps track of the {@link CryptoKeyPair} instance used\n * to sign messages and transactions.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * import { generateKeyPairSigner } from '@solana/signers';\n *\n * const signer = generateKeyPairSigner();\n * signer.address; // Address;\n * signer.keyPair; // CryptoKeyPair;\n * const [messageSignatures] = await signer.signMessages([message]);\n * const [transactionSignatures] = await signer.signTransactions([transaction]);\n * ```\n *\n * @see {@link generateKeyPairSigner}\n * @see {@link createSignerFromKeyPair}\n * @see {@link createKeyPairSignerFromBytes}\n * @see {@link createKeyPairSignerFromPrivateKeyBytes}\n * @see {@link isKeyPairSigner}\n * @see {@link assertIsKeyPairSigner}\n */\nexport type KeyPairSigner<TAddress extends string = string> = MessagePartialSigner<TAddress> &\n TransactionPartialSigner<TAddress> & { keyPair: CryptoKeyPair };\n\n/**\n * Checks whether the provided value implements the {@link KeyPairSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { generateKeyPairSigner, isKeyPairSigner } from '@solana/signers';\n *\n * const signer = await generateKeyPairSigner();\n * isKeyPairSigner(signer); // true\n * isKeyPairSigner({ address: address('1234..5678') }); // false\n * ```\n */\nexport function isKeyPairSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\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/**\n * Asserts that the provided value implements the {@link KeyPairSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { generateKeyPairSigner, assertIsKeyPairSigner } from '@solana/signers';\n *\n * const signer = await generateKeyPairSigner();\n * assertIsKeyPairSigner(signer); // void\n * assertIsKeyPairSigner({ address: address('1234..5678') }); // Throws an error.\n * ```\n */\nexport function assertIsKeyPairSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is KeyPairSigner<TAddress> {\n if (!isKeyPairSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_KEY_PAIR_SIGNER, {\n address: value.address,\n });\n }\n}\n\n/**\n * Creates a {@link KeyPairSigner} from a provided {@link CryptoKeyPair}.\n *\n * The {@link MessagePartialSigner#signMessages | signMessages} and\n * {@link TransactionPartialSigner#signTransactions | signTransactions}\n * functions of the returned signer will use the private key of the provided\n * key pair to sign messages and transactions.\n *\n * Note that both the {@link MessagePartialSigner#signMessages | signMessages} and\n * {@link TransactionPartialSigner#signTransactions | signTransactions} implementations\n * are parallelized, meaning that they will sign all provided messages and transactions in parallel.\n *\n * @example\n * ```ts\n * import { generateKeyPair } from '@solana/keys';\n * import { createSignerFromKeyPair, KeyPairSigner } from '@solana/signers';\n *\n * const keyPair: CryptoKeyPair = await generateKeyPair();\n * const signer: KeyPairSigner = await createSignerFromKeyPair(keyPair);\n * ```\n */\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 // we know that the address has signed `signedTransaction` because it comes from the keypair\n return Object.freeze({ [address]: signedTransaction.signatures[address]! });\n }),\n ),\n };\n\n return Object.freeze(out);\n}\n\n/**\n * Generates a signer capable of signing messages and transactions by generating\n * a {@link CryptoKeyPair} and creating a {@link KeyPairSigner} from it.\n *\n * @example\n * ```ts\n * import { generateKeyPairSigner } from '@solana/signers';\n *\n * const signer = await generateKeyPairSigner();\n * ```\n *\n * @see {@link createSignerFromKeyPair}\n */\nexport async function generateKeyPairSigner(): Promise<KeyPairSigner> {\n return await createSignerFromKeyPair(await generateKeyPair());\n}\n\n/**\n * Creates a new {@link KeyPairSigner} from a 64-bytes `Uint8Array` secret key (private key and public key).\n *\n * @example\n * ```ts\n * import fs from 'fs';\n * import { createKeyPairSignerFromBytes } from '@solana/signers';\n *\n * // Get bytes from local keypair file.\n * const keypairFile = fs.readFileSync('~/.config/solana/id.json');\n * const keypairBytes = new Uint8Array(JSON.parse(keypairFile.toString()));\n *\n * // Create a KeyPairSigner from the bytes.\n * const signer = await createKeyPairSignerFromBytes(keypairBytes);\n * ```\n *\n * @see {@link createKeyPairSignerFromPrivateKeyBytes} if you only have the 32-bytes private key instead.\n */\nexport async function createKeyPairSignerFromBytes(\n bytes: ReadonlyUint8Array,\n extractable?: boolean,\n): Promise<KeyPairSigner> {\n return await createSignerFromKeyPair(await createKeyPairFromBytes(bytes, extractable));\n}\n\n/**\n * Creates a new {@link KeyPairSigner} from a 32-bytes `Uint8Array` private key.\n *\n * @example\n * ```ts\n * import { getUtf8Encoder } from '@solana/codecs-strings';\n * import { createKeyPairSignerFromPrivateKeyBytes } from '@solana/signers';\n *\n * const message = getUtf8Encoder().encode('Hello, World!');\n * const seed = new Uint8Array(await crypto.subtle.digest('SHA-256', message));\n *\n * const derivedSigner = await createKeyPairSignerFromPrivateKeyBytes(seed);\n * ```\n *\n * @see {@link createKeyPairSignerFromBytes} if you have the 64-bytes secret key instead (private key and public key).\n */\nexport async function createKeyPairSignerFromPrivateKeyBytes(\n bytes: ReadonlyUint8Array,\n extractable?: boolean,\n): Promise<KeyPairSigner> {\n return await createSignerFromKeyPair(await createKeyPairFromPrivateKeyBytes(bytes, extractable));\n}\n","import { Address, isAddress } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_MODIFYING_SIGNER, SolanaError } from '@solana/errors';\n\nimport { SignableMessage } from './signable-message';\nimport { BaseSignerConfig } from './types';\n\n/**\n * The configuration to optionally provide when calling the\n * {@link MessageModifyingSigner#modifyAndSignMessages | modifyAndSignMessages} method.\n *\n * @see {@link BaseSignerConfig}\n */\nexport type MessageModifyingSignerConfig = BaseSignerConfig;\n\n/**\n * A signer interface that _potentially_ modifies the content\n * of the provided {@link SignableMessage | SignableMessages} before signing them.\n *\n * For instance, this enables wallets to prefix or suffix nonces to the messages they sign.\n * For each message, instead of returning a {@link SignatureDictionary}, the\n * {@link MessageModifyingSigner#modifyAndSignMessages | modifyAndSignMessages} function\n * returns an updated {@link SignableMessage} with a potentially modified content and signature dictionary.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * const signer: MessageModifyingSigner<'1234..5678'> = {\n * address: address('1234..5678'),\n * modifyAndSignMessages: async (\n * messages: SignableMessage[]\n * ): Promise<SignableMessage[]> => {\n * // My custom signing logic.\n * },\n * };\n * ```\n *\n * @remarks\n * Here are the main characteristics of this signer interface:\n *\n * - **Sequential**. Contrary to partial signers, these cannot be executed in\n * parallel as each call can modify the content of the message.\n * - **First signers**. For a given message, a modifying signer must always be used\n * before a partial signer as the former will likely modify the message and\n * thus impact the outcome of the latter.\n * - **Potential conflicts**. If more than one modifying signer is provided, the second\n * signer may invalidate the signature of the first one. However, modifying signers\n * may decide not to modify a message based on the existence of signatures for that message.\n *\n * @see {@link SignableMessage}\n * @see {@link createSignableMessage}\n * @see {@link isMessageModifyingSigner}\n * @see {@link assertIsMessageModifyingSigner}\n */\nexport type MessageModifyingSigner<TAddress extends string = string> = Readonly<{\n address: Address<TAddress>;\n modifyAndSignMessages(\n messages: readonly SignableMessage[],\n config?: MessageModifyingSignerConfig,\n ): Promise<readonly SignableMessage[]>;\n}>;\n\n/**\n * Checks whether the provided value implements the {@link MessageModifyingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isMessageModifyingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isMessageModifyingSigner({ address, modifyAndSignMessages: async () => {} }); // true\n * isMessageModifyingSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsMessageModifyingSigner}\n */\nexport function isMessageModifyingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is MessageModifyingSigner<TAddress> {\n return (\n isAddress(value.address) &&\n 'modifyAndSignMessages' in value &&\n typeof value.modifyAndSignMessages === 'function'\n );\n}\n\n/**\n * Asserts that the provided value implements the {@link MessageModifyingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsMessageModifyingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsMessageModifyingSigner({ address, modifyAndSignMessages: async () => {} }); // void\n * assertIsMessageModifyingSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isMessageModifyingSigner}\n */\nexport function assertIsMessageModifyingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is MessageModifyingSigner<TAddress> {\n if (!isMessageModifyingSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_MODIFYING_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_SIGNER, SolanaError } from '@solana/errors';\n\nimport { isMessageModifyingSigner, MessageModifyingSigner } from './message-modifying-signer';\nimport { isMessagePartialSigner, MessagePartialSigner } from './message-partial-signer';\n\n/**\n * Defines a signer capable of signing messages.\n *\n * @see {@link MessageModifyingSigner} For signers that can modify messages before signing them.\n * @see {@link MessagePartialSigner} For signers that can be used in parallel.\n * @see {@link isMessageSigner}\n * @see {@link assertIsMessageSigner}\n */\nexport type MessageSigner<TAddress extends string = string> =\n | MessageModifyingSigner<TAddress>\n | MessagePartialSigner<TAddress>;\n\n/**\n * Checks whether the provided value implements the {@link MessageSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isMessageSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isMessageSigner({ address, signMessages: async () => {} }); // true\n * isMessageSigner({ address, modifyAndSignMessages: async () => {} }); // true\n * isMessageSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsMessageSigner}\n */\nexport function isMessageSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is MessageSigner<TAddress> {\n return isMessagePartialSigner(value) || isMessageModifyingSigner(value);\n}\n\n/**\n * Asserts that the provided value implements the {@link MessageSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsMessageSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsMessageSigner({ address, signMessages: async () => {} }); // void\n * assertIsMessageSigner({ address, modifyAndSignMessages: async () => {} }); // void\n * assertIsMessageSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isMessageSigner}\n */\nexport function assertIsMessageSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is MessageSigner<TAddress> {\n if (!isMessageSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address } from '@solana/addresses';\n\nimport { MessagePartialSigner } from './message-partial-signer';\nimport { TransactionPartialSigner } from './transaction-partial-signer';\n\n/**\n * Defines a Noop (No-Operation) signer that pretends to partially sign messages and transactions.\n *\n * For a given {@link Address}, a Noop Signer can be created to offer an implementation of both\n * the {@link MessagePartialSigner} and {@link TransactionPartialSigner} interfaces such that\n * they do not sign anything. Namely, signing a transaction or a message with a `NoopSigner`\n * will return an empty `SignatureDictionary`.\n *\n * @typeParam TAddress - Supply a string literal to define a Noop signer having a particular address.\n *\n * @example\n * ```ts\n * import { address } from '@solana/addresses';\n * import { createNoopSigner } from '@solana/signers';\n *\n * const signer = createNoopSigner(address('1234..5678'));\n * const [messageSignatures] = await signer.signMessages([message]);\n * const [transactionSignatures] = await signer.signTransactions([transaction]);\n * // ^ Both messageSignatures and transactionSignatures are empty.\n * ```\n *\n * @remarks\n * This signer may be useful:\n *\n * - For testing purposes.\n * - For indicating that a given account is a signer and taking the responsibility to provide\n * the signature for that account ourselves. For instance, if we need to send the transaction\n * to a server that will sign it and send it for us.\n *\n * @see {@link createNoopSigner}\n */\nexport type NoopSigner<TAddress extends string = string> = MessagePartialSigner<TAddress> &\n TransactionPartialSigner<TAddress>;\n\n/**\n * Creates a {@link NoopSigner} from the provided {@link Address}.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { address } from '@solana/addresses';\n * import { createNoopSigner } from '@solana/signers';\n *\n * const signer = createNoopSigner(address('1234..5678'));\n * ```\n */\nexport function createNoopSigner<TAddress extends string = string>(address: Address<TAddress>): NoopSigner<TAddress> {\n const out: NoopSigner<TAddress> = {\n address,\n signMessages: messages => Promise.resolve(messages.map(() => Object.freeze({}))),\n signTransactions: transactions => Promise.resolve(transactions.map(() => Object.freeze({}))),\n };\n\n return Object.freeze(out);\n}\n","import { OffchainMessageWithRequiredSignatories } from '@solana/offchain-messages';\n\nimport { deduplicateSigners } from './deduplicate-signers';\nimport { isMessageSigner, MessageSigner } from './message-signer';\n\n/**\n * Represents a {@link Signer} that is required to sign an offchain message for it to be valid.\n */\nexport type OffchainMessageSignatorySigner<TAddress extends string = string> = MessageSigner<TAddress>;\n\n/**\n * Extracts and deduplicates all {@link MessageSigner | MessageSigners} stored inside a given\n * {@link OffchainMessageWithSigners | offchain message}.\n *\n * Any extracted signers that share the same {@link Address} will be de-duplicated.\n *\n * @typeParam TAddress - Supply a string literal to define an account having a particular address.\n * @typeParam TSigner - Optionally provide a narrower type for {@link MessageSigner | MessageSigners}.\n * @typeParam TOffchainMessage - The inferred type of the offchain message provided.\n *\n * @example\n * ```ts\n * import { OffchainMessageWithSigners, getSignersFromOffchainMessage } from '@solana/signers';\n *\n * const signerA = { address: address('1111..1111'), signMessages: async () => {} };\n * const signerB = { address: address('2222..2222'), modifyAndSignMessages: async () => {} };\n * const OffchainMessage: OffchainMessageWithSigners = {\n * /* ... *\\/\n * requiredSignatories: [signerA, signerB],\n * };\n *\n * const messageSigners = getSignersFromOffchainMessage(offchainMessage);\n * // ^ [signerA, signerB]\n * ```\n */\nexport function getSignersFromOffchainMessage({\n requiredSignatories,\n}: OffchainMessageWithRequiredSignatories): readonly MessageSigner[] {\n const messageSigners = requiredSignatories.filter(isMessageSigner);\n return deduplicateSigners(messageSigners);\n}\n","import {\n assertIsFullySignedOffchainMessageEnvelope,\n compileOffchainMessageEnvelope,\n FullySignedOffchainMessageEnvelope,\n OffchainMessage,\n OffchainMessageEnvelope,\n OffchainMessageSignatory,\n OffchainMessageWithRequiredSignatories,\n} from '@solana/offchain-messages';\n\nimport {\n isMessageModifyingSigner,\n MessageModifyingSigner,\n MessageModifyingSignerConfig,\n} from './message-modifying-signer';\nimport { isMessagePartialSigner, MessagePartialSigner, MessagePartialSignerConfig } from './message-partial-signer';\nimport { MessageSigner } from './message-signer';\nimport { getSignersFromOffchainMessage, OffchainMessageSignatorySigner } from './offchain-message-signer';\nimport { SignableMessage } from './signable-message';\n\n/**\n * Extracts all {@link MessageSigner | MessageSigners} inside the provided offchain message and uses\n * them to return a signed offchain message envelope.\n *\n * It first uses all {@link MessageModifyingSigner | MessageModifyingSigners} sequentially before\n * using all {@link MessagePartialSigner | MessagePartialSigners} in parallel.\n *\n * If a composite signer implements both interfaces, it will be used as a\n * {@link MessageModifyingSigner} if no other signer implements that interface. Otherwise, it will\n * be used as a {@link MessagePartialSigner}.\n *\n * @example\n * ```ts\n * const signedOffchainMessageEnvelope = await partiallySignOffchainMessageWithSigners(offchainMessage);\n * ```\n *\n * It also accepts an optional {@link AbortSignal} that will be propagated to all signers.\n *\n * ```ts\n * const signedOffchainMessageEnvelope = await partiallySignOffchainMessageWithSigners(offchainMessage, {\n * abortSignal: myAbortController.signal,\n * });\n * ```\n *\n * @see {@link signOffchainMessageWithSigners}\n */\nexport async function partiallySignOffchainMessageWithSigners(\n offchainMessage: OffchainMessageWithRequiredSignatories<OffchainMessageSignatory | OffchainMessageSignatorySigner> &\n Omit<OffchainMessage, 'requiredSignatories'>,\n config?: MessagePartialSignerConfig,\n): Promise<OffchainMessageEnvelope> {\n const { partialSigners, modifyingSigners } = categorizeMessageSigners(\n getSignersFromOffchainMessage(offchainMessage),\n );\n return await signModifyingAndPartialMessageSigners(offchainMessage, modifyingSigners, partialSigners, config);\n}\n\n/**\n * Extracts all {@link MessageSigner | MessageSigners} inside the provided offchain message and uses\n * them to return a signed offchain message envelope before asserting that all signatures required\n * by the message are present.\n *\n * This function delegates to the {@link partiallySignOffchainMessageWithSigners} function\n * in order to extract signers from the offchain message and sign it.\n *\n * @example\n * ```ts\n * const mySignedOffchainMessageEnvelope = await signOffchainMessageWithSigners(myOffchainMessage);\n *\n * // With additional config.\n * const mySignedOffchainMessageEnvelope = await signOffchainMessageWithSigners(myOffchainMessage, {\n * abortSignal: myAbortController.signal,\n * });\n *\n * // We now know the offchain message is fully signed.\n * mySignedOffchainMessageEnvelope satisfies FullySignedOffchainMessageEnvelope;\n * ```\n *\n * @see {@link partiallySignOffchainMessageWithSigners}\n */\nexport async function signOffchainMessageWithSigners(\n offchainMessage: OffchainMessageWithRequiredSignatories<OffchainMessageSignatory | OffchainMessageSignatorySigner> &\n Omit<OffchainMessage, 'requiredSignatories'>,\n config?: MessagePartialSignerConfig,\n): Promise<FullySignedOffchainMessageEnvelope & OffchainMessageEnvelope> {\n const signedOffchainMessageEnvelope = await partiallySignOffchainMessageWithSigners(offchainMessage, config);\n assertIsFullySignedOffchainMessageEnvelope(signedOffchainMessageEnvelope);\n return signedOffchainMessageEnvelope;\n}\n\n/**\n * Identifies each provided {@link MessageSigner} and categorizes them into their respective types.\n * When a signer implements multiple interfaces, it will try to used to most powerful interface but\n * fall back to the least powerful interface when necessary.\n *\n * For instance, if a signer implements {@link MessageSigner} and {@link MessageModifyingSigner},\n * it will be categorized as a `MessageModifyingSigner`.\n */\nfunction categorizeMessageSigners(signers: readonly MessageSigner[]): Readonly<{\n modifyingSigners: readonly MessageModifyingSigner[];\n partialSigners: readonly MessagePartialSigner[];\n}> {\n // Identify the modifying signers from the other signers.\n const modifyingSigners = identifyMessageModifyingSigners(signers);\n\n // Use any remaining signers as partial signers.\n const partialSigners = signers\n .filter(isMessagePartialSigner)\n .filter(signer => !(modifyingSigners as typeof signers).includes(signer));\n\n return Object.freeze({ modifyingSigners, partialSigners });\n}\n\n/** Identifies the best signers to use as MessageModifyingSigners, if any */\nfunction identifyMessageModifyingSigners(\n signers: readonly (MessageModifyingSigner | MessagePartialSigner)[],\n): readonly MessageModifyingSigner[] {\n // Ensure there are any MessageModifyingSigner in the first place.\n const modifyingSigners = signers.filter(isMessageModifyingSigner);\n if (modifyingSigners.length === 0) return [];\n\n // Prefer modifying signers that do not offer partial signing.\n const nonPartialSigners = modifyingSigners.filter(signer => !isMessagePartialSigner(signer));\n if (nonPartialSigners.length > 0) return nonPartialSigners;\n\n // Otherwise, choose only one modifying signer (whichever).\n return [modifyingSigners[0]];\n}\n\n/**\n * Signs an offchain message using the provided\n * {@link MessageModifyingSigner | MessageModifyingSigners} sequentially followed by the\n * {@link MessagePartialSigner | MessagePartialSigners} in parallel.\n */\nasync function signModifyingAndPartialMessageSigners(\n offchainMessage: OffchainMessageWithRequiredSignatories<OffchainMessageSignatory | OffchainMessageSignatorySigner> &\n Omit<OffchainMessage, 'requiredSignatories'>,\n modifyingSigners: readonly MessageModifyingSigner[] = [],\n partialSigners: readonly MessagePartialSigner[] = [],\n config?: MessageModifyingSignerConfig,\n): Promise<OffchainMessageEnvelope> {\n // @ts-expect-error SignableMessage should probably specify `ReadonlyUint8Array` here.\n const offchainMessageEnvelope: SignableMessage = compileOffchainMessageEnvelope(offchainMessage);\n\n // Handle modifying signers sequentially.\n const modifiedOffchainMessage = await modifyingSigners.reduce(async (offchainMessageEnvelope, modifyingSigner) => {\n config?.abortSignal?.throwIfAborted();\n const [message] = await modifyingSigner.modifyAndSignMessages([await offchainMessageEnvelope], config);\n return Object.freeze(message);\n }, Promise.resolve(offchainMessageEnvelope));\n\n // Handle partial signers in parallel.\n config?.abortSignal?.throwIfAborted();\n const signatureDictionaries = await Promise.all(\n partialSigners.map(async partialSigner => {\n const [signatures] = await partialSigner.signMessages([modifiedOffchainMessage], config);\n return signatures;\n }),\n );\n\n // @ts-expect-error SignableMessage should probably specify `ReadonlyUint8Array` here.\n return Object.freeze({\n ...modifiedOffchainMessage,\n signatures: Object.freeze(\n signatureDictionaries.reduce((signatures, signatureDictionary) => {\n return { ...signatures, ...signatureDictionary };\n }, modifiedOffchainMessage.signatures ?? {}),\n ),\n } as OffchainMessageEnvelope);\n}\n","import {\n SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS,\n SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING,\n SolanaError,\n} from '@solana/errors';\nimport { Brand } from '@solana/nominal-types';\nimport { BaseTransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\n\nimport { getSignersFromTransactionMessage, TransactionMessageWithSigners } from './account-signer-meta';\nimport { isTransactionModifyingSigner } from './transaction-modifying-signer';\nimport { isTransactionPartialSigner } from './transaction-partial-signer';\nimport { isTransactionSendingSigner } from './transaction-sending-signer';\n\n/**\n * Defines a transaction message with exactly one {@link TransactionSendingSigner}.\n *\n * This type is used to narrow the type of transaction messages that have been\n * checked to have exactly one sending signer.\n *\n * @example\n * ```ts\n * import { assertIsTransactionMessageWithSingleSendingSigner } from '@solana/signers';\n *\n * assertIsTransactionMessageWithSingleSendingSigner(transactionMessage);\n * transactionMessage satisfies TransactionMessageWithSingleSendingSigner;\n * ```\n *\n * @see {@link isTransactionMessageWithSingleSendingSigner}\n * @see {@link assertIsTransactionMessageWithSingleSendingSigner}\n */\nexport type TransactionMessageWithSingleSendingSigner = Brand<\n TransactionMessageWithSigners,\n 'TransactionMessageWithSingleSendingSigner'\n>;\n\n/**\n * Checks whether the provided transaction has exactly one {@link TransactionSendingSigner}.\n *\n * This can be useful when using {@link signAndSendTransactionMessageWithSigners} to provide\n * a fallback strategy in case the transaction message cannot be send using this function.\n *\n * @typeParam TTransactionMessage - The inferred type of the transaction message provided.\n *\n * @example\n * ```ts\n * import {\n * isTransactionMessageWithSingleSendingSigner,\n * signAndSendTransactionMessageWithSigners,\n * signTransactionMessageWithSigners,\n * } from '@solana/signers';\n * import { getBase64EncodedWireTransaction } from '@solana/transactions';\n *\n * let transactionSignature: SignatureBytes;\n * if (isTransactionMessageWithSingleSendingSigner(transactionMessage)) {\n * transactionSignature = await signAndSendTransactionMessageWithSigners(transactionMessage);\n * } else {\n * const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);\n * const encodedTransaction = getBase64EncodedWireTransaction(signedTransaction);\n * transactionSignature = await rpc.sendTransaction(encodedTransaction).send();\n * }\n * ```\n *\n * @see {@link signAndSendTransactionMessageWithSigners}\n * @see {@link assertIsTransactionMessageWithSingleSendingSigner}\n */\nexport function isTransactionMessageWithSingleSendingSigner<\n TTransactionMessage extends BaseTransactionMessage & TransactionMessageWithFeePayer,\n>(transaction: TTransactionMessage): transaction is TransactionMessageWithSingleSendingSigner & TTransactionMessage {\n try {\n assertIsTransactionMessageWithSingleSendingSigner(transaction);\n return true;\n } catch {\n return false;\n }\n}\n\n/**\n * Asserts that the provided transaction message has exactly one {@link TransactionSendingSigner}.\n *\n * This can be useful when using the {@link signAndSendTransactionMessageWithSigners} function\n * to ensure it will be able to select the correct signer to send the transaction.\n *\n * @typeParam TTransactionMessage - The inferred type of the transaction message provided.\n *\n * @example\n * ```ts\n * import {\n * assertIsTransactionMessageWithSingleSendingSigner,\n * signAndSendTransactionMessageWithSigners\n * } from '@solana/signers';\n *\n * assertIsTransactionMessageWithSingleSendingSigner(transactionMessage);\n * const transactionSignature = await signAndSendTransactionMessageWithSigners(transactionMessage);\n * ```\n *\n * @see {@link signAndSendTransactionMessageWithSigners}\n * @see {@link isTransactionMessageWithSingleSendingSigner}\n */\nexport function assertIsTransactionMessageWithSingleSendingSigner<\n TTransactionMessage extends BaseTransactionMessage & TransactionMessageWithFeePayer,\n>(\n transaction: TTransactionMessage,\n): asserts transaction is TransactionMessageWithSingleSendingSigner & TTransactionMessage {\n const signers = getSignersFromTransactionMessage(transaction);\n const sendingSigners = signers.filter(isTransactionSendingSigner);\n\n if (sendingSigners.length === 0) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING);\n }\n\n // When identifying if there are multiple sending signers, we only need to check for\n // sending signers that do not implement other transaction signer interfaces as\n // they will be used as these other signer interfaces in case of a conflict.\n const sendingOnlySigners = sendingSigners.filter(\n signer => !isTransactionPartialSigner(signer) && !isTransactionModifyingSigner(signer),\n );\n\n if (sendingOnlySigners.length > 1) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS);\n }\n}\n","import { SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING, SolanaError } from '@solana/errors';\nimport { SignatureBytes } from '@solana/keys';\nimport { BaseTransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\nimport {\n assertIsFullySignedTransaction,\n compileTransaction,\n SendableTransaction,\n Transaction,\n TransactionWithinSizeLimit,\n TransactionWithLifetime,\n} from '@solana/transactions';\n\nimport { getSignersFromTransactionMessage, TransactionMessageWithSigners } from './account-signer-meta';\nimport { deduplicateSigners } from './deduplicate-signers';\nimport {\n isTransactionModifyingSigner,\n TransactionModifyingSigner,\n TransactionModifyingSignerConfig,\n} from './transaction-modifying-signer';\nimport {\n isTransactionPartialSigner,\n TransactionPartialSigner,\n TransactionPartialSignerConfig,\n} from './transaction-partial-signer';\nimport {\n isTransactionSendingSigner,\n TransactionSendingSigner,\n TransactionSendingSignerConfig,\n} from './transaction-sending-signer';\nimport { isTransactionSigner, TransactionSigner } from './transaction-signer';\nimport { assertIsTransactionMessageWithSingleSendingSigner } from './transaction-with-single-sending-signer';\n\n/**\n * Extracts all {@link TransactionSigner | TransactionSigners} inside the provided\n * transaction message and uses them to return a signed transaction.\n *\n * It first uses all {@link TransactionModifyingSigner | TransactionModifyingSigners} sequentially before\n * using all {@link TransactionPartialSigner | TransactionPartialSigners} in parallel.\n *\n * If a composite signer implements both interfaces, it will be used as a\n * {@link TransactionModifyingSigner} if no other signer implements that interface.\n * Otherwise, it will be used as a {@link TransactionPartialSigner}.\n *\n * @example\n * ```ts\n * const signedTransaction = await partiallySignTransactionMessageWithSigners(transactionMessage);\n * ```\n *\n * It also accepts an optional {@link AbortSignal} that will be propagated to all signers.\n *\n * ```ts\n * const signedTransaction = await partiallySignTransactionMessageWithSigners(transactionMessage, {\n * abortSignal: myAbortController.signal,\n * });\n * ```\n *\n * @remarks\n * Finally, note that this function ignores {@link TransactionSendingSigner | TransactionSendingSigners}\n * as it does not send the transaction. Check out the {@link signAndSendTransactionMessageWithSigners}\n * function for more details on how to use sending signers.\n *\n * @see {@link signTransactionMessageWithSigners}\n * @see {@link signAndSendTransactionMessageWithSigners}\n */\nexport async function partiallySignTransactionMessageWithSigners(\n transactionMessage: BaseTransactionMessage & TransactionMessageWithFeePayer & TransactionMessageWithSigners,\n config?: TransactionPartialSignerConfig,\n): Promise<Transaction & TransactionWithinSizeLimit & TransactionWithLifetime> {\n const { partialSigners, modifyingSigners } = categorizeTransactionSigners(\n deduplicateSigners(getSignersFromTransactionMessage(transactionMessage).filter(isTransactionSigner)),\n { identifySendingSigner: false },\n );\n\n return await signModifyingAndPartialTransactionSigners(\n transactionMessage,\n modifyingSigners,\n partialSigners,\n config,\n );\n}\n\n/**\n * Extracts all {@link TransactionSigner | TransactionSigners} inside the provided\n * transaction message and uses them to return a signed transaction before asserting\n * that all signatures required by the transaction are present.\n *\n * This function delegates to the {@link partiallySignTransactionMessageWithSigners} function\n * in order to extract signers from the transaction message and sign the transaction.\n *\n * @example\n * ```ts\n * const mySignedTransaction = await signTransactionMessageWithSigners(myTransactionMessage);\n *\n * // With additional config.\n * const mySignedTransaction = await signTransactionMessageWithSigners(myTransactionMessage, {\n * abortSignal: myAbortController.signal,\n * });\n *\n * // We now know the transaction is fully signed.\n * mySignedTransaction satisfies FullySignedTransaction;\n * ```\n *\n * @see {@link partiallySignTransactionMessageWithSigners}\n * @see {@link signAndSendTransactionMessageWithSigners}\n */\nexport async function signTransactionMessageWithSigners(\n transactionMessage: BaseTransactionMessage & TransactionMessageWithFeePayer & TransactionMessageWithSigners,\n config?: TransactionPartialSignerConfig,\n): Promise<SendableTransaction & Transaction & TransactionWithLifetime> {\n const signedTransaction = await partiallySignTransactionMessageWithSigners(transactionMessage, config);\n assertIsFullySignedTransaction(signedTransaction);\n return signedTransaction;\n}\n\n/**\n * Extracts all {@link TransactionSigner | TransactionSigners} inside the provided\n * transaction message and uses them to sign it before sending it immediately to the blockchain.\n *\n * It returns the signature of the sent transaction (i.e. its identifier) as bytes.\n *\n * @example\n * ```ts\n * import { signAndSendTransactionMessageWithSigners } from '@solana/signers';\n *\n * const transactionSignature = await signAndSendTransactionMessageWithSigners(transactionMessage);\n *\n * // With additional config.\n * const transactionSignature = await signAndSendTransactionMessageWithSigners(transactionMessage, {\n * abortSignal: myAbortController.signal,\n * });\n * ```\n *\n * @remarks\n * Similarly to the {@link partiallySignTransactionMessageWithSigners} function, it first uses all\n * {@link TransactionModifyingSigner | TransactionModifyingSigners} sequentially before using all\n * {@link TransactionPartialSigner | TransactionPartialSigners} in parallel.\n * It then sends the transaction using the {@link TransactionSendingSigner} it identified.\n *\n * Composite transaction signers are treated such that at least one sending signer is used if any.\n * When a {@link TransactionSigner} implements more than one interface, we use it as a:\n *\n * - {@link TransactionSendingSigner}, if no other {@link TransactionSendingSigner} exists.\n * - {@link TransactionModifyingSigner}, if no other {@link TransactionModifyingSigner} exists.\n * - {@link TransactionPartialSigner}, otherwise.\n *\n * The provided transaction must contain exactly one {@link TransactionSendingSigner} inside its account metas.\n * If more than one composite signers implement the {@link TransactionSendingSigner} interface,\n * one of them will be selected as the sending signer. Otherwise, if multiple\n * {@link TransactionSendingSigner | TransactionSendingSigners} must be selected, the function will throw an error.\n *\n * If you'd like to assert that a transaction makes use of exactly one {@link TransactionSendingSigner}\n * _before_ calling this function, you may use the {@link assertIsTransactionMessageWithSingleSendingSigner} function.\n *\n * Alternatively, you may use the {@link isTransactionMessageWithSingleSendingSigner} function to provide a\n * fallback in case the transaction does not contain any sending signer.\n *\n * @see {@link assertIsTransactionMessageWithSingleSendingSigner}\n * @see {@link isTransactionMessageWithSingleSendingSigner}\n * @see {@link partiallySignTransactionMessageWithSigners}\n * @see {@link signTransactionMessageWithSigners}\n *\n */\nexport async function signAndSendTransactionMessageWithSigners(\n transaction: BaseTransactionMessage & TransactionMessageWithFeePayer & TransactionMessageWithSigners,\n config?: TransactionSendingSignerConfig,\n): Promise<SignatureBytes> {\n assertIsTransactionMessageWithSingleSendingSigner(transaction);\n\n const abortSignal = config?.abortSignal;\n const { partialSigners, modifyingSigners, sendingSigner } = categorizeTransactionSigners(\n deduplicateSigners(getSignersFromTransactionMessage(transaction).filter(isTransactionSigner)),\n );\n\n abortSignal?.throwIfAborted();\n const signedTransaction = await signModifyingAndPartialTransactionSigners(\n transaction,\n modifyingSigners,\n partialSigners,\n config,\n );\n\n if (!sendingSigner) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING);\n }\n\n abortSignal?.throwIfAborted();\n const [signature] = await sendingSigner.signAndSendTransactions([signedTransaction], config);\n abortSignal?.throwIfAborted();\n\n return signature;\n}\n\n/**\n * Identifies each provided TransactionSigner and categorizes them into their respective types.\n * When a signer implements multiple interface, it will try to used to most powerful interface\n * but fallback to the least powerful interface when necessary.\n * For instance, if a signer implements TransactionSendingSigner and TransactionModifyingSigner,\n * it will be categorized as a TransactionSendingSigner if and only if no other signers implement\n * the TransactionSendingSigner interface.\n */\nfunction categorizeTransactionSigners(\n signers: readonly TransactionSigner[],\n config: { identifySendingSigner?: boolean } = {},\n): Readonly<{\n modifyingSigners: readonly TransactionModifyingSigner[];\n partialSigners: readonly TransactionPartialSigner[];\n sendingSigner: TransactionSendingSigner | null;\n}> {\n // Identify the unique sending signer that should be used.\n const identifySendingSigner = config.identifySendingSigner ?? true;\n const sendingSigner = identifySendingSigner ? identifyTransactionSendingSigner(signers) : null;\n\n // Now, focus on the other signers.\n // I.e. the modifying or partial signers that are not the identified sending signer.\n // Note that any other sending only signers will be discarded.\n const otherSigners = signers.filter(\n (signer): signer is TransactionModifyingSigner | TransactionPartialSigner =>\n signer !== sendingSigner && (isTransactionModifyingSigner(signer) || isTransactionPartialSigner(signer)),\n );\n\n // Identify the modifying signers from the other signers.\n const modifyingSigners = identifyTransactionModifyingSigners(otherSigners);\n\n // Use any remaining signers as partial signers.\n const partialSigners = otherSigners\n .filter(isTransactionPartialSigner)\n .filter(signer => !(modifyingSigners as typeof otherSigners).includes(signer));\n\n return Object.freeze({ modifyingSigners, partialSigners, sendingSigner });\n}\n\n/** Identifies the best signer to use as a TransactionSendingSigner, if any */\nfunction identifyTransactionSendingSigner(signers: readonly TransactionSigner[]): TransactionSendingSigner | null {\n // Ensure there are any TransactionSendingSigners in the first place.\n const sendingSigners = signers.filter(isTransactionSendingSigner);\n if (sendingSigners.length === 0) return null;\n\n // Prefer sending signers that do not offer other interfaces.\n const sendingOnlySigners = sendingSigners.filter(\n signer => !isTransactionModifyingSigner(signer) && !isTransactionPartialSigner(signer),\n );\n if (sendingOnlySigners.length > 0) {\n return sendingOnlySigners[0];\n }\n\n // Otherwise, choose any sending signer.\n return sendingSigners[0];\n}\n\n/** Identifies the best signers to use as TransactionModifyingSigners, if any */\nfunction identifyTransactionModifyingSigners(\n signers: readonly (TransactionModifyingSigner | TransactionPartialSigner)[],\n): readonly TransactionModifyingSigner[] {\n // Ensure there are any TransactionModifyingSigner in the first place.\n const modifyingSigners = signers.filter(isTransactionModifyingSigner);\n if (modifyingSigners.length === 0) return [];\n\n // Prefer modifying signers that do not offer partial signing.\n const nonPartialSigners = modifyingSigners.filter(signer => !isTransactionPartialSigner(signer));\n if (nonPartialSigners.length > 0) return nonPartialSigners;\n\n // Otherwise, choose only one modifying signer (whichever).\n return [modifyingSigners[0]];\n}\n\n/**\n * Signs a transaction using the provided TransactionModifyingSigners\n * sequentially followed by the TransactionPartialSigners in parallel.\n */\nasync function signModifyingAndPartialTransactionSigners(\n transactionMessage: BaseTransactionMessage & TransactionMessageWithFeePayer & TransactionMessageWithSigners,\n modifyingSigners: readonly TransactionModifyingSigner[] = [],\n partialSigners: readonly TransactionPartialSigner[] = [],\n config?: TransactionModifyingSignerConfig,\n): Promise<Transaction & TransactionWithinSizeLimit & TransactionWithLifetime> {\n // serialize the transaction\n const transaction = compileTransaction(transactionMessage);\n\n // Handle modifying signers sequentially.\n const modifiedTransaction = (await modifyingSigners.reduce(\n async (transaction, modifyingSigner) => {\n config?.abortSignal?.throwIfAborted();\n const [tx] = await modifyingSigner.modifyAndSignTransactions([await transaction], config);\n return Object.freeze(tx);\n },\n Promise.resolve(transaction) as Promise<Readonly<Transaction & TransactionWithLifetime>>,\n )) as Transaction & TransactionWithinSizeLimit & TransactionWithLifetime;\n\n // Handle partial signers in parallel.\n config?.abortSignal?.throwIfAborted();\n const signatureDictionaries = await Promise.all(\n partialSigners.map(async partialSigner => {\n const [signatures] = await partialSigner.signTransactions([modifiedTransaction], config);\n return signatures;\n }),\n );\n\n return Object.freeze({\n ...modifiedTransaction,\n signatures: Object.freeze(\n signatureDictionaries.reduce((signatures, signatureDictionary) => {\n return { ...signatures, ...signatureDictionary };\n }, modifiedTransaction.signatures ?? {}),\n ),\n });\n}\n","export const TextDecoder = globalThis.TextDecoder;\nexport const TextEncoder = globalThis.TextEncoder;\n","import { TextEncoder } from '@solana/text-encoding-impl';\n\nimport { SignatureDictionary } from './types';\n\n/**\n * Defines a message that needs signing and its current set of signatures if any.\n *\n * This interface allows {@link MessageModifyingSigner | MessageModifyingSigners}\n * to decide on whether or not they should modify the provided message depending\n * on whether or not signatures already exist for such message.\n *\n * It also helps create a more consistent API by providing a structure analogous\n * to transactions which also keep track of their {@link SignatureDictionary}.\n *\n * @example\n * ```ts\n * import { createSignableMessage } from '@solana/signers';\n *\n * const message = createSignableMessage(new Uint8Array([1, 2, 3]));\n * message.content; // The content of the message as bytes.\n * message.signatures; // The current set of signatures for this message.\n * ```\n *\n * @see {@link createSignableMessage}\n */\nexport type SignableMessage = Readonly<{\n content: Uint8Array;\n signatures: SignatureDictionary;\n}>;\n\n/**\n * Creates a {@link SignableMessage} from a `Uint8Array` or a UTF-8 string.\n *\n * It optionally accepts a signature dictionary if the message already contains signatures.\n *\n * @example\n * ```ts\n * const message = createSignableMessage(new Uint8Array([1, 2, 3]));\n * const messageFromText = createSignableMessage('Hello world!');\n * const messageWithSignatures = createSignableMessage('Hello world!', {\n * [address('1234..5678')]: new Uint8Array([1, 2, 3]) as SignatureBytes,\n * });\n * ```\n */\nexport function createSignableMessage(\n content: Uint8Array | string,\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"]}
1
+ {"version":3,"sources":["../src/deduplicate-signers.ts","../src/transaction-modifying-signer.ts","../src/transaction-partial-signer.ts","../src/transaction-sending-signer.ts","../src/transaction-signer.ts","../src/account-signer-meta.ts","../src/add-signers.ts","../src/fee-payer-signer.ts","../src/message-partial-signer.ts","../src/keypair-signer.ts","../src/message-modifying-signer.ts","../src/message-signer.ts","../src/noop-signer.ts","../src/offchain-message-signer.ts","../src/sign-offchain-message.ts","../src/transaction-with-single-sending-signer.ts","../src/sign-transaction.ts","../../text-encoding-impl/src/index.browser.ts","../src/signable-message.ts"],"names":["SolanaError","SOLANA_ERROR__SIGNER__ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS","SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER","SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER","SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER","SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER","isSignerRole","SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_PARTIAL_SIGNER","SOLANA_ERROR__SIGNER__EXPECTED_KEY_PAIR_SIGNER","getAddressFromPublicKey","signBytes","transactions","partiallySignTransaction","generateKeyPair","createKeyPairFromBytes","createKeyPairFromPrivateKeyBytes","isAddress","SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_MODIFYING_SIGNER","SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_SIGNER","assertIsFullySignedOffchainMessageEnvelope","compileOffchainMessageEnvelope","offchainMessageEnvelope","SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING","SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS","assertIsFullySignedTransaction","compileTransaction","transaction","TextEncoder"],"mappings":"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","file":"index.browser.cjs","sourcesContent":["import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS, SolanaError } from '@solana/errors';\n\nimport { MessageSigner } from './message-signer';\nimport { TransactionSigner } from './transaction-signer';\n\n/**\n * Removes all duplicated {@link MessageSigner | MessageSigners} and\n * {@link TransactionSigner | TransactionSigners} from a provided array\n * by comparing their {@link Address | addresses}.\n *\n * @internal\n */\nexport function deduplicateSigners<TSigner extends MessageSigner | TransactionSigner>(\n signers: readonly TSigner[],\n): readonly TSigner[] {\n const deduplicated: Record<Address, TSigner> = {};\n signers.forEach(signer => {\n if (!deduplicated[signer.address]) {\n deduplicated[signer.address] = signer;\n } else if (deduplicated[signer.address] !== signer) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS, {\n address: signer.address,\n });\n }\n });\n return Object.values(deduplicated);\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER, SolanaError } from '@solana/errors';\nimport { Transaction, TransactionWithinSizeLimit, TransactionWithLifetime } from '@solana/transactions';\n\nimport { BaseTransactionSignerConfig } from './types';\n\n/**\n * The configuration to optionally provide when calling the\n * {@link TransactionModifyingSigner#modifyAndSignTransactions | modifyAndSignTransactions} method.\n *\n * @see {@link BaseTransactionSignerConfig}\n */\nexport type TransactionModifyingSignerConfig = BaseTransactionSignerConfig;\n\n/**\n * A signer interface that potentially modifies the provided {@link Transaction | Transactions}\n * before signing them.\n *\n * For instance, this enables wallets to inject additional instructions into the\n * transaction before signing them. For each transaction, instead of returning a\n * {@link SignatureDictionary}, its\n * {@link TransactionModifyingSigner#modifyAndSignTransactions | modifyAndSignTransactions} function\n * returns an updated {@link Transaction} with a potentially modified set of instructions and\n * signature dictionary. The returned transaction must be within the transaction size limit,\n * and include a `lifetimeConstraint`.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * const signer: TransactionModifyingSigner<'1234..5678'> = {\n * address: address('1234..5678'),\n * modifyAndSignTransactions: async (\n * transactions: Transaction[]\n * ): Promise<(Transaction & TransactionWithinSizeLimit & TransactionWithLifetime)[]> => {\n * // My custom signing logic.\n * },\n * };\n * ```\n *\n * @remarks\n * Here are the main characteristics of this signer interface:\n *\n * - **Sequential**. Contrary to partial signers, these cannot be executed in\n * parallel as each call can modify the provided transactions.\n * - **First signers**. For a given transaction, a modifying signer must always\n * be used before a partial signer as the former will likely modify the\n * transaction and thus impact the outcome of the latter.\n * - **Potential conflicts**. If more than one modifying signer is provided,\n * the second signer may invalidate the signature of the first one. However,\n * modifying signers may decide not to modify a transaction based on the\n * existence of signatures for that transaction.\n *\n * @see {@link isTransactionModifyingSigner}\n * @see {@link assertIsTransactionModifyingSigner}\n */\nexport type TransactionModifyingSigner<TAddress extends string = string> = Readonly<{\n address: Address<TAddress>;\n modifyAndSignTransactions(\n transactions: readonly (Transaction | (Transaction & TransactionWithLifetime))[],\n config?: TransactionModifyingSignerConfig,\n ): Promise<readonly (Transaction & TransactionWithinSizeLimit & TransactionWithLifetime)[]>;\n}>;\n\n/**\n * Checks whether the provided value implements the {@link TransactionModifyingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isTransactionModifyingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isTransactionModifyingSigner({ address, modifyAndSignTransactions: async () => {} }); // true\n * isTransactionModifyingSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsTransactionModifyingSigner}\n */\nexport function isTransactionModifyingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is TransactionModifyingSigner<TAddress> {\n return 'modifyAndSignTransactions' in value && typeof value.modifyAndSignTransactions === 'function';\n}\n\n/**\n * Asserts that the provided value implements the {@link TransactionModifyingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsTransactionModifyingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsTransactionModifyingSigner({ address, modifyAndSignTransactions: async () => {} }); // void\n * assertIsTransactionModifyingSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isTransactionModifyingSigner}\n */\nexport function assertIsTransactionModifyingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is TransactionModifyingSigner<TAddress> {\n if (!isTransactionModifyingSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER, SolanaError } from '@solana/errors';\nimport { Transaction, TransactionWithinSizeLimit, TransactionWithLifetime } from '@solana/transactions';\n\nimport { BaseTransactionSignerConfig, SignatureDictionary } from './types';\n\n/**\n * The configuration to optionally provide when calling the\n * {@link TransactionPartialSigner#signTransactions | signTransactions} method.\n *\n * @see {@link BaseTransactionSignerConfig}\n */\nexport type TransactionPartialSignerConfig = BaseTransactionSignerConfig;\n\n/**\n * A signer interface that signs an array of {@link Transaction | Transactions}\n * without modifying their content. It defines a\n * {@link TransactionPartialSigner#signTransactions | signTransactions}\n * function that returns a {@link SignatureDictionary} for each provided transaction.\n *\n * Such signature dictionaries are expected to be merged with the existing ones if any.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * const signer: TransactionPartialSigner<'1234..5678'> = {\n * address: address('1234..5678'),\n * signTransactions: async (\n * transactions: Transaction[]\n * ): Promise<SignatureDictionary[]> => {\n * // My custom signing logic.\n * },\n * };\n * ```\n *\n * @remarks\n * Here are the main characteristics of this signer interface:\n *\n * - **Parallel**. It returns a signature dictionary for each provided\n * transaction without modifying them, making it possible for multiple\n * partial signers to sign the same transaction in parallel.\n * - **Flexible order**. The order in which we use these signers for\n * a given transaction doesn’t matter.\n *\n * @see {@link isTransactionPartialSigner}\n * @see {@link assertIsTransactionPartialSigner}\n */\nexport type TransactionPartialSigner<TAddress extends string = string> = Readonly<{\n address: Address<TAddress>;\n signTransactions(\n transactions: readonly (Transaction & TransactionWithinSizeLimit & TransactionWithLifetime)[],\n config?: TransactionPartialSignerConfig,\n ): Promise<readonly SignatureDictionary[]>;\n}>;\n\n/**\n * Checks whether the provided value implements the {@link TransactionPartialSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isTransactionPartialSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isTransactionPartialSigner({ address, signTransactions: async () => {} }); // true\n * isTransactionPartialSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsTransactionPartialSigner}\n */\nexport function isTransactionPartialSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is TransactionPartialSigner<TAddress> {\n return 'signTransactions' in value && typeof value.signTransactions === 'function';\n}\n\n/**\n * Asserts that the provided value implements the {@link TransactionPartialSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsTransactionPartialSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsTransactionPartialSigner({ address, signTransactions: async () => {} }); // void\n * assertIsTransactionPartialSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isTransactionPartialSigner}\n */\nexport function assertIsTransactionPartialSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is TransactionPartialSigner<TAddress> {\n if (!isTransactionPartialSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER, SolanaError } from '@solana/errors';\nimport { SignatureBytes } from '@solana/keys';\nimport { Transaction, TransactionWithLifetime } from '@solana/transactions';\n\nimport { BaseTransactionSignerConfig } from './types';\n\n/**\n * The configuration to optionally provide when calling the\n * {@link TransactionSendingSignerConfig#signAndSendTransactions | signAndSendTransactions} method.\n *\n * @see {@link BaseTransactionSignerConfig}\n */\nexport type TransactionSendingSignerConfig = BaseTransactionSignerConfig;\n\n/**\n * A signer interface that signs one or multiple transactions\n * before sending them immediately to the blockchain.\n *\n * It defines a {@link TransactionSendingSignerConfig#signAndSendTransactions | signAndSendTransactions}\n * function that returns the transaction signature (i.e. its identifier) for each provided\n * {@link Transaction}.\n *\n * This interface is required for PDA wallets and other types of wallets that don't provide an\n * interface for signing transactions without sending them.\n *\n * Note that it is also possible for such signers to modify the provided transactions\n * before signing and sending them. This enables use cases where the modified transactions\n * cannot be shared with the app and thus must be sent directly.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * const myTransactionSendingSigner: TransactionSendingSigner<'1234..5678'> = {\n * address: address('1234..5678'),\n * signAndSendTransactions: async (transactions: Transaction[]): Promise<SignatureBytes[]> => {\n * // My custom signing logic.\n * },\n * };\n * ```\n *\n * @remarks\n * Here are the main characteristics of this signer interface:\n *\n * - **Single signer**. Since this signer also sends the provided transactions,\n * we can only use a single {@link TransactionSendingSigner} for a given set of transactions.\n * - **Last signer**. Trivially, that signer must also be the last one used.\n * - **Potential conflicts**. Since signers may decide to modify the given\n * transactions before sending them, they may invalidate previous signatures.\n * However, signers may decide not to modify a transaction based\n * on the existence of signatures for that transaction.\n * - **Potential confirmation**. Whilst this is not required by this interface,\n * it is also worth noting that most wallets will also wait for the transaction\n * to be confirmed (typically with a `confirmed` commitment)\n * before notifying the app that they are done.\n *\n * @see {@link isTransactionSendingSigner}\n * @see {@link assertIsTransactionSendingSigner}\n */\nexport type TransactionSendingSigner<TAddress extends string = string> = Readonly<{\n address: Address<TAddress>;\n signAndSendTransactions(\n transactions: readonly (Transaction | (Transaction & TransactionWithLifetime))[],\n config?: TransactionSendingSignerConfig,\n ): Promise<readonly SignatureBytes[]>;\n}>;\n\n/**\n * Checks whether the provided value implements the {@link TransactionSendingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isTransactionSendingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isTransactionSendingSigner({ address, signAndSendTransactions: async () => {} }); // true\n * isTransactionSendingSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsTransactionSendingSigner}\n */\nexport function isTransactionSendingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is TransactionSendingSigner<TAddress> {\n return 'signAndSendTransactions' in value && typeof value.signAndSendTransactions === 'function';\n}\n\n/**\n * Asserts that the provided value implements the {@link TransactionSendingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsTransactionSendingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsTransactionSendingSigner({ address, signAndSendTransactions: async () => {} }); // void\n * assertIsTransactionSendingSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isTransactionSendingSigner}\n */\nexport function assertIsTransactionSendingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is TransactionSendingSigner<TAddress> {\n if (!isTransactionSendingSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER, SolanaError } from '@solana/errors';\n\nimport { isTransactionModifyingSigner, TransactionModifyingSigner } from './transaction-modifying-signer';\nimport { isTransactionPartialSigner, TransactionPartialSigner } from './transaction-partial-signer';\nimport { isTransactionSendingSigner, TransactionSendingSigner } from './transaction-sending-signer';\n\n/**\n * Defines a signer capable of signing transactions.\n *\n * @see {@link TransactionModifyingSigner} For signers that can modify transactions before signing them.\n * @see {@link TransactionPartialSigner} For signers that can be used in parallel.\n * @see {@link TransactionSendingSigner} For signers that send transactions after signing them.\n * @see {@link isTransactionSigner}\n * @see {@link assertIsTransactionSigner}\n */\nexport type TransactionSigner<TAddress extends string = string> =\n | TransactionModifyingSigner<TAddress>\n | TransactionPartialSigner<TAddress>\n | TransactionSendingSigner<TAddress>;\n\n/**\n * Checks whether the provided value implements the {@link TransactionSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isTransactionSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isTransactionSigner({ address, signTransactions: async () => {} }); // true\n * isTransactionSigner({ address, modifyAndSignTransactions: async () => {} }); // true\n * isTransactionSigner({ address, signAndSendTransactions: async () => {} }); // true\n * isTransactionSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsTransactionSigner}\n */\nexport function isTransactionSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is TransactionSigner<TAddress> {\n return (\n isTransactionPartialSigner(value) || isTransactionModifyingSigner(value) || isTransactionSendingSigner(value)\n );\n}\n\n/**\n * Asserts that the provided value implements the {@link TransactionSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsTransactionSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsTransactionSigner({ address, signTransactions: async () => {} }); // void\n * assertIsTransactionSigner({ address, modifyAndSignTransactions: async () => {} }); // void\n * assertIsTransactionSigner({ address, signAndSendTransactions: async () => {} }); // void\n * assertIsTransactionSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isTransactionSigner}\n */\nexport function assertIsTransactionSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is TransactionSigner<TAddress> {\n if (!isTransactionSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { AccountLookupMeta, AccountMeta, AccountRole, Instruction } from '@solana/instructions';\nimport {\n BaseTransactionMessage,\n TransactionMessageWithFeePayer,\n TransactionVersion,\n} from '@solana/transaction-messages';\n\nimport { deduplicateSigners } from './deduplicate-signers';\nimport { TransactionMessageWithFeePayerSigner } from './fee-payer-signer';\nimport { isTransactionSigner, TransactionSigner } from './transaction-signer';\n\n/**\n * An extension of the {@link AccountMeta} type that allows us to store {@link TransactionSigner | TransactionSigners} inside it.\n *\n * Note that, because this type represents a signer, it must use one the following two roles:\n * - {@link AccountRole.READONLY_SIGNER}\n * - {@link AccountRole.WRITABLE_SIGNER}\n *\n * @typeParam TAddress - Supply a string literal to define an account having a particular address.\n * @typeParam TSigner - Optionally provide a narrower type for the {@link TransactionSigner} to use within the account meta.\n *\n * @interface\n *\n * @example\n * ```ts\n * import { AccountRole } from '@solana/instructions';\n * import { generateKeyPairSigner, AccountSignerMeta } from '@solana/signers';\n *\n * const signer = await generateKeyPairSigner();\n * const account: AccountSignerMeta = {\n * address: signer.address,\n * role: AccountRole.READONLY_SIGNER,\n * signer,\n * };\n * ```\n */\nexport interface AccountSignerMeta<\n TAddress extends string = string,\n TSigner extends TransactionSigner<TAddress> = TransactionSigner<TAddress>,\n> extends AccountMeta<TAddress> {\n readonly role: AccountRole.READONLY_SIGNER | AccountRole.WRITABLE_SIGNER;\n readonly signer: TSigner;\n}\n\n/**\n * A union type that supports base account metas as well as {@link AccountSignerMeta | signer account metas}.\n */\ntype AccountMetaWithSigner<TSigner extends TransactionSigner = TransactionSigner> =\n | AccountLookupMeta\n | AccountMeta\n | AccountSignerMeta<string, TSigner>;\n\n/**\n * Composable type that allows {@link AccountSignerMeta | AccountSignerMetas} to be used inside the instruction's `accounts` array\n *\n * @typeParam TSigner - Optionally provide a narrower type for {@link TransactionSigner | TransactionSigners}.\n * @typeParam TAccounts - Optionally provide a narrower type for the account metas.\n *\n * @interface\n *\n * @example\n * ```ts\n * import { AccountRole, Instruction } from '@solana/instructions';\n * import { generateKeyPairSigner, InstructionWithSigners } from '@solana/signers';\n *\n * const [authority, buffer] = await Promise.all([\n * generateKeyPairSigner(),\n * generateKeyPairSigner(),\n * ]);\n * const instruction: Instruction & InstructionWithSigners = {\n * programAddress: address('1234..5678'),\n * accounts: [\n * // The authority is a signer account.\n * {\n * address: authority.address,\n * role: AccountRole.READONLY_SIGNER,\n * signer: authority,\n * },\n * // The buffer is a writable account.\n * { address: buffer.address, role: AccountRole.WRITABLE },\n * ],\n * };\n * ```\n */\nexport type InstructionWithSigners<\n TSigner extends TransactionSigner = TransactionSigner,\n TAccounts extends readonly AccountMetaWithSigner<TSigner>[] = readonly AccountMetaWithSigner<TSigner>[],\n> = Pick<Instruction<string, TAccounts>, 'accounts'>;\n\n/**\n * A {@link BaseTransactionMessage} type extension that accept {@link TransactionSigner | TransactionSigners}.\n *\n * Namely, it allows:\n * - a {@link TransactionSigner} to be used as the fee payer and\n * - {@link InstructionWithSigners} to be used in its instructions.\n *\n *\n * @typeParam TAddress - Supply a string literal to define an account having a particular address.\n * @typeParam TSigner - Optionally provide a narrower type for {@link TransactionSigner | TransactionSigners}.\n * @typeParam TAccounts - Optionally provide a narrower type for the account metas.\n *\n * @example\n * ```ts\n * import { Instruction } from '@solana/instructions';\n * import { BaseTransactionMessage } from '@solana/transaction-messages';\n * import { generateKeyPairSigner, InstructionWithSigners, TransactionMessageWithSigners } from '@solana/signers';\n *\n * const signer = await generateKeyPairSigner();\n * const firstInstruction: Instruction = { ... };\n * const secondInstruction: InstructionWithSigners = { ... };\n * const transactionMessage: BaseTransactionMessage & TransactionMessageWithSigners = {\n * feePayer: signer,\n * instructions: [firstInstruction, secondInstruction],\n * }\n * ```\n */\nexport type TransactionMessageWithSigners<\n TAddress extends string = string,\n TSigner extends TransactionSigner<TAddress> = TransactionSigner<TAddress>,\n TAccounts extends readonly AccountMetaWithSigner<TSigner>[] = readonly AccountMetaWithSigner<TSigner>[],\n> = Partial<TransactionMessageWithFeePayer<TAddress> | TransactionMessageWithFeePayerSigner<TAddress, TSigner>> &\n Pick<\n BaseTransactionMessage<TransactionVersion, Instruction & InstructionWithSigners<TSigner, TAccounts>>,\n 'instructions'\n >;\n\n/**\n * Extracts and deduplicates all {@link TransactionSigner | TransactionSigners} stored\n * inside the account metas of an {@link InstructionWithSigners | instruction}.\n *\n * Any extracted signers that share the same {@link Address} will be de-duplicated.\n *\n * @typeParam TSigner - Optionally provide a narrower type for {@link TransactionSigner | TransactionSigners}.\n *\n * @example\n * ```ts\n * import { InstructionWithSigners, getSignersFromInstruction } from '@solana/signers';\n *\n * const signerA = { address: address('1111..1111'), signTransactions: async () => {} };\n * const signerB = { address: address('2222..2222'), signTransactions: async () => {} };\n * const instructionWithSigners: InstructionWithSigners = {\n * accounts: [\n * { address: signerA.address, signer: signerA, ... },\n * { address: signerB.address, signer: signerB, ... },\n * { address: signerA.address, signer: signerA, ... },\n * ],\n * };\n *\n * const instructionSigners = getSignersFromInstruction(instructionWithSigners);\n * // ^ [signerA, signerB]\n * ```\n */\nexport function getSignersFromInstruction<TSigner extends TransactionSigner = TransactionSigner>(\n instruction: InstructionWithSigners<TSigner>,\n): readonly TSigner[] {\n return deduplicateSigners(\n (instruction.accounts ?? []).flatMap(account => ('signer' in account ? account.signer : [])),\n );\n}\n\n/**\n * Extracts and deduplicates all {@link TransactionSigner | TransactionSigners} stored\n * inside a given {@link TransactionMessageWithSigners | transaction message}.\n *\n * This includes any {@link TransactionSigner | TransactionSigners} stored\n * as the fee payer or in the instructions of the transaction message.\n *\n * Any extracted signers that share the same {@link Address} will be de-duplicated.\n *\n * @typeParam TAddress - Supply a string literal to define an account having a particular address.\n * @typeParam TSigner - Optionally provide a narrower type for {@link TransactionSigner | TransactionSigners}.\n * @typeParam TTransactionMessage - The inferred type of the transaction message provided.\n *\n * @example\n * ```ts\n * import { Instruction } from '@solana/instructions';\n * import { InstructionWithSigners, TransactionMessageWithSigners, getSignersFromTransactionMessage } from '@solana/signers';\n *\n * const signerA = { address: address('1111..1111'), signTransactions: async () => {} };\n * const signerB = { address: address('2222..2222'), signTransactions: async () => {} };\n * const firstInstruction: Instruction & InstructionWithSigners = {\n * programAddress: address('1234..5678'),\n * accounts: [{ address: signerA.address, signer: signerA, ... }],\n * };\n * const secondInstruction: Instruction & InstructionWithSigners = {\n * programAddress: address('1234..5678'),\n * accounts: [{ address: signerB.address, signer: signerB, ... }],\n * };\n * const transactionMessage: TransactionMessageWithSigners = {\n * feePayer: signerA,\n * instructions: [firstInstruction, secondInstruction],\n * }\n *\n * const transactionSigners = getSignersFromTransactionMessage(transactionMessage);\n * // ^ [signerA, signerB]\n * ```\n */\nexport function getSignersFromTransactionMessage<\n TAddress extends string = string,\n TSigner extends TransactionSigner<TAddress> = TransactionSigner<TAddress>,\n TTransactionMessage extends TransactionMessageWithSigners<TAddress, TSigner> = TransactionMessageWithSigners<\n TAddress,\n TSigner\n >,\n>(transaction: TTransactionMessage): readonly TSigner[] {\n return deduplicateSigners([\n ...(transaction.feePayer && isTransactionSigner(transaction.feePayer) ? [transaction.feePayer as TSigner] : []),\n ...transaction.instructions.flatMap(getSignersFromInstruction),\n ]);\n}\n","import { Address } from '@solana/addresses';\nimport { Instruction, isSignerRole } from '@solana/instructions';\nimport { BaseTransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\n\nimport { AccountSignerMeta, InstructionWithSigners, TransactionMessageWithSigners } from './account-signer-meta';\nimport { deduplicateSigners } from './deduplicate-signers';\nimport { isTransactionSigner, TransactionSigner } from './transaction-signer';\n\n/**\n * Attaches the provided {@link TransactionSigner | TransactionSigners} to the\n * account metas of an instruction when applicable.\n *\n * For an account meta to match a provided signer it:\n * - Must have a signer role ({@link AccountRole.READONLY_SIGNER} or {@link AccountRole.WRITABLE_SIGNER}).\n * - Must have the same address as the provided signer.\n * - Must not have an attached signer already.\n *\n * @typeParam TInstruction - The inferred type of the instruction provided.\n *\n * @example\n * ```ts\n * import { AccountRole, Instruction } from '@solana/instructions';\n * import { addSignersToInstruction, TransactionSigner } from '@solana/signers';\n *\n * const instruction: Instruction = {\n * accounts: [\n * { address: '1111' as Address, role: AccountRole.READONLY_SIGNER },\n * { address: '2222' as Address, role: AccountRole.WRITABLE_SIGNER },\n * ],\n * // ...\n * };\n *\n * const signerA: TransactionSigner<'1111'>;\n * const signerB: TransactionSigner<'2222'>;\n * const instructionWithSigners = addSignersToInstruction(\n * [signerA, signerB],\n * instruction\n * );\n *\n * // instructionWithSigners.accounts[0].signer === signerA\n * // instructionWithSigners.accounts[1].signer === signerB\n * ```\n */\nexport function addSignersToInstruction<TInstruction extends Instruction>(\n signers: TransactionSigner[],\n instruction: TInstruction | (InstructionWithSigners & TInstruction),\n): InstructionWithSigners & TInstruction {\n if (!instruction.accounts || instruction.accounts.length === 0) {\n return instruction as InstructionWithSigners & TInstruction;\n }\n\n const signerByAddress = new Map(deduplicateSigners(signers).map(signer => [signer.address, signer]));\n return Object.freeze({\n ...instruction,\n accounts: instruction.accounts.map(account => {\n const signer = signerByAddress.get(account.address);\n if (!isSignerRole(account.role) || 'signer' in account || !signer) {\n return account;\n }\n return Object.freeze({ ...account, signer } as AccountSignerMeta);\n }),\n });\n}\n\n/**\n * Attaches the provided {@link TransactionSigner | TransactionSigners} to the\n * account metas of all instructions inside a transaction message and/or\n * the transaction message fee payer, when applicable.\n *\n * For an account meta to match a provided signer it:\n * - Must have a signer role ({@link AccountRole.READONLY_SIGNER} or {@link AccountRole.WRITABLE_SIGNER}).\n * - Must have the same address as the provided signer.\n * - Must not have an attached signer already.\n *\n * @typeParam TTransactionMessage - The inferred type of the transaction message provided.\n *\n * @example\n * ```ts\n * import { AccountRole, Instruction } from '@solana/instructions';\n * import { BaseTransactionMessage } from '@solana/transaction-messages';\n * import { addSignersToTransactionMessage, TransactionSigner } from '@solana/signers';\n *\n * const instructionA: Instruction = {\n * accounts: [{ address: '1111' as Address, role: AccountRole.READONLY_SIGNER }],\n * // ...\n * };\n * const instructionB: Instruction = {\n * accounts: [{ address: '2222' as Address, role: AccountRole.WRITABLE_SIGNER }],\n * // ...\n * };\n * const transactionMessage: BaseTransactionMessage = {\n * instructions: [instructionA, instructionB],\n * // ...\n * }\n *\n * const signerA: TransactionSigner<'1111'>;\n * const signerB: TransactionSigner<'2222'>;\n * const transactionMessageWithSigners = addSignersToTransactionMessage(\n * [signerA, signerB],\n * transactionMessage\n * );\n *\n * // transactionMessageWithSigners.instructions[0].accounts[0].signer === signerA\n * // transactionMessageWithSigners.instructions[1].accounts[0].signer === signerB\n * ```\n */\nexport function addSignersToTransactionMessage<TTransactionMessage extends BaseTransactionMessage>(\n signers: TransactionSigner[],\n transactionMessage: TTransactionMessage | (TransactionMessageWithSigners & TTransactionMessage),\n): TransactionMessageWithSigners & TTransactionMessage {\n const feePayerSigner = hasAddressOnlyFeePayer(transactionMessage)\n ? signers.find(signer => signer.address === transactionMessage.feePayer.address)\n : undefined;\n\n if (!feePayerSigner && transactionMessage.instructions.length === 0) {\n return transactionMessage as TransactionMessageWithSigners & TTransactionMessage;\n }\n\n return Object.freeze({\n ...transactionMessage,\n ...(feePayerSigner ? { feePayer: feePayerSigner } : null),\n instructions: transactionMessage.instructions.map(instruction => addSignersToInstruction(signers, instruction)),\n });\n}\n\nfunction hasAddressOnlyFeePayer(\n message: BaseTransactionMessage & Partial<TransactionMessageWithFeePayer>,\n): message is BaseTransactionMessage & { feePayer: { address: Address } } {\n return (\n !!message &&\n 'feePayer' in message &&\n !!message.feePayer &&\n typeof message.feePayer.address === 'string' &&\n !isTransactionSigner(message.feePayer)\n );\n}\n","import { TransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\n\nimport { TransactionSigner } from './transaction-signer';\n\n/**\n * Alternative to {@link TransactionMessageWithFeePayer} that uses a {@link TransactionSigner} for the fee payer.\n *\n * @typeParam TAddress - Supply a string literal to define a fee payer having a particular address.\n * @typeParam TSigner - Optionally provide a narrower type for the {@link TransactionSigner}.\n *\n * @example\n * ```ts\n * import { TransactionMessage } from '@solana/transaction-messages';\n * import { generateKeyPairSigner, TransactionMessageWithFeePayerSigner } from '@solana/signers';\n *\n * const transactionMessage: TransactionMessage & TransactionMessageWithFeePayerSigner = {\n * feePayer: await generateKeyPairSigner(),\n * instructions: [],\n * version: 0,\n * };\n * ```\n */\nexport interface TransactionMessageWithFeePayerSigner<\n TAddress extends string = string,\n TSigner extends TransactionSigner<TAddress> = TransactionSigner<TAddress>,\n> {\n readonly feePayer: TSigner;\n}\n\n/**\n * A helper type to exclude the fee payer from a transaction message.\n */\ntype ExcludeTransactionMessageFeePayer<TTransactionMessage extends TransactionMessage> =\n TTransactionMessage extends unknown ? Omit<TTransactionMessage, 'feePayer'> : never;\n\n/**\n * Sets the fee payer of a {@link TransactionMessage | transaction message}\n * using a {@link TransactionSigner}.\n *\n * @typeParam TFeePayerAddress - Supply a string literal to define a fee payer having a particular address.\n * @typeParam TTransactionMessage - The inferred type of the transaction message provided.\n *\n * @example\n * ```ts\n * import { pipe } from '@solana/functional';\n * import { generateKeyPairSigner, setTransactionMessageFeePayerSigner } from '@solana/signers';\n * import { createTransactionMessage } from '@solana/transaction-messages';\n *\n * const feePayer = await generateKeyPairSigner();\n * const transactionMessage = pipe(\n * createTransactionMessage({ version: 0 }),\n * message => setTransactionMessageFeePayerSigner(signer, message),\n * );\n * ```\n */\nexport function setTransactionMessageFeePayerSigner<\n TFeePayerAddress extends string,\n TTransactionMessage extends Partial<TransactionMessageWithFeePayer | TransactionMessageWithFeePayerSigner> &\n TransactionMessage,\n>(\n feePayer: TransactionSigner<TFeePayerAddress>,\n transactionMessage: TTransactionMessage,\n): ExcludeTransactionMessageFeePayer<TTransactionMessage> & TransactionMessageWithFeePayerSigner<TFeePayerAddress> {\n Object.freeze(feePayer);\n const out = { ...transactionMessage, feePayer };\n Object.freeze(out);\n return out as ExcludeTransactionMessageFeePayer<TTransactionMessage> &\n TransactionMessageWithFeePayerSigner<TFeePayerAddress>;\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_PARTIAL_SIGNER, SolanaError } from '@solana/errors';\n\nimport { SignableMessage } from './signable-message';\nimport { BaseSignerConfig, SignatureDictionary } from './types';\n\n/**\n * The configuration to optionally provide when calling the\n * {@link MessagePartialSigner#signMessages | signMessages} method.\n *\n * @see {@link BaseSignerConfig}\n */\nexport type MessagePartialSignerConfig = BaseSignerConfig;\n\n/**\n * A signer interface that signs an array of {@link SignableMessage | SignableMessages}\n * without modifying their content.\n *\n * It defines a {@link MessagePartialSigner#signMessages | signMessages} function\n * that returns a {@link SignatureDictionary} for each provided message.\n * Such signature dictionaries are expected to be merged with the existing ones if any.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * const signer: MessagePartialSigner<'1234..5678'> = {\n * address: address('1234..5678'),\n * signMessages: async (\n * messages: SignableMessage[]\n * ): Promise<SignatureDictionary[]> => {\n * // My custom signing logic.\n * },\n * };\n * ```\n *\n * @remarks\n * Here are the main characteristics of this signer interface:\n *\n * - **Parallel**. When multiple signers sign the same message, we can\n * perform this operation in parallel to obtain all their signatures.\n * - **Flexible order**. The order in which we use these signers\n * for a given message doesn’t matter.\n *\n * @see {@link SignableMessage}\n * @see {@link createSignableMessage}\n * @see {@link isMessagePartialSigner}\n * @see {@link assertIsMessagePartialSigner}\n */\nexport type MessagePartialSigner<TAddress extends string = string> = Readonly<{\n address: Address<TAddress>;\n signMessages(\n messages: readonly SignableMessage[],\n config?: MessagePartialSignerConfig,\n ): Promise<readonly SignatureDictionary[]>;\n}>;\n\n/**\n * Checks whether the provided value implements the {@link MessagePartialSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isMessagePartialSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isMessagePartialSigner({ address, signMessages: async () => {} }); // true\n * isMessagePartialSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsMessagePartialSigner}\n */\nexport function isMessagePartialSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is MessagePartialSigner<TAddress> {\n return 'signMessages' in value && typeof value.signMessages === 'function';\n}\n\n/**\n * Asserts that the provided value implements the {@link MessagePartialSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsMessagePartialSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsMessagePartialSigner({ address, signMessages: async () => {} }); // void\n * assertIsMessagePartialSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isMessagePartialSigner}\n */\nexport function assertIsMessagePartialSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is MessagePartialSigner<TAddress> {\n if (!isMessagePartialSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_PARTIAL_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address, getAddressFromPublicKey } from '@solana/addresses';\nimport { ReadonlyUint8Array } from '@solana/codecs-core';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_KEY_PAIR_SIGNER, SolanaError } from '@solana/errors';\nimport { createKeyPairFromBytes, createKeyPairFromPrivateKeyBytes, 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/**\n * Defines a signer that uses a {@link CryptoKeyPair} to sign messages and transactions.\n *\n * It implements both the {@link MessagePartialSigner} and {@link TransactionPartialSigner}\n * interfaces and keeps track of the {@link CryptoKeyPair} instance used\n * to sign messages and transactions.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * import { generateKeyPairSigner } from '@solana/signers';\n *\n * const signer = generateKeyPairSigner();\n * signer.address; // Address;\n * signer.keyPair; // CryptoKeyPair;\n * const [messageSignatures] = await signer.signMessages([message]);\n * const [transactionSignatures] = await signer.signTransactions([transaction]);\n * ```\n *\n * @see {@link generateKeyPairSigner}\n * @see {@link createSignerFromKeyPair}\n * @see {@link createKeyPairSignerFromBytes}\n * @see {@link createKeyPairSignerFromPrivateKeyBytes}\n * @see {@link isKeyPairSigner}\n * @see {@link assertIsKeyPairSigner}\n */\nexport type KeyPairSigner<TAddress extends string = string> = MessagePartialSigner<TAddress> &\n TransactionPartialSigner<TAddress> & { keyPair: CryptoKeyPair };\n\n/**\n * Checks whether the provided value implements the {@link KeyPairSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { generateKeyPairSigner, isKeyPairSigner } from '@solana/signers';\n *\n * const signer = await generateKeyPairSigner();\n * isKeyPairSigner(signer); // true\n * isKeyPairSigner({ address: address('1234..5678') }); // false\n * ```\n */\nexport function isKeyPairSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\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/**\n * Asserts that the provided value implements the {@link KeyPairSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { generateKeyPairSigner, assertIsKeyPairSigner } from '@solana/signers';\n *\n * const signer = await generateKeyPairSigner();\n * assertIsKeyPairSigner(signer); // void\n * assertIsKeyPairSigner({ address: address('1234..5678') }); // Throws an error.\n * ```\n */\nexport function assertIsKeyPairSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is KeyPairSigner<TAddress> {\n if (!isKeyPairSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_KEY_PAIR_SIGNER, {\n address: value.address,\n });\n }\n}\n\n/**\n * Creates a {@link KeyPairSigner} from a provided {@link CryptoKeyPair}.\n *\n * The {@link MessagePartialSigner#signMessages | signMessages} and\n * {@link TransactionPartialSigner#signTransactions | signTransactions}\n * functions of the returned signer will use the private key of the provided\n * key pair to sign messages and transactions.\n *\n * Note that both the {@link MessagePartialSigner#signMessages | signMessages} and\n * {@link TransactionPartialSigner#signTransactions | signTransactions} implementations\n * are parallelized, meaning that they will sign all provided messages and transactions in parallel.\n *\n * @example\n * ```ts\n * import { generateKeyPair } from '@solana/keys';\n * import { createSignerFromKeyPair, KeyPairSigner } from '@solana/signers';\n *\n * const keyPair: CryptoKeyPair = await generateKeyPair();\n * const signer: KeyPairSigner = await createSignerFromKeyPair(keyPair);\n * ```\n */\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 // we know that the address has signed `signedTransaction` because it comes from the keypair\n return Object.freeze({ [address]: signedTransaction.signatures[address]! });\n }),\n ),\n };\n\n return Object.freeze(out);\n}\n\n/**\n * Generates a signer capable of signing messages and transactions by generating\n * a {@link CryptoKeyPair} and creating a {@link KeyPairSigner} from it.\n *\n * @example\n * ```ts\n * import { generateKeyPairSigner } from '@solana/signers';\n *\n * const signer = await generateKeyPairSigner();\n * ```\n *\n * @see {@link createSignerFromKeyPair}\n */\nexport async function generateKeyPairSigner(): Promise<KeyPairSigner> {\n return await createSignerFromKeyPair(await generateKeyPair());\n}\n\n/**\n * Creates a new {@link KeyPairSigner} from a 64-bytes `Uint8Array` secret key (private key and public key).\n *\n * @example\n * ```ts\n * import fs from 'fs';\n * import { createKeyPairSignerFromBytes } from '@solana/signers';\n *\n * // Get bytes from local keypair file.\n * const keypairFile = fs.readFileSync('~/.config/solana/id.json');\n * const keypairBytes = new Uint8Array(JSON.parse(keypairFile.toString()));\n *\n * // Create a KeyPairSigner from the bytes.\n * const signer = await createKeyPairSignerFromBytes(keypairBytes);\n * ```\n *\n * @see {@link createKeyPairSignerFromPrivateKeyBytes} if you only have the 32-bytes private key instead.\n */\nexport async function createKeyPairSignerFromBytes(\n bytes: ReadonlyUint8Array,\n extractable?: boolean,\n): Promise<KeyPairSigner> {\n return await createSignerFromKeyPair(await createKeyPairFromBytes(bytes, extractable));\n}\n\n/**\n * Creates a new {@link KeyPairSigner} from a 32-bytes `Uint8Array` private key.\n *\n * @example\n * ```ts\n * import { getUtf8Encoder } from '@solana/codecs-strings';\n * import { createKeyPairSignerFromPrivateKeyBytes } from '@solana/signers';\n *\n * const message = getUtf8Encoder().encode('Hello, World!');\n * const seed = new Uint8Array(await crypto.subtle.digest('SHA-256', message));\n *\n * const derivedSigner = await createKeyPairSignerFromPrivateKeyBytes(seed);\n * ```\n *\n * @see {@link createKeyPairSignerFromBytes} if you have the 64-bytes secret key instead (private key and public key).\n */\nexport async function createKeyPairSignerFromPrivateKeyBytes(\n bytes: ReadonlyUint8Array,\n extractable?: boolean,\n): Promise<KeyPairSigner> {\n return await createSignerFromKeyPair(await createKeyPairFromPrivateKeyBytes(bytes, extractable));\n}\n","import { Address, isAddress } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_MODIFYING_SIGNER, SolanaError } from '@solana/errors';\n\nimport { SignableMessage } from './signable-message';\nimport { BaseSignerConfig } from './types';\n\n/**\n * The configuration to optionally provide when calling the\n * {@link MessageModifyingSigner#modifyAndSignMessages | modifyAndSignMessages} method.\n *\n * @see {@link BaseSignerConfig}\n */\nexport type MessageModifyingSignerConfig = BaseSignerConfig;\n\n/**\n * A signer interface that _potentially_ modifies the content\n * of the provided {@link SignableMessage | SignableMessages} before signing them.\n *\n * For instance, this enables wallets to prefix or suffix nonces to the messages they sign.\n * For each message, instead of returning a {@link SignatureDictionary}, the\n * {@link MessageModifyingSigner#modifyAndSignMessages | modifyAndSignMessages} function\n * returns an updated {@link SignableMessage} with a potentially modified content and signature dictionary.\n *\n * @typeParam TAddress - Supply a string literal to define a signer having a particular address.\n *\n * @example\n * ```ts\n * const signer: MessageModifyingSigner<'1234..5678'> = {\n * address: address('1234..5678'),\n * modifyAndSignMessages: async (\n * messages: SignableMessage[]\n * ): Promise<SignableMessage[]> => {\n * // My custom signing logic.\n * },\n * };\n * ```\n *\n * @remarks\n * Here are the main characteristics of this signer interface:\n *\n * - **Sequential**. Contrary to partial signers, these cannot be executed in\n * parallel as each call can modify the content of the message.\n * - **First signers**. For a given message, a modifying signer must always be used\n * before a partial signer as the former will likely modify the message and\n * thus impact the outcome of the latter.\n * - **Potential conflicts**. If more than one modifying signer is provided, the second\n * signer may invalidate the signature of the first one. However, modifying signers\n * may decide not to modify a message based on the existence of signatures for that message.\n *\n * @see {@link SignableMessage}\n * @see {@link createSignableMessage}\n * @see {@link isMessageModifyingSigner}\n * @see {@link assertIsMessageModifyingSigner}\n */\nexport type MessageModifyingSigner<TAddress extends string = string> = Readonly<{\n address: Address<TAddress>;\n modifyAndSignMessages(\n messages: readonly SignableMessage[],\n config?: MessageModifyingSignerConfig,\n ): Promise<readonly SignableMessage[]>;\n}>;\n\n/**\n * Checks whether the provided value implements the {@link MessageModifyingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isMessageModifyingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isMessageModifyingSigner({ address, modifyAndSignMessages: async () => {} }); // true\n * isMessageModifyingSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsMessageModifyingSigner}\n */\nexport function isMessageModifyingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is MessageModifyingSigner<TAddress> {\n return (\n isAddress(value.address) &&\n 'modifyAndSignMessages' in value &&\n typeof value.modifyAndSignMessages === 'function'\n );\n}\n\n/**\n * Asserts that the provided value implements the {@link MessageModifyingSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsMessageModifyingSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsMessageModifyingSigner({ address, modifyAndSignMessages: async () => {} }); // void\n * assertIsMessageModifyingSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isMessageModifyingSigner}\n */\nexport function assertIsMessageModifyingSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is MessageModifyingSigner<TAddress> {\n if (!isMessageModifyingSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_MODIFYING_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address } from '@solana/addresses';\nimport { SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_SIGNER, SolanaError } from '@solana/errors';\n\nimport { isMessageModifyingSigner, MessageModifyingSigner } from './message-modifying-signer';\nimport { isMessagePartialSigner, MessagePartialSigner } from './message-partial-signer';\n\n/**\n * Defines a signer capable of signing messages.\n *\n * @see {@link MessageModifyingSigner} For signers that can modify messages before signing them.\n * @see {@link MessagePartialSigner} For signers that can be used in parallel.\n * @see {@link isMessageSigner}\n * @see {@link assertIsMessageSigner}\n */\nexport type MessageSigner<TAddress extends string = string> =\n | MessageModifyingSigner<TAddress>\n | MessagePartialSigner<TAddress>;\n\n/**\n * Checks whether the provided value implements the {@link MessageSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { isMessageSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * isMessageSigner({ address, signMessages: async () => {} }); // true\n * isMessageSigner({ address, modifyAndSignMessages: async () => {} }); // true\n * isMessageSigner({ address }); // false\n * ```\n *\n * @see {@link assertIsMessageSigner}\n */\nexport function isMessageSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): value is MessageSigner<TAddress> {\n return isMessagePartialSigner(value) || isMessageModifyingSigner(value);\n}\n\n/**\n * Asserts that the provided value implements the {@link MessageSigner} interface.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { Address } from '@solana/addresses';\n * import { assertIsMessageSigner } from '@solana/signers';\n *\n * const address = '1234..5678' as Address<'1234..5678'>;\n * assertIsMessageSigner({ address, signMessages: async () => {} }); // void\n * assertIsMessageSigner({ address, modifyAndSignMessages: async () => {} }); // void\n * assertIsMessageSigner({ address }); // Throws an error.\n * ```\n *\n * @see {@link isMessageSigner}\n */\nexport function assertIsMessageSigner<TAddress extends string>(value: {\n [key: string]: unknown;\n address: Address<TAddress>;\n}): asserts value is MessageSigner<TAddress> {\n if (!isMessageSigner(value)) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_SIGNER, {\n address: value.address,\n });\n }\n}\n","import { Address } from '@solana/addresses';\n\nimport { MessagePartialSigner } from './message-partial-signer';\nimport { TransactionPartialSigner } from './transaction-partial-signer';\n\n/**\n * Defines a Noop (No-Operation) signer that pretends to partially sign messages and transactions.\n *\n * For a given {@link Address}, a Noop Signer can be created to offer an implementation of both\n * the {@link MessagePartialSigner} and {@link TransactionPartialSigner} interfaces such that\n * they do not sign anything. Namely, signing a transaction or a message with a `NoopSigner`\n * will return an empty `SignatureDictionary`.\n *\n * @typeParam TAddress - Supply a string literal to define a Noop signer having a particular address.\n *\n * @example\n * ```ts\n * import { address } from '@solana/addresses';\n * import { createNoopSigner } from '@solana/signers';\n *\n * const signer = createNoopSigner(address('1234..5678'));\n * const [messageSignatures] = await signer.signMessages([message]);\n * const [transactionSignatures] = await signer.signTransactions([transaction]);\n * // ^ Both messageSignatures and transactionSignatures are empty.\n * ```\n *\n * @remarks\n * This signer may be useful:\n *\n * - For testing purposes.\n * - For indicating that a given account is a signer and taking the responsibility to provide\n * the signature for that account ourselves. For instance, if we need to send the transaction\n * to a server that will sign it and send it for us.\n *\n * @see {@link createNoopSigner}\n */\nexport type NoopSigner<TAddress extends string = string> = MessagePartialSigner<TAddress> &\n TransactionPartialSigner<TAddress>;\n\n/**\n * Creates a {@link NoopSigner} from the provided {@link Address}.\n *\n * @typeParam TAddress - The inferred type of the address provided.\n *\n * @example\n * ```ts\n * import { address } from '@solana/addresses';\n * import { createNoopSigner } from '@solana/signers';\n *\n * const signer = createNoopSigner(address('1234..5678'));\n * ```\n */\nexport function createNoopSigner<TAddress extends string = string>(address: Address<TAddress>): NoopSigner<TAddress> {\n const out: NoopSigner<TAddress> = {\n address,\n signMessages: messages => Promise.resolve(messages.map(() => Object.freeze({}))),\n signTransactions: transactions => Promise.resolve(transactions.map(() => Object.freeze({}))),\n };\n\n return Object.freeze(out);\n}\n","import { OffchainMessageWithRequiredSignatories } from '@solana/offchain-messages';\n\nimport { deduplicateSigners } from './deduplicate-signers';\nimport { isMessageSigner, MessageSigner } from './message-signer';\n\n/**\n * Represents a {@link Signer} that is required to sign an offchain message for it to be valid.\n */\nexport type OffchainMessageSignatorySigner<TAddress extends string = string> = MessageSigner<TAddress>;\n\n/**\n * Extracts and deduplicates all {@link MessageSigner | MessageSigners} stored inside a given\n * {@link OffchainMessageWithSigners | offchain message}.\n *\n * Any extracted signers that share the same {@link Address} will be de-duplicated.\n *\n * @typeParam TAddress - Supply a string literal to define an account having a particular address.\n * @typeParam TSigner - Optionally provide a narrower type for {@link MessageSigner | MessageSigners}.\n * @typeParam TOffchainMessage - The inferred type of the offchain message provided.\n *\n * @example\n * ```ts\n * import { OffchainMessageWithSigners, getSignersFromOffchainMessage } from '@solana/signers';\n *\n * const signerA = { address: address('1111..1111'), signMessages: async () => {} };\n * const signerB = { address: address('2222..2222'), modifyAndSignMessages: async () => {} };\n * const OffchainMessage: OffchainMessageWithSigners = {\n * /* ... *\\/\n * requiredSignatories: [signerA, signerB],\n * };\n *\n * const messageSigners = getSignersFromOffchainMessage(offchainMessage);\n * // ^ [signerA, signerB]\n * ```\n */\nexport function getSignersFromOffchainMessage({\n requiredSignatories,\n}: OffchainMessageWithRequiredSignatories): readonly MessageSigner[] {\n const messageSigners = requiredSignatories.filter(isMessageSigner);\n return deduplicateSigners(messageSigners);\n}\n","import {\n assertIsFullySignedOffchainMessageEnvelope,\n compileOffchainMessageEnvelope,\n FullySignedOffchainMessageEnvelope,\n OffchainMessage,\n OffchainMessageEnvelope,\n OffchainMessageSignatory,\n OffchainMessageWithRequiredSignatories,\n} from '@solana/offchain-messages';\n\nimport {\n isMessageModifyingSigner,\n MessageModifyingSigner,\n MessageModifyingSignerConfig,\n} from './message-modifying-signer';\nimport { isMessagePartialSigner, MessagePartialSigner, MessagePartialSignerConfig } from './message-partial-signer';\nimport { MessageSigner } from './message-signer';\nimport { getSignersFromOffchainMessage, OffchainMessageSignatorySigner } from './offchain-message-signer';\nimport { SignableMessage } from './signable-message';\n\n/**\n * Extracts all {@link MessageSigner | MessageSigners} inside the provided offchain message and uses\n * them to return a signed offchain message envelope.\n *\n * It first uses all {@link MessageModifyingSigner | MessageModifyingSigners} sequentially before\n * using all {@link MessagePartialSigner | MessagePartialSigners} in parallel.\n *\n * If a composite signer implements both interfaces, it will be used as a\n * {@link MessageModifyingSigner} if no other signer implements that interface. Otherwise, it will\n * be used as a {@link MessagePartialSigner}.\n *\n * @example\n * ```ts\n * const signedOffchainMessageEnvelope = await partiallySignOffchainMessageWithSigners(offchainMessage);\n * ```\n *\n * It also accepts an optional {@link AbortSignal} that will be propagated to all signers.\n *\n * ```ts\n * const signedOffchainMessageEnvelope = await partiallySignOffchainMessageWithSigners(offchainMessage, {\n * abortSignal: myAbortController.signal,\n * });\n * ```\n *\n * @see {@link signOffchainMessageWithSigners}\n */\nexport async function partiallySignOffchainMessageWithSigners(\n offchainMessage: OffchainMessageWithRequiredSignatories<OffchainMessageSignatory | OffchainMessageSignatorySigner> &\n Omit<OffchainMessage, 'requiredSignatories'>,\n config?: MessagePartialSignerConfig,\n): Promise<OffchainMessageEnvelope> {\n const { partialSigners, modifyingSigners } = categorizeMessageSigners(\n getSignersFromOffchainMessage(offchainMessage),\n );\n return await signModifyingAndPartialMessageSigners(offchainMessage, modifyingSigners, partialSigners, config);\n}\n\n/**\n * Extracts all {@link MessageSigner | MessageSigners} inside the provided offchain message and uses\n * them to return a signed offchain message envelope before asserting that all signatures required\n * by the message are present.\n *\n * This function delegates to the {@link partiallySignOffchainMessageWithSigners} function\n * in order to extract signers from the offchain message and sign it.\n *\n * @example\n * ```ts\n * const mySignedOffchainMessageEnvelope = await signOffchainMessageWithSigners(myOffchainMessage);\n *\n * // With additional config.\n * const mySignedOffchainMessageEnvelope = await signOffchainMessageWithSigners(myOffchainMessage, {\n * abortSignal: myAbortController.signal,\n * });\n *\n * // We now know the offchain message is fully signed.\n * mySignedOffchainMessageEnvelope satisfies FullySignedOffchainMessageEnvelope;\n * ```\n *\n * @see {@link partiallySignOffchainMessageWithSigners}\n */\nexport async function signOffchainMessageWithSigners(\n offchainMessage: OffchainMessageWithRequiredSignatories<OffchainMessageSignatory | OffchainMessageSignatorySigner> &\n Omit<OffchainMessage, 'requiredSignatories'>,\n config?: MessagePartialSignerConfig,\n): Promise<FullySignedOffchainMessageEnvelope & OffchainMessageEnvelope> {\n const signedOffchainMessageEnvelope = await partiallySignOffchainMessageWithSigners(offchainMessage, config);\n assertIsFullySignedOffchainMessageEnvelope(signedOffchainMessageEnvelope);\n return signedOffchainMessageEnvelope;\n}\n\n/**\n * Identifies each provided {@link MessageSigner} and categorizes them into their respective types.\n * When a signer implements multiple interfaces, it will try to used to most powerful interface but\n * fall back to the least powerful interface when necessary.\n *\n * For instance, if a signer implements {@link MessageSigner} and {@link MessageModifyingSigner},\n * it will be categorized as a `MessageModifyingSigner`.\n */\nfunction categorizeMessageSigners(signers: readonly MessageSigner[]): Readonly<{\n modifyingSigners: readonly MessageModifyingSigner[];\n partialSigners: readonly MessagePartialSigner[];\n}> {\n // Identify the modifying signers from the other signers.\n const modifyingSigners = identifyMessageModifyingSigners(signers);\n\n // Use any remaining signers as partial signers.\n const partialSigners = signers\n .filter(isMessagePartialSigner)\n .filter(signer => !(modifyingSigners as typeof signers).includes(signer));\n\n return Object.freeze({ modifyingSigners, partialSigners });\n}\n\n/** Identifies the best signers to use as MessageModifyingSigners, if any */\nfunction identifyMessageModifyingSigners(\n signers: readonly (MessageModifyingSigner | MessagePartialSigner)[],\n): readonly MessageModifyingSigner[] {\n // Ensure there are any MessageModifyingSigner in the first place.\n const modifyingSigners = signers.filter(isMessageModifyingSigner);\n if (modifyingSigners.length === 0) return [];\n\n // Prefer modifying signers that do not offer partial signing.\n const nonPartialSigners = modifyingSigners.filter(signer => !isMessagePartialSigner(signer));\n if (nonPartialSigners.length > 0) return nonPartialSigners;\n\n // Otherwise, choose only one modifying signer (whichever).\n return [modifyingSigners[0]];\n}\n\n/**\n * Signs an offchain message using the provided\n * {@link MessageModifyingSigner | MessageModifyingSigners} sequentially followed by the\n * {@link MessagePartialSigner | MessagePartialSigners} in parallel.\n */\nasync function signModifyingAndPartialMessageSigners(\n offchainMessage: OffchainMessageWithRequiredSignatories<OffchainMessageSignatory | OffchainMessageSignatorySigner> &\n Omit<OffchainMessage, 'requiredSignatories'>,\n modifyingSigners: readonly MessageModifyingSigner[] = [],\n partialSigners: readonly MessagePartialSigner[] = [],\n config?: MessageModifyingSignerConfig,\n): Promise<OffchainMessageEnvelope> {\n // @ts-expect-error SignableMessage should probably specify `ReadonlyUint8Array` here.\n const offchainMessageEnvelope: SignableMessage = compileOffchainMessageEnvelope(offchainMessage);\n\n // Handle modifying signers sequentially.\n const modifiedOffchainMessage = await modifyingSigners.reduce(async (offchainMessageEnvelope, modifyingSigner) => {\n config?.abortSignal?.throwIfAborted();\n const [message] = await modifyingSigner.modifyAndSignMessages([await offchainMessageEnvelope], config);\n return Object.freeze(message);\n }, Promise.resolve(offchainMessageEnvelope));\n\n // Handle partial signers in parallel.\n config?.abortSignal?.throwIfAborted();\n const signatureDictionaries = await Promise.all(\n partialSigners.map(async partialSigner => {\n const [signatures] = await partialSigner.signMessages([modifiedOffchainMessage], config);\n return signatures;\n }),\n );\n\n // @ts-expect-error SignableMessage should probably specify `ReadonlyUint8Array` here.\n return Object.freeze({\n ...modifiedOffchainMessage,\n signatures: Object.freeze(\n signatureDictionaries.reduce((signatures, signatureDictionary) => {\n return { ...signatures, ...signatureDictionary };\n }, modifiedOffchainMessage.signatures ?? {}),\n ),\n } as OffchainMessageEnvelope);\n}\n","import {\n SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS,\n SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING,\n SolanaError,\n} from '@solana/errors';\nimport { Brand } from '@solana/nominal-types';\nimport { BaseTransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\n\nimport { getSignersFromTransactionMessage, TransactionMessageWithSigners } from './account-signer-meta';\nimport { isTransactionModifyingSigner } from './transaction-modifying-signer';\nimport { isTransactionPartialSigner } from './transaction-partial-signer';\nimport { isTransactionSendingSigner } from './transaction-sending-signer';\n\n/**\n * Defines a transaction message with exactly one {@link TransactionSendingSigner}.\n *\n * This type is used to narrow the type of transaction messages that have been\n * checked to have exactly one sending signer.\n *\n * @example\n * ```ts\n * import { assertIsTransactionMessageWithSingleSendingSigner } from '@solana/signers';\n *\n * assertIsTransactionMessageWithSingleSendingSigner(transactionMessage);\n * transactionMessage satisfies TransactionMessageWithSingleSendingSigner;\n * ```\n *\n * @see {@link isTransactionMessageWithSingleSendingSigner}\n * @see {@link assertIsTransactionMessageWithSingleSendingSigner}\n */\nexport type TransactionMessageWithSingleSendingSigner = Brand<\n TransactionMessageWithSigners,\n 'TransactionMessageWithSingleSendingSigner'\n>;\n\n/**\n * Checks whether the provided transaction has exactly one {@link TransactionSendingSigner}.\n *\n * This can be useful when using {@link signAndSendTransactionMessageWithSigners} to provide\n * a fallback strategy in case the transaction message cannot be send using this function.\n *\n * @typeParam TTransactionMessage - The inferred type of the transaction message provided.\n *\n * @example\n * ```ts\n * import {\n * isTransactionMessageWithSingleSendingSigner,\n * signAndSendTransactionMessageWithSigners,\n * signTransactionMessageWithSigners,\n * } from '@solana/signers';\n * import { getBase64EncodedWireTransaction } from '@solana/transactions';\n *\n * let transactionSignature: SignatureBytes;\n * if (isTransactionMessageWithSingleSendingSigner(transactionMessage)) {\n * transactionSignature = await signAndSendTransactionMessageWithSigners(transactionMessage);\n * } else {\n * const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);\n * const encodedTransaction = getBase64EncodedWireTransaction(signedTransaction);\n * transactionSignature = await rpc.sendTransaction(encodedTransaction).send();\n * }\n * ```\n *\n * @see {@link signAndSendTransactionMessageWithSigners}\n * @see {@link assertIsTransactionMessageWithSingleSendingSigner}\n */\nexport function isTransactionMessageWithSingleSendingSigner<\n TTransactionMessage extends BaseTransactionMessage & TransactionMessageWithFeePayer,\n>(transaction: TTransactionMessage): transaction is TransactionMessageWithSingleSendingSigner & TTransactionMessage {\n try {\n assertIsTransactionMessageWithSingleSendingSigner(transaction);\n return true;\n } catch {\n return false;\n }\n}\n\n/**\n * Asserts that the provided transaction message has exactly one {@link TransactionSendingSigner}.\n *\n * This can be useful when using the {@link signAndSendTransactionMessageWithSigners} function\n * to ensure it will be able to select the correct signer to send the transaction.\n *\n * @typeParam TTransactionMessage - The inferred type of the transaction message provided.\n *\n * @example\n * ```ts\n * import {\n * assertIsTransactionMessageWithSingleSendingSigner,\n * signAndSendTransactionMessageWithSigners\n * } from '@solana/signers';\n *\n * assertIsTransactionMessageWithSingleSendingSigner(transactionMessage);\n * const transactionSignature = await signAndSendTransactionMessageWithSigners(transactionMessage);\n * ```\n *\n * @see {@link signAndSendTransactionMessageWithSigners}\n * @see {@link isTransactionMessageWithSingleSendingSigner}\n */\nexport function assertIsTransactionMessageWithSingleSendingSigner<\n TTransactionMessage extends BaseTransactionMessage & TransactionMessageWithFeePayer,\n>(\n transaction: TTransactionMessage,\n): asserts transaction is TransactionMessageWithSingleSendingSigner & TTransactionMessage {\n const signers = getSignersFromTransactionMessage(transaction);\n const sendingSigners = signers.filter(isTransactionSendingSigner);\n\n if (sendingSigners.length === 0) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING);\n }\n\n // When identifying if there are multiple sending signers, we only need to check for\n // sending signers that do not implement other transaction signer interfaces as\n // they will be used as these other signer interfaces in case of a conflict.\n const sendingOnlySigners = sendingSigners.filter(\n signer => !isTransactionPartialSigner(signer) && !isTransactionModifyingSigner(signer),\n );\n\n if (sendingOnlySigners.length > 1) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS);\n }\n}\n","import { SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING, SolanaError } from '@solana/errors';\nimport { SignatureBytes } from '@solana/keys';\nimport { BaseTransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\nimport {\n assertIsFullySignedTransaction,\n compileTransaction,\n SendableTransaction,\n Transaction,\n TransactionWithinSizeLimit,\n TransactionWithLifetime,\n} from '@solana/transactions';\n\nimport { getSignersFromTransactionMessage, TransactionMessageWithSigners } from './account-signer-meta';\nimport { deduplicateSigners } from './deduplicate-signers';\nimport {\n isTransactionModifyingSigner,\n TransactionModifyingSigner,\n TransactionModifyingSignerConfig,\n} from './transaction-modifying-signer';\nimport {\n isTransactionPartialSigner,\n TransactionPartialSigner,\n TransactionPartialSignerConfig,\n} from './transaction-partial-signer';\nimport {\n isTransactionSendingSigner,\n TransactionSendingSigner,\n TransactionSendingSignerConfig,\n} from './transaction-sending-signer';\nimport { isTransactionSigner, TransactionSigner } from './transaction-signer';\nimport { assertIsTransactionMessageWithSingleSendingSigner } from './transaction-with-single-sending-signer';\n\n/**\n * Extracts all {@link TransactionSigner | TransactionSigners} inside the provided\n * transaction message and uses them to return a signed transaction.\n *\n * It first uses all {@link TransactionModifyingSigner | TransactionModifyingSigners} sequentially before\n * using all {@link TransactionPartialSigner | TransactionPartialSigners} in parallel.\n *\n * If a composite signer implements both interfaces, it will be used as a\n * {@link TransactionModifyingSigner} if no other signer implements that interface.\n * Otherwise, it will be used as a {@link TransactionPartialSigner}.\n *\n * @example\n * ```ts\n * const signedTransaction = await partiallySignTransactionMessageWithSigners(transactionMessage);\n * ```\n *\n * It also accepts an optional {@link AbortSignal} that will be propagated to all signers.\n *\n * ```ts\n * const signedTransaction = await partiallySignTransactionMessageWithSigners(transactionMessage, {\n * abortSignal: myAbortController.signal,\n * });\n * ```\n *\n * @remarks\n * Finally, note that this function ignores {@link TransactionSendingSigner | TransactionSendingSigners}\n * as it does not send the transaction. Check out the {@link signAndSendTransactionMessageWithSigners}\n * function for more details on how to use sending signers.\n *\n * @see {@link signTransactionMessageWithSigners}\n * @see {@link signAndSendTransactionMessageWithSigners}\n */\nexport async function partiallySignTransactionMessageWithSigners(\n transactionMessage: BaseTransactionMessage & TransactionMessageWithFeePayer & TransactionMessageWithSigners,\n config?: TransactionPartialSignerConfig,\n): Promise<Transaction & TransactionWithinSizeLimit & TransactionWithLifetime> {\n const { partialSigners, modifyingSigners } = categorizeTransactionSigners(\n deduplicateSigners(getSignersFromTransactionMessage(transactionMessage).filter(isTransactionSigner)),\n { identifySendingSigner: false },\n );\n\n return await signModifyingAndPartialTransactionSigners(\n transactionMessage,\n modifyingSigners,\n partialSigners,\n config,\n );\n}\n\n/**\n * Extracts all {@link TransactionSigner | TransactionSigners} inside the provided\n * transaction message and uses them to return a signed transaction before asserting\n * that all signatures required by the transaction are present.\n *\n * This function delegates to the {@link partiallySignTransactionMessageWithSigners} function\n * in order to extract signers from the transaction message and sign the transaction.\n *\n * @example\n * ```ts\n * const mySignedTransaction = await signTransactionMessageWithSigners(myTransactionMessage);\n *\n * // With additional config.\n * const mySignedTransaction = await signTransactionMessageWithSigners(myTransactionMessage, {\n * abortSignal: myAbortController.signal,\n * });\n *\n * // We now know the transaction is fully signed.\n * mySignedTransaction satisfies FullySignedTransaction;\n * ```\n *\n * @see {@link partiallySignTransactionMessageWithSigners}\n * @see {@link signAndSendTransactionMessageWithSigners}\n */\nexport async function signTransactionMessageWithSigners(\n transactionMessage: BaseTransactionMessage & TransactionMessageWithFeePayer & TransactionMessageWithSigners,\n config?: TransactionPartialSignerConfig,\n): Promise<SendableTransaction & Transaction & TransactionWithLifetime> {\n const signedTransaction = await partiallySignTransactionMessageWithSigners(transactionMessage, config);\n assertIsFullySignedTransaction(signedTransaction);\n return signedTransaction;\n}\n\n/**\n * Extracts all {@link TransactionSigner | TransactionSigners} inside the provided\n * transaction message and uses them to sign it before sending it immediately to the blockchain.\n *\n * It returns the signature of the sent transaction (i.e. its identifier) as bytes.\n *\n * @example\n * ```ts\n * import { signAndSendTransactionMessageWithSigners } from '@solana/signers';\n *\n * const transactionSignature = await signAndSendTransactionMessageWithSigners(transactionMessage);\n *\n * // With additional config.\n * const transactionSignature = await signAndSendTransactionMessageWithSigners(transactionMessage, {\n * abortSignal: myAbortController.signal,\n * });\n * ```\n *\n * @remarks\n * Similarly to the {@link partiallySignTransactionMessageWithSigners} function, it first uses all\n * {@link TransactionModifyingSigner | TransactionModifyingSigners} sequentially before using all\n * {@link TransactionPartialSigner | TransactionPartialSigners} in parallel.\n * It then sends the transaction using the {@link TransactionSendingSigner} it identified.\n *\n * Composite transaction signers are treated such that at least one sending signer is used if any.\n * When a {@link TransactionSigner} implements more than one interface, we use it as a:\n *\n * - {@link TransactionSendingSigner}, if no other {@link TransactionSendingSigner} exists.\n * - {@link TransactionModifyingSigner}, if no other {@link TransactionModifyingSigner} exists.\n * - {@link TransactionPartialSigner}, otherwise.\n *\n * The provided transaction must contain exactly one {@link TransactionSendingSigner} inside its account metas.\n * If more than one composite signers implement the {@link TransactionSendingSigner} interface,\n * one of them will be selected as the sending signer. Otherwise, if multiple\n * {@link TransactionSendingSigner | TransactionSendingSigners} must be selected, the function will throw an error.\n *\n * If you'd like to assert that a transaction makes use of exactly one {@link TransactionSendingSigner}\n * _before_ calling this function, you may use the {@link assertIsTransactionMessageWithSingleSendingSigner} function.\n *\n * Alternatively, you may use the {@link isTransactionMessageWithSingleSendingSigner} function to provide a\n * fallback in case the transaction does not contain any sending signer.\n *\n * @see {@link assertIsTransactionMessageWithSingleSendingSigner}\n * @see {@link isTransactionMessageWithSingleSendingSigner}\n * @see {@link partiallySignTransactionMessageWithSigners}\n * @see {@link signTransactionMessageWithSigners}\n *\n */\nexport async function signAndSendTransactionMessageWithSigners(\n transaction: BaseTransactionMessage & TransactionMessageWithFeePayer & TransactionMessageWithSigners,\n config?: TransactionSendingSignerConfig,\n): Promise<SignatureBytes> {\n assertIsTransactionMessageWithSingleSendingSigner(transaction);\n\n const abortSignal = config?.abortSignal;\n const { partialSigners, modifyingSigners, sendingSigner } = categorizeTransactionSigners(\n deduplicateSigners(getSignersFromTransactionMessage(transaction).filter(isTransactionSigner)),\n );\n\n abortSignal?.throwIfAborted();\n const signedTransaction = await signModifyingAndPartialTransactionSigners(\n transaction,\n modifyingSigners,\n partialSigners,\n config,\n );\n\n if (!sendingSigner) {\n throw new SolanaError(SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING);\n }\n\n abortSignal?.throwIfAborted();\n const [signature] = await sendingSigner.signAndSendTransactions([signedTransaction], config);\n abortSignal?.throwIfAborted();\n\n return signature;\n}\n\n/**\n * Identifies each provided TransactionSigner and categorizes them into their respective types.\n * When a signer implements multiple interface, it will try to used to most powerful interface\n * but fallback to the least powerful interface when necessary.\n * For instance, if a signer implements TransactionSendingSigner and TransactionModifyingSigner,\n * it will be categorized as a TransactionSendingSigner if and only if no other signers implement\n * the TransactionSendingSigner interface.\n */\nfunction categorizeTransactionSigners(\n signers: readonly TransactionSigner[],\n config: { identifySendingSigner?: boolean } = {},\n): Readonly<{\n modifyingSigners: readonly TransactionModifyingSigner[];\n partialSigners: readonly TransactionPartialSigner[];\n sendingSigner: TransactionSendingSigner | null;\n}> {\n // Identify the unique sending signer that should be used.\n const identifySendingSigner = config.identifySendingSigner ?? true;\n const sendingSigner = identifySendingSigner ? identifyTransactionSendingSigner(signers) : null;\n\n // Now, focus on the other signers.\n // I.e. the modifying or partial signers that are not the identified sending signer.\n // Note that any other sending only signers will be discarded.\n const otherSigners = signers.filter(\n (signer): signer is TransactionModifyingSigner | TransactionPartialSigner =>\n signer !== sendingSigner && (isTransactionModifyingSigner(signer) || isTransactionPartialSigner(signer)),\n );\n\n // Identify the modifying signers from the other signers.\n const modifyingSigners = identifyTransactionModifyingSigners(otherSigners);\n\n // Use any remaining signers as partial signers.\n const partialSigners = otherSigners\n .filter(isTransactionPartialSigner)\n .filter(signer => !(modifyingSigners as typeof otherSigners).includes(signer));\n\n return Object.freeze({ modifyingSigners, partialSigners, sendingSigner });\n}\n\n/** Identifies the best signer to use as a TransactionSendingSigner, if any */\nfunction identifyTransactionSendingSigner(signers: readonly TransactionSigner[]): TransactionSendingSigner | null {\n // Ensure there are any TransactionSendingSigners in the first place.\n const sendingSigners = signers.filter(isTransactionSendingSigner);\n if (sendingSigners.length === 0) return null;\n\n // Prefer sending signers that do not offer other interfaces.\n const sendingOnlySigners = sendingSigners.filter(\n signer => !isTransactionModifyingSigner(signer) && !isTransactionPartialSigner(signer),\n );\n if (sendingOnlySigners.length > 0) {\n return sendingOnlySigners[0];\n }\n\n // Otherwise, choose any sending signer.\n return sendingSigners[0];\n}\n\n/** Identifies the best signers to use as TransactionModifyingSigners, if any */\nfunction identifyTransactionModifyingSigners(\n signers: readonly (TransactionModifyingSigner | TransactionPartialSigner)[],\n): readonly TransactionModifyingSigner[] {\n // Ensure there are any TransactionModifyingSigner in the first place.\n const modifyingSigners = signers.filter(isTransactionModifyingSigner);\n if (modifyingSigners.length === 0) return [];\n\n // Prefer modifying signers that do not offer partial signing.\n const nonPartialSigners = modifyingSigners.filter(signer => !isTransactionPartialSigner(signer));\n if (nonPartialSigners.length > 0) return nonPartialSigners;\n\n // Otherwise, choose only one modifying signer (whichever).\n return [modifyingSigners[0]];\n}\n\n/**\n * Signs a transaction using the provided TransactionModifyingSigners\n * sequentially followed by the TransactionPartialSigners in parallel.\n */\nasync function signModifyingAndPartialTransactionSigners(\n transactionMessage: BaseTransactionMessage & TransactionMessageWithFeePayer & TransactionMessageWithSigners,\n modifyingSigners: readonly TransactionModifyingSigner[] = [],\n partialSigners: readonly TransactionPartialSigner[] = [],\n config?: TransactionModifyingSignerConfig,\n): Promise<Transaction & TransactionWithinSizeLimit & TransactionWithLifetime> {\n // serialize the transaction\n const transaction = compileTransaction(transactionMessage);\n\n // Handle modifying signers sequentially.\n const modifiedTransaction = (await modifyingSigners.reduce(\n async (transaction, modifyingSigner) => {\n config?.abortSignal?.throwIfAborted();\n const [tx] = await modifyingSigner.modifyAndSignTransactions([await transaction], config);\n return Object.freeze(tx);\n },\n Promise.resolve(transaction) as Promise<Readonly<Transaction & TransactionWithLifetime>>,\n )) as Transaction & TransactionWithinSizeLimit & TransactionWithLifetime;\n\n // Handle partial signers in parallel.\n config?.abortSignal?.throwIfAborted();\n const signatureDictionaries = await Promise.all(\n partialSigners.map(async partialSigner => {\n const [signatures] = await partialSigner.signTransactions([modifiedTransaction], config);\n return signatures;\n }),\n );\n\n return Object.freeze({\n ...modifiedTransaction,\n signatures: Object.freeze(\n signatureDictionaries.reduce((signatures, signatureDictionary) => {\n return { ...signatures, ...signatureDictionary };\n }, modifiedTransaction.signatures ?? {}),\n ),\n });\n}\n","export const TextDecoder = globalThis.TextDecoder;\nexport const TextEncoder = globalThis.TextEncoder;\n","import { TextEncoder } from '@solana/text-encoding-impl';\n\nimport { SignatureDictionary } from './types';\n\n/**\n * Defines a message that needs signing and its current set of signatures if any.\n *\n * This interface allows {@link MessageModifyingSigner | MessageModifyingSigners}\n * to decide on whether or not they should modify the provided message depending\n * on whether or not signatures already exist for such message.\n *\n * It also helps create a more consistent API by providing a structure analogous\n * to transactions which also keep track of their {@link SignatureDictionary}.\n *\n * @example\n * ```ts\n * import { createSignableMessage } from '@solana/signers';\n *\n * const message = createSignableMessage(new Uint8Array([1, 2, 3]));\n * message.content; // The content of the message as bytes.\n * message.signatures; // The current set of signatures for this message.\n * ```\n *\n * @see {@link createSignableMessage}\n */\nexport type SignableMessage = Readonly<{\n content: Uint8Array;\n signatures: SignatureDictionary;\n}>;\n\n/**\n * Creates a {@link SignableMessage} from a `Uint8Array` or a UTF-8 string.\n *\n * It optionally accepts a signature dictionary if the message already contains signatures.\n *\n * @example\n * ```ts\n * const message = createSignableMessage(new Uint8Array([1, 2, 3]));\n * const messageFromText = createSignableMessage('Hello world!');\n * const messageWithSignatures = createSignableMessage('Hello world!', {\n * [address('1234..5678')]: new Uint8Array([1, 2, 3]) as SignatureBytes,\n * });\n * ```\n */\nexport function createSignableMessage(\n content: Uint8Array | string,\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"]}