2025-06-21 23:30:33 +03:00

350 lines
14 KiB
JavaScript

'use strict';
var errors = require('@solana/errors');
var instructions = require('@solana/instructions');
var addresses = require('@solana/addresses');
var keys = require('@solana/keys');
var transactions = require('@solana/transactions');
// src/deduplicate-signers.ts
function deduplicateSigners(signers) {
const deduplicated = {};
signers.forEach((signer) => {
if (!deduplicated[signer.address]) {
deduplicated[signer.address] = signer;
} else if (deduplicated[signer.address] !== signer) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS, {
address: signer.address
});
}
});
return Object.values(deduplicated);
}
function isTransactionModifyingSigner(value) {
return "modifyAndSignTransactions" in value && typeof value.modifyAndSignTransactions === "function";
}
function assertIsTransactionModifyingSigner(value) {
if (!isTransactionModifyingSigner(value)) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER, {
address: value.address
});
}
}
function isTransactionPartialSigner(value) {
return "signTransactions" in value && typeof value.signTransactions === "function";
}
function assertIsTransactionPartialSigner(value) {
if (!isTransactionPartialSigner(value)) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER, {
address: value.address
});
}
}
function isTransactionSendingSigner(value) {
return "signAndSendTransactions" in value && typeof value.signAndSendTransactions === "function";
}
function assertIsTransactionSendingSigner(value) {
if (!isTransactionSendingSigner(value)) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER, {
address: value.address
});
}
}
// src/transaction-signer.ts
function isTransactionSigner(value) {
return isTransactionPartialSigner(value) || isTransactionModifyingSigner(value) || isTransactionSendingSigner(value);
}
function assertIsTransactionSigner(value) {
if (!isTransactionSigner(value)) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER, {
address: value.address
});
}
}
// src/account-signer-meta.ts
function getSignersFromInstruction(instruction) {
return deduplicateSigners(
(instruction.accounts ?? []).flatMap((account) => "signer" in account ? account.signer : [])
);
}
function getSignersFromTransactionMessage(transaction) {
return deduplicateSigners([
...transaction.feePayer && isTransactionSigner(transaction.feePayer) ? [transaction.feePayer] : [],
...transaction.instructions.flatMap(getSignersFromInstruction)
]);
}
function addSignersToInstruction(signers, instruction) {
if (!instruction.accounts || instruction.accounts.length === 0) {
return instruction;
}
const signerByAddress = new Map(deduplicateSigners(signers).map((signer) => [signer.address, signer]));
return Object.freeze({
...instruction,
accounts: instruction.accounts.map((account) => {
const signer = signerByAddress.get(account.address);
if (!instructions.isSignerRole(account.role) || "signer" in account || !signer) {
return account;
}
return Object.freeze({ ...account, signer });
})
});
}
function addSignersToTransactionMessage(signers, transactionMessage) {
if (transactionMessage.instructions.length === 0) {
return transactionMessage;
}
return Object.freeze({
...transactionMessage,
instructions: transactionMessage.instructions.map((instruction) => addSignersToInstruction(signers, instruction))
});
}
// src/fee-payer-signer.ts
function setTransactionMessageFeePayerSigner(feePayer, transactionMessage) {
Object.freeze(feePayer);
const out = { ...transactionMessage, feePayer };
Object.freeze(out);
return out;
}
function isMessagePartialSigner(value) {
return "signMessages" in value && typeof value.signMessages === "function";
}
function assertIsMessagePartialSigner(value) {
if (!isMessagePartialSigner(value)) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_PARTIAL_SIGNER, {
address: value.address
});
}
}
// src/keypair-signer.ts
function isKeyPairSigner(value) {
return "keyPair" in value && typeof value.keyPair === "object" && isMessagePartialSigner(value) && isTransactionPartialSigner(value);
}
function assertIsKeyPairSigner(value) {
if (!isKeyPairSigner(value)) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__EXPECTED_KEY_PAIR_SIGNER, {
address: value.address
});
}
}
async function createSignerFromKeyPair(keyPair) {
const address = await addresses.getAddressFromPublicKey(keyPair.publicKey);
const out = {
address,
keyPair,
signMessages: (messages) => Promise.all(
messages.map(
async (message) => Object.freeze({ [address]: await keys.signBytes(keyPair.privateKey, message.content) })
)
),
signTransactions: (transactions$1) => Promise.all(
transactions$1.map(async (transaction) => {
const signedTransaction = await transactions.partiallySignTransaction([keyPair], transaction);
return Object.freeze({ [address]: signedTransaction.signatures[address] });
})
)
};
return Object.freeze(out);
}
async function generateKeyPairSigner() {
return await createSignerFromKeyPair(await keys.generateKeyPair());
}
async function createKeyPairSignerFromBytes(bytes, extractable) {
return await createSignerFromKeyPair(await keys.createKeyPairFromBytes(bytes, extractable));
}
async function createKeyPairSignerFromPrivateKeyBytes(bytes, extractable) {
return await createSignerFromKeyPair(await keys.createKeyPairFromPrivateKeyBytes(bytes, extractable));
}
function isMessageModifyingSigner(value) {
return addresses.isAddress(value.address) && "modifyAndSignMessages" in value && typeof value.modifyAndSignMessages === "function";
}
function assertIsMessageModifyingSigner(value) {
if (!isMessageModifyingSigner(value)) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_MODIFYING_SIGNER, {
address: value.address
});
}
}
function isMessageSigner(value) {
return isMessagePartialSigner(value) || isMessageModifyingSigner(value);
}
function assertIsMessageSigner(value) {
if (!isMessageSigner(value)) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_SIGNER, {
address: value.address
});
}
}
// src/noop-signer.ts
function createNoopSigner(address) {
const out = {
address,
signMessages: (messages) => Promise.resolve(messages.map(() => Object.freeze({}))),
signTransactions: (transactions) => Promise.resolve(transactions.map(() => Object.freeze({})))
};
return Object.freeze(out);
}
function isTransactionMessageWithSingleSendingSigner(transaction) {
try {
assertIsTransactionMessageWithSingleSendingSigner(transaction);
return true;
} catch {
return false;
}
}
function assertIsTransactionMessageWithSingleSendingSigner(transaction) {
const signers = getSignersFromTransactionMessage(transaction);
const sendingSigners = signers.filter(isTransactionSendingSigner);
if (sendingSigners.length === 0) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING);
}
const sendingOnlySigners = sendingSigners.filter(
(signer) => !isTransactionPartialSigner(signer) && !isTransactionModifyingSigner(signer)
);
if (sendingOnlySigners.length > 1) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS);
}
}
// src/sign-transaction.ts
async function partiallySignTransactionMessageWithSigners(transactionMessage, config) {
const { partialSigners, modifyingSigners } = categorizeTransactionSigners(
deduplicateSigners(getSignersFromTransactionMessage(transactionMessage).filter(isTransactionSigner)),
{ identifySendingSigner: false }
);
return await signModifyingAndPartialTransactionSigners(
transactionMessage,
modifyingSigners,
partialSigners,
config
);
}
async function signTransactionMessageWithSigners(transactionMessage, config) {
const signedTransaction = await partiallySignTransactionMessageWithSigners(transactionMessage, config);
transactions.assertTransactionIsFullySigned(signedTransaction);
return signedTransaction;
}
async function signAndSendTransactionMessageWithSigners(transaction, config) {
assertIsTransactionMessageWithSingleSendingSigner(transaction);
const abortSignal = config?.abortSignal;
const { partialSigners, modifyingSigners, sendingSigner } = categorizeTransactionSigners(
deduplicateSigners(getSignersFromTransactionMessage(transaction).filter(isTransactionSigner))
);
abortSignal?.throwIfAborted();
const signedTransaction = await signModifyingAndPartialTransactionSigners(
transaction,
modifyingSigners,
partialSigners,
config
);
if (!sendingSigner) {
throw new errors.SolanaError(errors.SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING);
}
abortSignal?.throwIfAborted();
const [signature] = await sendingSigner.signAndSendTransactions([signedTransaction], config);
abortSignal?.throwIfAborted();
return signature;
}
function categorizeTransactionSigners(signers, config = {}) {
const identifySendingSigner = config.identifySendingSigner ?? true;
const sendingSigner = identifySendingSigner ? identifyTransactionSendingSigner(signers) : null;
const otherSigners = signers.filter(
(signer) => signer !== sendingSigner && (isTransactionModifyingSigner(signer) || isTransactionPartialSigner(signer))
);
const modifyingSigners = identifyTransactionModifyingSigners(otherSigners);
const partialSigners = otherSigners.filter(isTransactionPartialSigner).filter((signer) => !modifyingSigners.includes(signer));
return Object.freeze({ modifyingSigners, partialSigners, sendingSigner });
}
function identifyTransactionSendingSigner(signers) {
const sendingSigners = signers.filter(isTransactionSendingSigner);
if (sendingSigners.length === 0) return null;
const sendingOnlySigners = sendingSigners.filter(
(signer) => !isTransactionModifyingSigner(signer) && !isTransactionPartialSigner(signer)
);
if (sendingOnlySigners.length > 0) {
return sendingOnlySigners[0];
}
return sendingSigners[0];
}
function identifyTransactionModifyingSigners(signers) {
const modifyingSigners = signers.filter(isTransactionModifyingSigner);
if (modifyingSigners.length === 0) return [];
const nonPartialSigners = modifyingSigners.filter((signer) => !isTransactionPartialSigner(signer));
if (nonPartialSigners.length > 0) return nonPartialSigners;
return [modifyingSigners[0]];
}
async function signModifyingAndPartialTransactionSigners(transactionMessage, modifyingSigners = [], partialSigners = [], config) {
const transaction = transactions.compileTransaction(transactionMessage);
const modifiedTransaction = await modifyingSigners.reduce(
async (transaction2, modifyingSigner) => {
config?.abortSignal?.throwIfAborted();
const [tx] = await modifyingSigner.modifyAndSignTransactions([await transaction2], config);
return Object.freeze(tx);
},
Promise.resolve(transaction)
);
config?.abortSignal?.throwIfAborted();
const signatureDictionaries = await Promise.all(
partialSigners.map(async (partialSigner) => {
const [signatures] = await partialSigner.signTransactions([modifiedTransaction], config);
return signatures;
})
);
const signedTransaction = {
...modifiedTransaction,
signatures: Object.freeze(
signatureDictionaries.reduce((signatures, signatureDictionary) => {
return { ...signatures, ...signatureDictionary };
}, modifiedTransaction.signatures ?? {})
)
};
return Object.freeze(signedTransaction);
}
var o = globalThis.TextEncoder;
// src/signable-message.ts
function createSignableMessage(content, signatures = {}) {
return Object.freeze({
content: typeof content === "string" ? new o().encode(content) : content,
signatures: Object.freeze({ ...signatures })
});
}
exports.addSignersToInstruction = addSignersToInstruction;
exports.addSignersToTransactionMessage = addSignersToTransactionMessage;
exports.assertIsKeyPairSigner = assertIsKeyPairSigner;
exports.assertIsMessageModifyingSigner = assertIsMessageModifyingSigner;
exports.assertIsMessagePartialSigner = assertIsMessagePartialSigner;
exports.assertIsMessageSigner = assertIsMessageSigner;
exports.assertIsTransactionMessageWithSingleSendingSigner = assertIsTransactionMessageWithSingleSendingSigner;
exports.assertIsTransactionModifyingSigner = assertIsTransactionModifyingSigner;
exports.assertIsTransactionPartialSigner = assertIsTransactionPartialSigner;
exports.assertIsTransactionSendingSigner = assertIsTransactionSendingSigner;
exports.assertIsTransactionSigner = assertIsTransactionSigner;
exports.createKeyPairSignerFromBytes = createKeyPairSignerFromBytes;
exports.createKeyPairSignerFromPrivateKeyBytes = createKeyPairSignerFromPrivateKeyBytes;
exports.createNoopSigner = createNoopSigner;
exports.createSignableMessage = createSignableMessage;
exports.createSignerFromKeyPair = createSignerFromKeyPair;
exports.generateKeyPairSigner = generateKeyPairSigner;
exports.getSignersFromInstruction = getSignersFromInstruction;
exports.getSignersFromTransactionMessage = getSignersFromTransactionMessage;
exports.isKeyPairSigner = isKeyPairSigner;
exports.isMessageModifyingSigner = isMessageModifyingSigner;
exports.isMessagePartialSigner = isMessagePartialSigner;
exports.isMessageSigner = isMessageSigner;
exports.isTransactionMessageWithSingleSendingSigner = isTransactionMessageWithSingleSendingSigner;
exports.isTransactionModifyingSigner = isTransactionModifyingSigner;
exports.isTransactionPartialSigner = isTransactionPartialSigner;
exports.isTransactionSendingSigner = isTransactionSendingSigner;
exports.isTransactionSigner = isTransactionSigner;
exports.partiallySignTransactionMessageWithSigners = partiallySignTransactionMessageWithSigners;
exports.setTransactionMessageFeePayerSigner = setTransactionMessageFeePayerSigner;
exports.signAndSendTransactionMessageWithSigners = signAndSendTransactionMessageWithSigners;
exports.signTransactionMessageWithSigners = signTransactionMessageWithSigners;
//# sourceMappingURL=index.node.cjs.map
//# sourceMappingURL=index.node.cjs.map