@algorandfoundation/algokit-utils 9.2.0-beta.7 → 10.0.0-alpha.1

package/packages/transact/src/multisig.mjs

@@ -0,0 +1,368 @@
+import { arrayEqual } from "../../common/src/array.mjs";
+import { PUBLIC_KEY_BYTE_LENGTH, SIGNATURE_BYTE_LENGTH } from "../../common/src/constants.mjs";
+import { ALGORAND_ADDRESS_BYTE_LENGTH, ALGORAND_CHECKSUM_BYTE_LENGTH, Address, getAddress } from "../../common/src/address.mjs";
+import { hash } from "../../common/src/crypto.mjs";
+import { decodeMsgpack } from "../../common/src/msgpack.mjs";
+import { multiSignatureCodec } from "./transactions/signed-transaction-meta.mjs";
+import { decodeSignedTransaction, encodeSignedTransaction } from "./transactions/signed-transaction.mjs";
+
+//#region packages/transact/src/multisig.ts
+/**
+* Creates an empty multisignature signature from a list of participant public keys.
+*/
+function newMultisigSignature(version, threshold, participants) {
+	if (version === 0) throw new Error("Version cannot be zero");
+	if (participants.length === 0) throw new Error("Participants cannot be empty");
+	if (threshold === 0 || threshold > participants.length) throw new Error("Threshold must be greater than zero and less than or equal to the number of participants");
+	return {
+		version,
+		threshold,
+		subsignatures: participants.map((publicKey) => ({ publicKey }))
+	};
+}
+/**
+* Returns the list of participant public keys from a multisignature signature.
+*/
+function participantsFromMultisigSignature(multisigSignature) {
+	return multisigSignature.subsignatures.map((subsig) => subsig.publicKey);
+}
+const toPublicKeys = (addrs) => addrs.map((addr) => getAddress(addr).publicKey);
+/**
+* Returns the address of the multisignature account.
+*/
+function addressFromMultisigSignature(multisigSignature) {
+	return addressFromMultisigPreImg({
+		version: multisigSignature.version,
+		threshold: multisigSignature.threshold,
+		pks: multisigSignature.subsignatures.map((subsig) => subsig.publicKey)
+	});
+}
+/**
+* Applies a subsignature for a participant to a multisignature signature, replacing any existing signature.
+*
+* This method applies the signature to ALL instances of the given public key (to support weighted multisig).
+* Since ed25519 signatures are deterministic, there's only one valid signature for a given message and public key.
+*/
+function applyMultisigSubsignature(multisigSignature, participant, signature) {
+	let found = false;
+	const newSubsignatures = multisigSignature.subsignatures.map((subsig) => {
+		if (arrayEqual(subsig.publicKey, participant)) {
+			found = true;
+			return {
+				...subsig,
+				signature
+			};
+		}
+		return subsig;
+	});
+	if (!found) throw new Error("Public key not found in multisig signature");
+	return {
+		...multisigSignature,
+		subsignatures: newSubsignatures
+	};
+}
+/**
+* Merges two multisignature signatures, replacing signatures in the first with those from the second where present.
+* For each participant, the resulting signature will be taken from the second multisig if present, otherwise from the first.
+*/
+function mergeMultisignatures(multisigSignatureA, multisigSignatureB) {
+	if (multisigSignatureA.version !== multisigSignatureB.version) throw new Error("Cannot merge multisig signatures with different versions");
+	if (multisigSignatureA.threshold !== multisigSignatureB.threshold) throw new Error("Cannot merge multisig signatures with different thresholds");
+	const participantsA = participantsFromMultisigSignature(multisigSignatureA);
+	const participantsB = participantsFromMultisigSignature(multisigSignatureB);
+	if (!(participantsA.length === participantsB.length && participantsA.every((pk, i) => arrayEqual(pk, participantsB[i])))) throw new Error("Cannot merge multisig signatures with different participants");
+	const mergedSubsignatures = multisigSignatureA.subsignatures.map((s1, index) => {
+		const s2 = multisigSignatureB.subsignatures[index];
+		return {
+			publicKey: s1.publicKey,
+			signature: s2.signature || s1.signature
+		};
+	});
+	return {
+		version: multisigSignatureA.version,
+		threshold: multisigSignatureA.threshold,
+		subsignatures: mergedSubsignatures
+	};
+}
+const MULTISIG_PREIMG2ADDR_PREFIX = new Uint8Array([
+	77,
+	117,
+	108,
+	116,
+	105,
+	115,
+	105,
+	103,
+	65,
+	100,
+	100,
+	114
+]);
+const INVALID_MSIG_VERSION_ERROR_MSG = "invalid multisig version";
+const INVALID_MSIG_THRESHOLD_ERROR_MSG = "bad multisig threshold";
+const INVALID_MSIG_PK_ERROR_MSG = "bad multisig public key - wrong length";
+const UNEXPECTED_PK_LEN_ERROR_MSG = "nacl public key length is not 32 bytes";
+const MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG = "Not enough multisig transactions to merge. Need at least two";
+const MULTISIG_MERGE_MISMATCH_ERROR_MSG = "Cannot merge txs. txIDs differ";
+const MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG = "Cannot merge txs. Auth addrs differ";
+const MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = "Cannot merge txs. Multisig preimages differ";
+const MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = "Cannot merge txs. subsigs are mismatched.";
+const MULTISIG_NO_MUTATE_ERROR_MSG = "Cannot mutate a multisig field as it would invalidate all existing signatures.";
+const MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG = "Cannot sign a multisig transaction using `signTxn`. Use `partialSignTxn` instead.";
+const MULTISIG_SIGNATURE_LENGTH_ERROR_MSG = "Cannot add multisig signature. Signature is not of the correct length.";
+const MULTISIG_KEY_NOT_EXIST_ERROR_MSG = "Key does not exist";
+/**
+* creates a raw, multisig transaction blob without any signatures.
+* @param txn - the actual transaction.
+* @param version - multisig version
+* @param threshold - multisig threshold
+* @param pks - ordered list of public keys in this multisig
+* @returns encoded multisig blob
+*/
+function createMultisigTransaction(txn, { version, threshold, addrs }) {
+	const pks = toPublicKeys(addrs);
+	const msig = {
+		version,
+		threshold,
+		subsignatures: pks.map((pk) => ({
+			publicKey: pk,
+			signature: void 0
+		}))
+	};
+	const msigAddr = addressFromMultisigPreImg({
+		version,
+		threshold,
+		pks
+	});
+	let authAddress;
+	if (!msigAddr.equals(txn.sender)) authAddress = msigAddr;
+	return encodeSignedTransaction({
+		txn,
+		msig,
+		authAddress
+	});
+}
+/**
+* creates a multisig transaction blob with an included signature.
+* @param txn - the actual transaction to sign.
+* @param rawSig - a Uint8Array raw signature of that transaction
+* @param myPk - a public key that corresponds with rawSig
+* @param version - multisig version
+* @param threshold - multisig threshold
+* @param pks - ordered list of public keys in this multisig
+* @returns encoded multisig blob
+*/
+function createMultisigTransactionWithSignature(txn, { rawSig, myPk }, { version, threshold, pks }) {
+	const signedTxn = decodeSignedTransaction(createMultisigTransaction(txn, {
+		version,
+		threshold,
+		addrs: pks.map((pk) => new Address(pk))
+	}));
+	let keyExist = false;
+	const updatedSubsigs = signedTxn.msig.subsignatures.map((subsig) => {
+		if (arrayEqual(subsig.publicKey, myPk)) {
+			keyExist = true;
+			return {
+				...subsig,
+				signature: rawSig
+			};
+		}
+		return subsig;
+	});
+	if (!keyExist) throw new Error(MULTISIG_KEY_NOT_EXIST_ERROR_MSG);
+	return encodeSignedTransaction({
+		...signedTxn,
+		msig: {
+			...signedTxn.msig,
+			subsignatures: updatedSubsigs
+		}
+	});
+}
+/**
+* takes a list of multisig transaction blobs, and merges them.
+* @param multisigTxnBlobs - a list of blobs representing encoded multisig txns
+* @returns typed array msg-pack encoded multisig txn
+*/
+function mergeMultisigTransactions(multisigTxnBlobs) {
+	if (multisigTxnBlobs.length < 2) throw new Error(MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG);
+	const refSigTx = decodeSignedTransaction(multisigTxnBlobs[0]);
+	if (!refSigTx.msig) throw new Error("Invalid multisig transaction, multisig structure missing at index 0");
+	const refTxID = refSigTx.txn.txId();
+	const refAuthAddr = refSigTx.authAddress;
+	const refMsigAddr = addressFromMultisigPreImg({
+		version: refSigTx.msig.version,
+		threshold: refSigTx.msig.threshold,
+		pks: refSigTx.msig.subsignatures.map((subsig) => subsig.publicKey)
+	});
+	const newSubsigs = refSigTx.msig.subsignatures.map((sig) => ({ ...sig }));
+	for (let i = 1; i < multisigTxnBlobs.length; i++) {
+		const unisig = decodeSignedTransaction(multisigTxnBlobs[i]);
+		if (!unisig.msig) throw new Error(`Invalid multisig transaction, multisig structure missing at index ${i}`);
+		if (unisig.txn.txId() !== refTxID) throw new Error(MULTISIG_MERGE_MISMATCH_ERROR_MSG);
+		if (refAuthAddr !== unisig.authAddress) throw new Error(MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG);
+		if (unisig.msig.subsignatures.length !== refSigTx.msig.subsignatures.length) throw new Error(MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG);
+		const msgigAddr = addressFromMultisigPreImg({
+			version: unisig.msig.version,
+			threshold: unisig.msig.threshold,
+			pks: unisig.msig.subsignatures.map((subsig) => subsig.publicKey)
+		});
+		if (refMsigAddr.toString() !== msgigAddr.toString()) throw new Error(MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG);
+		unisig.msig.subsignatures.forEach((uniSubsig, index) => {
+			if (!uniSubsig.signature) return;
+			const current = newSubsigs[index];
+			if (current.signature && !arrayEqual(uniSubsig.signature, current.signature)) throw new Error(MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG);
+			current.signature = uniSubsig.signature;
+		});
+	}
+	return encodeSignedTransaction({
+		txn: refSigTx.txn,
+		msig: {
+			version: refSigTx.msig.version,
+			threshold: refSigTx.msig.threshold,
+			subsignatures: newSubsigs
+		},
+		authAddress: refAuthAddr
+	});
+}
+/**
+* Partially signs this transaction with an external raw multisig signature and returns
+* a partially-signed multisig transaction, encoded with msgpack as a typed array.
+* @param transaction - The transaction to sign
+* @param metadata - multisig metadata
+* @param signerAddr - address of the signer
+* @param signature - raw multisig signature
+* @returns an encoded, partially signed multisig transaction.
+*/
+function partialSignWithMultisigSignature(transaction, metadata, signerAddr, signature) {
+	if (signature.length != SIGNATURE_BYTE_LENGTH) throw new Error(MULTISIG_SIGNATURE_LENGTH_ERROR_MSG);
+	return createMultisigTransactionWithSignature(transaction, {
+		rawSig: signature,
+		myPk: (typeof signerAddr === "string" ? Address.fromString(signerAddr) : signerAddr).publicKey
+	}, metadata);
+}
+/**
+* Takes a multisig transaction blob, and appends a given raw signature to it.
+* This makes it possible to compile a multisig signature using only raw signatures from external methods.
+* @param multisigTxnBlob - an encoded multisig txn. Supports non-payment txn types.
+* @param version - multisig version
+* @param threshold - multisig threshold
+* @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.
+* @param signerAddr - address of the signer
+* @param signature - raw multisig signature
+* @returns object containing txID, and blob representing encoded multisig txn
+*/
+function appendSignRawMultisigSignature(multisigTxnBlob, { version, threshold, addrs }, signerAddr, signature) {
+	const pks = toPublicKeys(addrs);
+	const multisigTxObj = decodeSignedTransaction(multisigTxnBlob);
+	const partialSignedBlob = partialSignWithMultisigSignature(multisigTxObj.txn, {
+		version,
+		threshold,
+		pks
+	}, signerAddr, signature);
+	return {
+		txID: multisigTxObj.txn.txId(),
+		blob: mergeMultisigTransactions([multisigTxnBlob, partialSignedBlob])
+	};
+}
+/**
+* Takes multisig parameters and returns a 32 byte typed array public key,
+* representing an address that identifies the "exact group, version, and public keys" that are required for signing.
+* Hash("MultisigAddr" || version uint8 || threshold uint8 || PK1 || PK2 || ...)
+* Encoding this output yields a human readable address.
+* @param version - multisig version
+* @param threshold - multisig threshold
+* @param pks - array of typed array public keys
+*/
+function addressFromMultisigPreImg({ version, threshold, pks }) {
+	if (version > 255 || version < 0) throw new Error(`${INVALID_MSIG_VERSION_ERROR_MSG}: ${version}`);
+	if (threshold === 0 || pks.length === 0 || threshold > pks.length || threshold > 255) throw new Error(INVALID_MSIG_THRESHOLD_ERROR_MSG);
+	const pkLen = ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH;
+	if (pkLen !== PUBLIC_KEY_BYTE_LENGTH) throw new Error(UNEXPECTED_PK_LEN_ERROR_MSG);
+	const merged = new Uint8Array(MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + pkLen * pks.length);
+	merged.set(MULTISIG_PREIMG2ADDR_PREFIX, 0);
+	merged.set([version], MULTISIG_PREIMG2ADDR_PREFIX.length);
+	merged.set([threshold], MULTISIG_PREIMG2ADDR_PREFIX.length + 1);
+	for (let i = 0; i < pks.length; i++) {
+		if (pks[i].length !== pkLen) throw new Error(INVALID_MSIG_PK_ERROR_MSG);
+		merged.set(pks[i], MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + i * pkLen);
+	}
+	return new Address(Uint8Array.from(hash(merged)));
+}
+/**
+* Takes multisig parameters and returns a human readable Algorand address.
+* This is equivalent to fromMultisigPreImg, but interfaces with encoded addresses.
+* @param version - multisig version
+* @param threshold - multisig threshold
+* @param addrs - array of encoded addresses
+*/
+function addressFromMultisigPreImgAddrs({ version, threshold, addrs }) {
+	return addressFromMultisigPreImg({
+		version,
+		threshold,
+		pks: toPublicKeys(addrs)
+	});
+}
+/**
+* Takes multisig metadata (preimage) and returns the corresponding human readable Algorand address.
+* @param version - multisig version
+* @param threshold - multisig threshold
+* @param addrs - list of Algorand addresses
+*/
+const multisigAddress = addressFromMultisigPreImgAddrs;
+/** Account wrapper that supports partial or full multisig signing. */
+var MultisigAccount = class {
+	_params;
+	_subSigners;
+	_addr;
+	_signer;
+	/** The parameters for the multisig account */
+	get params() {
+		return this._params;
+	}
+	/** The list of accounts that are present to sign transactions or lsigs */
+	get subSigners() {
+		return this._subSigners;
+	}
+	/** The address of the multisig account */
+	get addr() {
+		return this._addr;
+	}
+	/** The transaction signer for the multisig account */
+	get signer() {
+		return this._signer;
+	}
+	constructor(multisigParams, subSigners) {
+		this._params = multisigParams;
+		this._subSigners = subSigners;
+		this._addr = multisigAddress(multisigParams);
+		this._signer = async (txns, indexesToSign) => {
+			const txnsToSign = txns.filter((_, index) => indexesToSign.includes(index));
+			const signedMsigTxns = [];
+			for (const txn of txnsToSign) {
+				let signedMsigTxn = createMultisigTransaction(txn, this._params);
+				for (const subSigner of this.subSigners) {
+					const stxn = (await subSigner.signer([txn], [0]))[0];
+					const sig = decodeSignedTransaction(stxn).sig;
+					if (!sig) throw new Error(`Signer for address ${subSigner.addr.toString()} did not produce a valid signature when signing ${txn.txId()} for multisig account ${this._addr.toString()}`);
+					signedMsigTxn = appendSignRawMultisigSignature(signedMsigTxn, this._params, subSigner.addr, sig).blob;
+				}
+				signedMsigTxns.push(signedMsigTxn);
+			}
+			return signedMsigTxns;
+		};
+	}
+};
+/**
+* Decodes MsgPack bytes into a multi signature.
+*
+* @param encodedMultiSignature - The MsgPack encoded multi signature
+* @returns The decoded MultisigSignature or an error if decoding fails.
+*/
+function decodeMultiSignature(encodedMultiSignature) {
+	const decodedData = decodeMsgpack(encodedMultiSignature);
+	return multiSignatureCodec.decode(decodedData, "msgpack");
+}
+
+//#endregion
+export { MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG, MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG, MULTISIG_MERGE_MISMATCH_ERROR_MSG, MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG, MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG, MULTISIG_NO_MUTATE_ERROR_MSG, MULTISIG_SIGNATURE_LENGTH_ERROR_MSG, MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG, MultisigAccount, addressFromMultisigPreImg, addressFromMultisigPreImgAddrs, addressFromMultisigSignature, appendSignRawMultisigSignature, applyMultisigSubsignature, createMultisigTransaction, decodeMultiSignature, mergeMultisigTransactions, mergeMultisignatures, multisigAddress, newMultisigSignature, participantsFromMultisigSignature };
+//# sourceMappingURL=multisig.mjs.map

package/packages/transact/src/multisig.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"multisig.mjs","names":["mergedSubsignatures: MultisigSubsignature[]","msig: MultisigSignature","authAddress: Address | undefined","newSubsigs: MultisigSubsignature[]","multisigAddress: typeof addressFromMultisigPreImgAddrs","signedMsigTxns: Uint8Array[]"],"sources":["../../../../packages/transact/src/multisig.ts"],"sourcesContent":["import {\n  Address,\n  ALGORAND_ADDRESS_BYTE_LENGTH,\n  ALGORAND_CHECKSUM_BYTE_LENGTH,\n  arrayEqual,\n  decodeMsgpack,\n  getAddress,\n  hash,\n  PUBLIC_KEY_BYTE_LENGTH,\n  SIGNATURE_BYTE_LENGTH,\n} from '@algorandfoundation/algokit-common'\nimport { AddressWithDelegatedLsigSigner, AddressWithTransactionSigner, TransactionSigner } from './signer'\nimport {\n  decodeSignedTransaction,\n  encodeSignedTransaction,\n  MultisigSignature,\n  MultisigSubsignature,\n  SignedTransaction,\n} from './transactions/signed-transaction'\nimport { multiSignatureCodec } from './transactions/signed-transaction-meta'\nimport { Transaction } from './transactions/transaction'\n\n/**\n * Creates an empty multisignature signature from a list of participant public keys.\n */\nexport function newMultisigSignature(version: number, threshold: number, participants: Uint8Array[]): MultisigSignature {\n  if (version === 0) {\n    throw new Error('Version cannot be zero')\n  }\n  if (participants.length === 0) {\n    throw new Error('Participants cannot be empty')\n  }\n  if (threshold === 0 || threshold > participants.length) {\n    throw new Error('Threshold must be greater than zero and less than or equal to the number of participants')\n  }\n\n  return {\n    version,\n    threshold,\n    subsignatures: participants.map((publicKey) => ({ publicKey })),\n  }\n}\n\n/**\n * Returns the list of participant public keys from a multisignature signature.\n */\nexport function participantsFromMultisigSignature(multisigSignature: MultisigSignature): Uint8Array[] {\n  return multisigSignature.subsignatures.map((subsig) => subsig.publicKey)\n}\n\nconst toPublicKeys = (addrs: Array<string | Address>): Uint8Array[] => addrs.map((addr) => getAddress(addr).publicKey)\n\n/**\n * Returns the address of the multisignature account.\n */\nexport function addressFromMultisigSignature(multisigSignature: MultisigSignature): Address {\n  return addressFromMultisigPreImg({\n    version: multisigSignature.version,\n    threshold: multisigSignature.threshold,\n    pks: multisigSignature.subsignatures.map((subsig) => subsig.publicKey),\n  })\n}\n\n/**\n * Applies a subsignature for a participant to a multisignature signature, replacing any existing signature.\n *\n * This method applies the signature to ALL instances of the given public key (to support weighted multisig).\n * Since ed25519 signatures are deterministic, there's only one valid signature for a given message and public key.\n */\nexport function applyMultisigSubsignature(\n  multisigSignature: MultisigSignature,\n  participant: Uint8Array,\n  signature: Uint8Array,\n): MultisigSignature {\n  let found = false\n  const newSubsignatures = multisigSignature.subsignatures.map((subsig) => {\n    if (arrayEqual(subsig.publicKey, participant)) {\n      found = true\n      return { ...subsig, signature }\n    }\n    return subsig\n  })\n\n  if (!found) {\n    throw new Error('Public key not found in multisig signature')\n  }\n\n  return {\n    ...multisigSignature,\n    subsignatures: newSubsignatures,\n  }\n}\n\n/**\n * Merges two multisignature signatures, replacing signatures in the first with those from the second where present.\n * For each participant, the resulting signature will be taken from the second multisig if present, otherwise from the first.\n */\nexport function mergeMultisignatures(multisigSignatureA: MultisigSignature, multisigSignatureB: MultisigSignature): MultisigSignature {\n  if (multisigSignatureA.version !== multisigSignatureB.version) {\n    throw new Error('Cannot merge multisig signatures with different versions')\n  }\n  if (multisigSignatureA.threshold !== multisigSignatureB.threshold) {\n    throw new Error('Cannot merge multisig signatures with different thresholds')\n  }\n\n  // Check participants match exactly (same public keys in same order)\n  const participantsA = participantsFromMultisigSignature(multisigSignatureA)\n  const participantsB = participantsFromMultisigSignature(multisigSignatureB)\n  const participantsMatch =\n    participantsA.length === participantsB.length && participantsA.every((pk, i) => arrayEqual(pk, participantsB[i]))\n  if (!participantsMatch) {\n    throw new Error('Cannot merge multisig signatures with different participants')\n  }\n\n  const mergedSubsignatures: MultisigSubsignature[] = multisigSignatureA.subsignatures.map((s1, index) => {\n    const s2 = multisigSignatureB.subsignatures[index]\n    return {\n      publicKey: s1.publicKey,\n      signature: s2.signature || s1.signature, // Prefer s2, fall back to s1\n    }\n  })\n\n  return {\n    version: multisigSignatureA.version,\n    threshold: multisigSignatureA.threshold,\n    subsignatures: mergedSubsignatures,\n  }\n}\n\n// Convert \"MultisigAddr\" UTF-8 to byte array\nconst MULTISIG_PREIMG2ADDR_PREFIX = new Uint8Array([77, 117, 108, 116, 105, 115, 105, 103, 65, 100, 100, 114])\n\nconst INVALID_MSIG_VERSION_ERROR_MSG = 'invalid multisig version'\nconst INVALID_MSIG_THRESHOLD_ERROR_MSG = 'bad multisig threshold'\nconst INVALID_MSIG_PK_ERROR_MSG = 'bad multisig public key - wrong length'\nconst UNEXPECTED_PK_LEN_ERROR_MSG = 'nacl public key length is not 32 bytes'\n\nexport const MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG = 'Not enough multisig transactions to merge. Need at least two'\nexport const MULTISIG_MERGE_MISMATCH_ERROR_MSG = 'Cannot merge txs. txIDs differ'\nexport const MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG = 'Cannot merge txs. Auth addrs differ'\nexport const MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = 'Cannot merge txs. Multisig preimages differ'\nexport const MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = 'Cannot merge txs. subsigs are mismatched.'\nexport const MULTISIG_NO_MUTATE_ERROR_MSG = 'Cannot mutate a multisig field as it would invalidate all existing signatures.'\nexport const MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG = 'Cannot sign a multisig transaction using `signTxn`. Use `partialSignTxn` instead.'\nexport const MULTISIG_SIGNATURE_LENGTH_ERROR_MSG = 'Cannot add multisig signature. Signature is not of the correct length.'\nconst MULTISIG_KEY_NOT_EXIST_ERROR_MSG = 'Key does not exist'\n\n/**\n * creates a raw, multisig transaction blob without any signatures.\n * @param txn - the actual transaction.\n * @param version - multisig version\n * @param threshold - multisig threshold\n * @param pks - ordered list of public keys in this multisig\n * @returns encoded multisig blob\n */\nexport function createMultisigTransaction(txn: Transaction, { version, threshold, addrs }: MultisigMetadata) {\n  // construct the appendable multisigned transaction format\n  const pks = toPublicKeys(addrs)\n  const subsignatures: MultisigSubsignature[] = pks.map((pk) => ({\n    publicKey: pk,\n    signature: undefined,\n  }))\n\n  const msig: MultisigSignature = {\n    version,\n    threshold,\n    subsignatures,\n  }\n\n  // if the address of this multisig is different from the transaction sender,\n  // we need to add the auth-addr field\n  const msigAddr = addressFromMultisigPreImg({\n    version,\n    threshold,\n    pks,\n  })\n  let authAddress: Address | undefined\n  if (!msigAddr.equals(txn.sender)) {\n    authAddress = msigAddr\n  }\n\n  const signedTxn: SignedTransaction = {\n    txn: txn,\n    msig: msig,\n    authAddress,\n  }\n\n  return encodeSignedTransaction(signedTxn)\n}\n\ninterface MultisigOptions {\n  rawSig: Uint8Array\n  myPk: Uint8Array\n}\n\ninterface MultisigMetadataWithPks extends Omit<MultisigMetadata, 'addrs'> {\n  pks: Uint8Array[]\n}\n\n/**\n * creates a multisig transaction blob with an included signature.\n * @param txn - the actual transaction to sign.\n * @param rawSig - a Uint8Array raw signature of that transaction\n * @param myPk - a public key that corresponds with rawSig\n * @param version - multisig version\n * @param threshold - multisig threshold\n * @param pks - ordered list of public keys in this multisig\n * @returns encoded multisig blob\n */\nfunction createMultisigTransactionWithSignature(\n  txn: Transaction,\n  { rawSig, myPk }: MultisigOptions,\n  { version, threshold, pks }: MultisigMetadataWithPks,\n): Uint8Array {\n  // Create an empty encoded multisig transaction\n  const encodedMsig = createMultisigTransaction(txn, {\n    version,\n    threshold,\n    addrs: pks.map((pk) => new Address(pk)),\n  })\n  // note: this is not signed yet, but will be shortly\n  const signedTxn = decodeSignedTransaction(encodedMsig)\n\n  let keyExist = false\n\n  // append the multisig signature to the corresponding public key in the multisig blob\n  const updatedSubsigs = signedTxn.msig!.subsignatures.map((subsig) => {\n    if (arrayEqual(subsig.publicKey, myPk)) {\n      keyExist = true\n      return { ...subsig, signature: rawSig }\n    }\n    return subsig\n  })\n\n  if (!keyExist) {\n    throw new Error(MULTISIG_KEY_NOT_EXIST_ERROR_MSG)\n  }\n\n  const updatedSignedTxn: SignedTransaction = {\n    ...signedTxn,\n    msig: {\n      ...signedTxn.msig!,\n      subsignatures: updatedSubsigs,\n    },\n  }\n\n  return encodeSignedTransaction(updatedSignedTxn)\n}\n\n/**\n * takes a list of multisig transaction blobs, and merges them.\n * @param multisigTxnBlobs - a list of blobs representing encoded multisig txns\n * @returns typed array msg-pack encoded multisig txn\n */\nexport function mergeMultisigTransactions(multisigTxnBlobs: Uint8Array[]) {\n  if (multisigTxnBlobs.length < 2) {\n    throw new Error(MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG)\n  }\n  const refSigTx = decodeSignedTransaction(multisigTxnBlobs[0])\n  if (!refSigTx.msig) {\n    throw new Error('Invalid multisig transaction, multisig structure missing at index 0')\n  }\n  const refTxID = refSigTx.txn.txId()\n  const refAuthAddr = refSigTx.authAddress\n  const refPreImage = {\n    version: refSigTx.msig.version,\n    threshold: refSigTx.msig.threshold,\n    pks: refSigTx.msig.subsignatures.map((subsig) => subsig.publicKey),\n  }\n  const refMsigAddr = addressFromMultisigPreImg(refPreImage)\n\n  const newSubsigs: MultisigSubsignature[] = refSigTx.msig.subsignatures.map((sig) => ({ ...sig }))\n  for (let i = 1; i < multisigTxnBlobs.length; i++) {\n    const unisig = decodeSignedTransaction(multisigTxnBlobs[i])\n    if (!unisig.msig) {\n      throw new Error(`Invalid multisig transaction, multisig structure missing at index ${i}`)\n    }\n\n    if (unisig.txn.txId() !== refTxID) {\n      throw new Error(MULTISIG_MERGE_MISMATCH_ERROR_MSG)\n    }\n\n    const authAddr = unisig.authAddress\n    if (refAuthAddr !== authAddr) {\n      throw new Error(MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG)\n    }\n\n    // check multisig has same preimage as reference\n    if (unisig.msig.subsignatures.length !== refSigTx.msig.subsignatures.length) {\n      throw new Error(MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG)\n    }\n    const preimg: MultisigMetadataWithPks = {\n      version: unisig.msig.version,\n      threshold: unisig.msig.threshold,\n      pks: unisig.msig.subsignatures.map((subsig) => subsig.publicKey),\n    }\n    const msgigAddr = addressFromMultisigPreImg(preimg)\n    if (refMsigAddr.toString() !== msgigAddr.toString()) {\n      throw new Error(MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG)\n    }\n\n    // now, we can merge\n    unisig.msig.subsignatures.forEach((uniSubsig, index) => {\n      if (!uniSubsig.signature) return\n      const current = newSubsigs[index]\n      if (current.signature && !arrayEqual(uniSubsig.signature, current.signature)) {\n        // mismatch\n        throw new Error(MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG)\n      }\n      current.signature = uniSubsig.signature\n    })\n  }\n\n  const msig: MultisigSignature = {\n    version: refSigTx.msig.version,\n    threshold: refSigTx.msig.threshold,\n    subsignatures: newSubsigs,\n  }\n\n  const signedTxn: SignedTransaction = {\n    txn: refSigTx.txn,\n    msig: msig,\n    authAddress: refAuthAddr,\n  }\n\n  return encodeSignedTransaction(signedTxn)\n}\n\n/**\n * Partially signs this transaction with an external raw multisig signature and returns\n * a partially-signed multisig transaction, encoded with msgpack as a typed array.\n * @param transaction - The transaction to sign\n * @param metadata - multisig metadata\n * @param signerAddr - address of the signer\n * @param signature - raw multisig signature\n * @returns an encoded, partially signed multisig transaction.\n */\nfunction partialSignWithMultisigSignature(\n  transaction: Transaction,\n  metadata: MultisigMetadataWithPks,\n  signerAddr: string | Address,\n  signature: Uint8Array,\n) {\n  if (signature.length != SIGNATURE_BYTE_LENGTH) {\n    throw new Error(MULTISIG_SIGNATURE_LENGTH_ERROR_MSG)\n  }\n  const signerAddressObj = typeof signerAddr === 'string' ? Address.fromString(signerAddr) : signerAddr\n  return createMultisigTransactionWithSignature(\n    transaction,\n    {\n      rawSig: signature,\n      myPk: signerAddressObj.publicKey,\n    },\n    metadata,\n  )\n}\n\n/**\n * Takes a multisig transaction blob, and appends a given raw signature to it.\n * This makes it possible to compile a multisig signature using only raw signatures from external methods.\n * @param multisigTxnBlob - an encoded multisig txn. Supports non-payment txn types.\n * @param version - multisig version\n * @param threshold - multisig threshold\n * @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.\n * @param signerAddr - address of the signer\n * @param signature - raw multisig signature\n * @returns object containing txID, and blob representing encoded multisig txn\n */\nexport function appendSignRawMultisigSignature(\n  multisigTxnBlob: Uint8Array,\n  { version, threshold, addrs }: MultisigMetadata,\n  signerAddr: string | Address,\n  signature: Uint8Array,\n) {\n  const pks = toPublicKeys(addrs)\n  // obtain underlying txn, sign it, and merge it\n  const multisigTxObj = decodeSignedTransaction(multisigTxnBlob)\n  const partialSignedBlob = partialSignWithMultisigSignature(multisigTxObj.txn, { version, threshold, pks }, signerAddr, signature)\n  return {\n    txID: multisigTxObj.txn.txId(),\n    blob: mergeMultisigTransactions([multisigTxnBlob, partialSignedBlob]),\n  }\n}\n\n/**\n * Takes multisig parameters and returns a 32 byte typed array public key,\n * representing an address that identifies the \"exact group, version, and public keys\" that are required for signing.\n * Hash(\"MultisigAddr\" || version uint8 || threshold uint8 || PK1 || PK2 || ...)\n * Encoding this output yields a human readable address.\n * @param version - multisig version\n * @param threshold - multisig threshold\n * @param pks - array of typed array public keys\n */\nexport function addressFromMultisigPreImg({\n  version,\n  threshold,\n  pks,\n}: Omit<MultisigMetadata, 'addrs'> & {\n  pks: Uint8Array[]\n}): Address {\n  if (version > 255 || version < 0) {\n    // ^ a tad redundant, but in case in the future version != 1, still check for uint8\n    throw new Error(`${INVALID_MSIG_VERSION_ERROR_MSG}: ${version}`)\n  }\n  if (threshold === 0 || pks.length === 0 || threshold > pks.length || threshold > 255) {\n    throw new Error(INVALID_MSIG_THRESHOLD_ERROR_MSG)\n  }\n  const pkLen = ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH\n  if (pkLen !== PUBLIC_KEY_BYTE_LENGTH) {\n    throw new Error(UNEXPECTED_PK_LEN_ERROR_MSG)\n  }\n  const merged = new Uint8Array(MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + pkLen * pks.length)\n  merged.set(MULTISIG_PREIMG2ADDR_PREFIX, 0)\n  merged.set([version], MULTISIG_PREIMG2ADDR_PREFIX.length)\n  merged.set([threshold], MULTISIG_PREIMG2ADDR_PREFIX.length + 1)\n  for (let i = 0; i < pks.length; i++) {\n    if (pks[i].length !== pkLen) {\n      throw new Error(INVALID_MSIG_PK_ERROR_MSG)\n    }\n    merged.set(pks[i], MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + i * pkLen)\n  }\n  return new Address(Uint8Array.from(hash(merged)))\n}\n\n/**\n * Takes multisig parameters and returns a human readable Algorand address.\n * This is equivalent to fromMultisigPreImg, but interfaces with encoded addresses.\n * @param version - multisig version\n * @param threshold - multisig threshold\n * @param addrs - array of encoded addresses\n */\nexport function addressFromMultisigPreImgAddrs({ version, threshold, addrs }: MultisigMetadata): Address {\n  return addressFromMultisigPreImg({\n    version,\n    threshold,\n    pks: toPublicKeys(addrs),\n  })\n}\n\n/**\n * Takes multisig metadata (preimage) and returns the corresponding human readable Algorand address.\n * @param version - multisig version\n * @param threshold - multisig threshold\n * @param addrs - list of Algorand addresses\n */\nexport const multisigAddress: typeof addressFromMultisigPreImgAddrs = addressFromMultisigPreImgAddrs\n\nexport interface MultisigMetadata {\n  /**\n   * Multisig version\n   */\n  version: number\n\n  /**\n   * Multisig threshold value. Authorization requires a subset of signatures,\n   * equal to or greater than the threshold value.\n   */\n  threshold: number\n\n  /**\n   * A list of Algorand addresses representing possible signers for this multisig. Order is important.\n   */\n  addrs: Array<Address>\n}\n\n/** Account wrapper that supports partial or full multisig signing. */\nexport class MultisigAccount implements AddressWithTransactionSigner {\n  _params: MultisigMetadata\n  _subSigners: (AddressWithTransactionSigner & AddressWithDelegatedLsigSigner)[]\n  _addr: Address\n  _signer: TransactionSigner\n\n  /** The parameters for the multisig account */\n  get params(): Readonly<MultisigMetadata> {\n    return this._params\n  }\n\n  /** The list of accounts that are present to sign transactions or lsigs */\n  get subSigners() {\n    return this._subSigners\n  }\n\n  /** The address of the multisig account */\n  get addr(): Readonly<Address> {\n    return this._addr\n  }\n\n  /** The transaction signer for the multisig account */\n  get signer(): TransactionSigner {\n    return this._signer\n  }\n\n  constructor(multisigParams: MultisigMetadata, subSigners: (AddressWithTransactionSigner & AddressWithDelegatedLsigSigner)[]) {\n    this._params = multisigParams\n    this._subSigners = subSigners\n    this._addr = multisigAddress(multisigParams)\n    this._signer = async (txns: Transaction[], indexesToSign: number[]): Promise<Uint8Array[]> => {\n      const txnsToSign = txns.filter((_, index) => indexesToSign.includes(index))\n      const signedMsigTxns: Uint8Array[] = []\n\n      for (const txn of txnsToSign) {\n        let signedMsigTxn = createMultisigTransaction(txn, this._params)\n\n        for (const subSigner of this.subSigners) {\n          const stxn = (await subSigner.signer([txn], [0]))[0]\n          const sig = decodeSignedTransaction(stxn).sig\n\n          if (!sig) {\n            throw new Error(\n              `Signer for address ${subSigner.addr.toString()} did not produce a valid signature when signing ${txn.txId()} for multisig account ${this._addr.toString()}`,\n            )\n          }\n\n          signedMsigTxn = appendSignRawMultisigSignature(signedMsigTxn, this._params, subSigner.addr, sig).blob\n        }\n\n        signedMsigTxns.push(signedMsigTxn)\n      }\n\n      return signedMsigTxns\n    }\n  }\n}\n/**\n * Decodes MsgPack bytes into a multi signature.\n *\n * @param encodedMultiSignature - The MsgPack encoded multi signature\n * @returns The decoded MultisigSignature or an error if decoding fails.\n */\nexport function decodeMultiSignature(encodedMultiSignature: Uint8Array): MultisigSignature {\n  const decodedData = decodeMsgpack(encodedMultiSignature)\n  return multiSignatureCodec.decode(decodedData, 'msgpack')\n}\n"],"mappings":"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"}

package/packages/transact/src/signer.d.ts

@@ -0,0 +1,47 @@
+import { Address, Addressable, ReadableAddress } from "../../common/src/address.js";
+import { Expand } from "../../common/src/expand.js";
+import { Transaction } from "./transactions/transaction.js";
+import { DelegatedLsigSigner, ProgramDataSigner } from "./logicsig.js";
+
+//#region packages/transact/src/signer.d.ts
+/** Function for signing a group of transactions */
+type TransactionSigner = (txnGroup: Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+/** A transaction signer attached to an address */
+interface AddressWithTransactionSigner extends Addressable {
+  signer: TransactionSigner;
+}
+/** An address that can be used to send transactions that may or may not have a signer */
+type SendingAddress = ReadableAddress | AddressWithTransactionSigner;
+/** A delegated logic signature signer attached to an address */
+interface AddressWithDelegatedLsigSigner extends Addressable {
+  lsigSigner: DelegatedLsigSigner;
+}
+interface AddressWithProgramDataSigner extends Addressable {
+  programDataSigner: ProgramDataSigner;
+}
+type MxBytesSigner = (bytesToSign: Uint8Array) => Promise<Uint8Array>;
+interface AddressWithMxBytesSigner extends Addressable {
+  mxBytesSigner: MxBytesSigner;
+}
+type AddressWithSigners = Expand<Addressable & AddressWithTransactionSigner & AddressWithDelegatedLsigSigner & AddressWithProgramDataSigner & AddressWithMxBytesSigner>;
+/**
+ * Generate type-safe domain-separated signer callbacks given an ed25519 pubkey and a signing callback
+ * @param args - The arguments for generating signers
+ * @param args.ed25519Pubkey - The ed25519 public key used for signing
+ * @param args.sendingAddress - The address that will be used as the sender of transactions. If not provided, defaults to the address derived from the ed25519 public key. This is useful when signing for a rekeyed account where the sending address differs from the auth address.
+ * @param args.rawEd25519Signer - A callback function that signs raw bytes using the ed25519 private key
+ * @returns An object containing the sending address and various signer functions
+ */
+declare function generateAddressWithSigners(args: {
+  ed25519Pubkey: Uint8Array;
+  sendingAddress?: Address;
+  rawEd25519Signer: (bytesToSign: Uint8Array) => Promise<Uint8Array>;
+}): AddressWithSigners;
+/**
+ * Create a makeEmptyTransactionSigner that does not specify any signer or
+ * signing capabilities. This should only be used to simulate transactions.
+ */
+declare function makeEmptyTransactionSigner(): TransactionSigner;
+//#endregion
+export { AddressWithDelegatedLsigSigner, AddressWithMxBytesSigner, AddressWithProgramDataSigner, AddressWithSigners, AddressWithTransactionSigner, MxBytesSigner, SendingAddress, TransactionSigner, generateAddressWithSigners, makeEmptyTransactionSigner };
+//# sourceMappingURL=signer.d.ts.map

package/packages/transact/src/signer.js

@@ -0,0 +1,71 @@
+const require_array = require('../../common/src/array.js');
+const require_address = require('../../common/src/address.js');
+const require_transaction = require('./transactions/transaction.js');
+const require_signed_transaction = require('./transactions/signed-transaction.js');
+
+//#region packages/transact/src/signer.ts
+const SIGN_BYTES_PREFIX = Uint8Array.from([77, 88]);
+/**
+* Generate type-safe domain-separated signer callbacks given an ed25519 pubkey and a signing callback
+* @param args - The arguments for generating signers
+* @param args.ed25519Pubkey - The ed25519 public key used for signing
+* @param args.sendingAddress - The address that will be used as the sender of transactions. If not provided, defaults to the address derived from the ed25519 public key. This is useful when signing for a rekeyed account where the sending address differs from the auth address.
+* @param args.rawEd25519Signer - A callback function that signs raw bytes using the ed25519 private key
+* @returns An object containing the sending address and various signer functions
+*/
+function generateAddressWithSigners(args) {
+	const { ed25519Pubkey, rawEd25519Signer } = args;
+	const authAddr = new require_address.Address(ed25519Pubkey);
+	const sendingAddress = args.sendingAddress ?? authAddr;
+	const signer = async (txnGroup, indexesToSign) => {
+		const stxns = [];
+		for (const index of indexesToSign) {
+			const txn = txnGroup[index];
+			const stxn = {
+				txn,
+				sig: await rawEd25519Signer(require_transaction.encodeTransaction(txn))
+			};
+			if (!txn.sender.equals(sendingAddress)) stxn.authAddress = authAddr;
+			stxns.push(stxn);
+		}
+		return stxns.map(require_signed_transaction.encodeSignedTransaction);
+	};
+	const lsigSigner = async (lsig, msig) => {
+		return await rawEd25519Signer(lsig.bytesToSignForDelegation(msig));
+	};
+	const programDataSigner = async (data, lsig) => {
+		return await rawEd25519Signer(lsig.programDataToSign(data));
+	};
+	const mxBytesSigner = async (bytes) => {
+		return await rawEd25519Signer(require_array.concatArrays(SIGN_BYTES_PREFIX, bytes));
+	};
+	return {
+		addr: sendingAddress,
+		signer,
+		lsigSigner,
+		programDataSigner,
+		mxBytesSigner
+	};
+}
+/**
+* Create a makeEmptyTransactionSigner that does not specify any signer or
+* signing capabilities. This should only be used to simulate transactions.
+*/
+function makeEmptyTransactionSigner() {
+	return (txnGroup, indexesToSign) => {
+		const unsigned = [];
+		for (const index of indexesToSign) {
+			const stxn = {
+				txn: txnGroup[index],
+				sig: new Uint8Array(64).fill(0)
+			};
+			unsigned.push(require_signed_transaction.encodeSignedTransaction(stxn));
+		}
+		return Promise.resolve(unsigned);
+	};
+}
+
+//#endregion
+exports.generateAddressWithSigners = generateAddressWithSigners;
+exports.makeEmptyTransactionSigner = makeEmptyTransactionSigner;
+//# sourceMappingURL=signer.js.map

package/packages/transact/src/signer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.js","names":["Address","signer: TransactionSigner","stxns: SignedTransaction[]","stxn: SignedTransaction","encodeTransaction","encodeSignedTransaction","lsigSigner: DelegatedLsigSigner","programDataSigner: ProgramDataSigner","mxBytesSigner: MxBytesSigner","concatArrays","unsigned: Uint8Array[]"],"sources":["../../../../packages/transact/src/signer.ts"],"sourcesContent":["import { Address, Addressable, concatArrays, Expand, ReadableAddress } from '@algorandfoundation/algokit-common'\nimport { encodeTransaction, Transaction } from './transactions/transaction'\nimport { DelegatedLsigSigner, ProgramDataSigner } from './logicsig'\nimport { encodeSignedTransaction, SignedTransaction } from './transactions/signed-transaction'\n\n/** Function for signing a group of transactions */\nexport type TransactionSigner = (txnGroup: Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>\n\n/** A transaction signer attached to an address */\nexport interface AddressWithTransactionSigner extends Addressable {\n  signer: TransactionSigner\n}\n\n/** An address that can be used to send transactions that may or may not have a signer */\nexport type SendingAddress = ReadableAddress | AddressWithTransactionSigner\n\n/** A delegated logic signature signer attached to an address */\nexport interface AddressWithDelegatedLsigSigner extends Addressable {\n  lsigSigner: DelegatedLsigSigner\n}\n\nexport interface AddressWithProgramDataSigner extends Addressable {\n  programDataSigner: ProgramDataSigner\n}\n\nexport type MxBytesSigner = (bytesToSign: Uint8Array) => Promise<Uint8Array>\n\nexport interface AddressWithMxBytesSigner extends Addressable {\n  mxBytesSigner: MxBytesSigner\n}\n\nexport type AddressWithSigners = Expand<\n  Addressable & AddressWithTransactionSigner & AddressWithDelegatedLsigSigner & AddressWithProgramDataSigner & AddressWithMxBytesSigner\n>\n\nconst SIGN_BYTES_PREFIX = Uint8Array.from([77, 88]) // \"MX\"\n\n/**\n * Generate type-safe domain-separated signer callbacks given an ed25519 pubkey and a signing callback\n * @param args - The arguments for generating signers\n * @param args.ed25519Pubkey - The ed25519 public key used for signing\n * @param args.sendingAddress - The address that will be used as the sender of transactions. If not provided, defaults to the address derived from the ed25519 public key. This is useful when signing for a rekeyed account where the sending address differs from the auth address.\n * @param args.rawEd25519Signer - A callback function that signs raw bytes using the ed25519 private key\n * @returns An object containing the sending address and various signer functions\n */\nexport function generateAddressWithSigners(args: {\n  ed25519Pubkey: Uint8Array\n  sendingAddress?: Address\n  rawEd25519Signer: (bytesToSign: Uint8Array) => Promise<Uint8Array>\n}): AddressWithSigners {\n  const { ed25519Pubkey, rawEd25519Signer } = args\n  const authAddr = new Address(ed25519Pubkey)\n  const sendingAddress = args.sendingAddress ?? authAddr\n\n  const signer: TransactionSigner = async (txnGroup: Transaction[], indexesToSign: number[]) => {\n    const stxns: SignedTransaction[] = []\n    for (const index of indexesToSign) {\n      const txn = txnGroup[index]\n      const bytesToSign = encodeTransaction(txn)\n      const signature = await rawEd25519Signer(bytesToSign)\n      const stxn: SignedTransaction = {\n        txn,\n        sig: signature,\n      }\n\n      if (!txn.sender.equals(sendingAddress)) {\n        stxn.authAddress = authAddr\n      }\n\n      stxns.push(stxn)\n    }\n\n    return stxns.map(encodeSignedTransaction)\n  }\n\n  const lsigSigner: DelegatedLsigSigner = async (lsig, msig) => {\n    const bytesToSign = lsig.bytesToSignForDelegation(msig)\n    return await rawEd25519Signer(bytesToSign)\n  }\n\n  const programDataSigner: ProgramDataSigner = async (data, lsig) => {\n    const bytesToSign = lsig.programDataToSign(data)\n    return await rawEd25519Signer(bytesToSign)\n  }\n\n  const mxBytesSigner: MxBytesSigner = async (bytes: Uint8Array) => {\n    const bytesToSign = concatArrays(SIGN_BYTES_PREFIX, bytes)\n    return await rawEd25519Signer(bytesToSign)\n  }\n\n  return { addr: sendingAddress, signer, lsigSigner, programDataSigner, mxBytesSigner }\n}\n\n/**\n * Create a makeEmptyTransactionSigner that does not specify any signer or\n * signing capabilities. This should only be used to simulate transactions.\n */\nexport function makeEmptyTransactionSigner(): TransactionSigner {\n  return (txnGroup: Transaction[], indexesToSign: number[]) => {\n    const unsigned: Uint8Array[] = []\n\n    for (const index of indexesToSign) {\n      const stxn: SignedTransaction = {\n        txn: txnGroup[index],\n        sig: new Uint8Array(64).fill(0),\n      }\n      unsigned.push(encodeSignedTransaction(stxn))\n    }\n\n    return Promise.resolve(unsigned)\n  }\n}\n"],"mappings":";;;;;;AAmCA,MAAM,oBAAoB,WAAW,KAAK,CAAC,IAAI,GAAG,CAAC;;;;;;;;;AAUnD,SAAgB,2BAA2B,MAIpB;CACrB,MAAM,EAAE,eAAe,qBAAqB;CAC5C,MAAM,WAAW,IAAIA,wBAAQ,cAAc;CAC3C,MAAM,iBAAiB,KAAK,kBAAkB;CAE9C,MAAMC,SAA4B,OAAO,UAAyB,kBAA4B;EAC5F,MAAMC,QAA6B,EAAE;AACrC,OAAK,MAAM,SAAS,eAAe;GACjC,MAAM,MAAM,SAAS;GAGrB,MAAMC,OAA0B;IAC9B;IACA,KAHgB,MAAM,iBADJC,sCAAkB,IAAI,CACW;IAIpD;AAED,OAAI,CAAC,IAAI,OAAO,OAAO,eAAe,CACpC,MAAK,cAAc;AAGrB,SAAM,KAAK,KAAK;;AAGlB,SAAO,MAAM,IAAIC,mDAAwB;;CAG3C,MAAMC,aAAkC,OAAO,MAAM,SAAS;AAE5D,SAAO,MAAM,iBADO,KAAK,yBAAyB,KAAK,CACb;;CAG5C,MAAMC,oBAAuC,OAAO,MAAM,SAAS;AAEjE,SAAO,MAAM,iBADO,KAAK,kBAAkB,KAAK,CACN;;CAG5C,MAAMC,gBAA+B,OAAO,UAAsB;AAEhE,SAAO,MAAM,iBADOC,2BAAa,mBAAmB,MAAM,CAChB;;AAG5C,QAAO;EAAE,MAAM;EAAgB;EAAQ;EAAY;EAAmB;EAAe;;;;;;AAOvF,SAAgB,6BAAgD;AAC9D,SAAQ,UAAyB,kBAA4B;EAC3D,MAAMC,WAAyB,EAAE;AAEjC,OAAK,MAAM,SAAS,eAAe;GACjC,MAAMP,OAA0B;IAC9B,KAAK,SAAS;IACd,KAAK,IAAI,WAAW,GAAG,CAAC,KAAK,EAAE;IAChC;AACD,YAAS,KAAKE,mDAAwB,KAAK,CAAC;;AAG9C,SAAO,QAAQ,QAAQ,SAAS"}

package/packages/transact/src/signer.mjs

@@ -0,0 +1,70 @@
+import { concatArrays } from "../../common/src/array.mjs";
+import { Address } from "../../common/src/address.mjs";
+import { encodeTransaction } from "./transactions/transaction.mjs";
+import { encodeSignedTransaction } from "./transactions/signed-transaction.mjs";
+
+//#region packages/transact/src/signer.ts
+const SIGN_BYTES_PREFIX = Uint8Array.from([77, 88]);
+/**
+* Generate type-safe domain-separated signer callbacks given an ed25519 pubkey and a signing callback
+* @param args - The arguments for generating signers
+* @param args.ed25519Pubkey - The ed25519 public key used for signing
+* @param args.sendingAddress - The address that will be used as the sender of transactions. If not provided, defaults to the address derived from the ed25519 public key. This is useful when signing for a rekeyed account where the sending address differs from the auth address.
+* @param args.rawEd25519Signer - A callback function that signs raw bytes using the ed25519 private key
+* @returns An object containing the sending address and various signer functions
+*/
+function generateAddressWithSigners(args) {
+	const { ed25519Pubkey, rawEd25519Signer } = args;
+	const authAddr = new Address(ed25519Pubkey);
+	const sendingAddress = args.sendingAddress ?? authAddr;
+	const signer = async (txnGroup, indexesToSign) => {
+		const stxns = [];
+		for (const index of indexesToSign) {
+			const txn = txnGroup[index];
+			const stxn = {
+				txn,
+				sig: await rawEd25519Signer(encodeTransaction(txn))
+			};
+			if (!txn.sender.equals(sendingAddress)) stxn.authAddress = authAddr;
+			stxns.push(stxn);
+		}
+		return stxns.map(encodeSignedTransaction);
+	};
+	const lsigSigner = async (lsig, msig) => {
+		return await rawEd25519Signer(lsig.bytesToSignForDelegation(msig));
+	};
+	const programDataSigner = async (data, lsig) => {
+		return await rawEd25519Signer(lsig.programDataToSign(data));
+	};
+	const mxBytesSigner = async (bytes) => {
+		return await rawEd25519Signer(concatArrays(SIGN_BYTES_PREFIX, bytes));
+	};
+	return {
+		addr: sendingAddress,
+		signer,
+		lsigSigner,
+		programDataSigner,
+		mxBytesSigner
+	};
+}
+/**
+* Create a makeEmptyTransactionSigner that does not specify any signer or
+* signing capabilities. This should only be used to simulate transactions.
+*/
+function makeEmptyTransactionSigner() {
+	return (txnGroup, indexesToSign) => {
+		const unsigned = [];
+		for (const index of indexesToSign) {
+			const stxn = {
+				txn: txnGroup[index],
+				sig: new Uint8Array(64).fill(0)
+			};
+			unsigned.push(encodeSignedTransaction(stxn));
+		}
+		return Promise.resolve(unsigned);
+	};
+}
+
+//#endregion
+export { generateAddressWithSigners, makeEmptyTransactionSigner };
+//# sourceMappingURL=signer.mjs.map

package/packages/transact/src/signer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.mjs","names":["signer: TransactionSigner","stxns: SignedTransaction[]","stxn: SignedTransaction","lsigSigner: DelegatedLsigSigner","programDataSigner: ProgramDataSigner","mxBytesSigner: MxBytesSigner","unsigned: Uint8Array[]"],"sources":["../../../../packages/transact/src/signer.ts"],"sourcesContent":["import { Address, Addressable, concatArrays, Expand, ReadableAddress } from '@algorandfoundation/algokit-common'\nimport { encodeTransaction, Transaction } from './transactions/transaction'\nimport { DelegatedLsigSigner, ProgramDataSigner } from './logicsig'\nimport { encodeSignedTransaction, SignedTransaction } from './transactions/signed-transaction'\n\n/** Function for signing a group of transactions */\nexport type TransactionSigner = (txnGroup: Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>\n\n/** A transaction signer attached to an address */\nexport interface AddressWithTransactionSigner extends Addressable {\n  signer: TransactionSigner\n}\n\n/** An address that can be used to send transactions that may or may not have a signer */\nexport type SendingAddress = ReadableAddress | AddressWithTransactionSigner\n\n/** A delegated logic signature signer attached to an address */\nexport interface AddressWithDelegatedLsigSigner extends Addressable {\n  lsigSigner: DelegatedLsigSigner\n}\n\nexport interface AddressWithProgramDataSigner extends Addressable {\n  programDataSigner: ProgramDataSigner\n}\n\nexport type MxBytesSigner = (bytesToSign: Uint8Array) => Promise<Uint8Array>\n\nexport interface AddressWithMxBytesSigner extends Addressable {\n  mxBytesSigner: MxBytesSigner\n}\n\nexport type AddressWithSigners = Expand<\n  Addressable & AddressWithTransactionSigner & AddressWithDelegatedLsigSigner & AddressWithProgramDataSigner & AddressWithMxBytesSigner\n>\n\nconst SIGN_BYTES_PREFIX = Uint8Array.from([77, 88]) // \"MX\"\n\n/**\n * Generate type-safe domain-separated signer callbacks given an ed25519 pubkey and a signing callback\n * @param args - The arguments for generating signers\n * @param args.ed25519Pubkey - The ed25519 public key used for signing\n * @param args.sendingAddress - The address that will be used as the sender of transactions. If not provided, defaults to the address derived from the ed25519 public key. This is useful when signing for a rekeyed account where the sending address differs from the auth address.\n * @param args.rawEd25519Signer - A callback function that signs raw bytes using the ed25519 private key\n * @returns An object containing the sending address and various signer functions\n */\nexport function generateAddressWithSigners(args: {\n  ed25519Pubkey: Uint8Array\n  sendingAddress?: Address\n  rawEd25519Signer: (bytesToSign: Uint8Array) => Promise<Uint8Array>\n}): AddressWithSigners {\n  const { ed25519Pubkey, rawEd25519Signer } = args\n  const authAddr = new Address(ed25519Pubkey)\n  const sendingAddress = args.sendingAddress ?? authAddr\n\n  const signer: TransactionSigner = async (txnGroup: Transaction[], indexesToSign: number[]) => {\n    const stxns: SignedTransaction[] = []\n    for (const index of indexesToSign) {\n      const txn = txnGroup[index]\n      const bytesToSign = encodeTransaction(txn)\n      const signature = await rawEd25519Signer(bytesToSign)\n      const stxn: SignedTransaction = {\n        txn,\n        sig: signature,\n      }\n\n      if (!txn.sender.equals(sendingAddress)) {\n        stxn.authAddress = authAddr\n      }\n\n      stxns.push(stxn)\n    }\n\n    return stxns.map(encodeSignedTransaction)\n  }\n\n  const lsigSigner: DelegatedLsigSigner = async (lsig, msig) => {\n    const bytesToSign = lsig.bytesToSignForDelegation(msig)\n    return await rawEd25519Signer(bytesToSign)\n  }\n\n  const programDataSigner: ProgramDataSigner = async (data, lsig) => {\n    const bytesToSign = lsig.programDataToSign(data)\n    return await rawEd25519Signer(bytesToSign)\n  }\n\n  const mxBytesSigner: MxBytesSigner = async (bytes: Uint8Array) => {\n    const bytesToSign = concatArrays(SIGN_BYTES_PREFIX, bytes)\n    return await rawEd25519Signer(bytesToSign)\n  }\n\n  return { addr: sendingAddress, signer, lsigSigner, programDataSigner, mxBytesSigner }\n}\n\n/**\n * Create a makeEmptyTransactionSigner that does not specify any signer or\n * signing capabilities. This should only be used to simulate transactions.\n */\nexport function makeEmptyTransactionSigner(): TransactionSigner {\n  return (txnGroup: Transaction[], indexesToSign: number[]) => {\n    const unsigned: Uint8Array[] = []\n\n    for (const index of indexesToSign) {\n      const stxn: SignedTransaction = {\n        txn: txnGroup[index],\n        sig: new Uint8Array(64).fill(0),\n      }\n      unsigned.push(encodeSignedTransaction(stxn))\n    }\n\n    return Promise.resolve(unsigned)\n  }\n}\n"],"mappings":";;;;;;AAmCA,MAAM,oBAAoB,WAAW,KAAK,CAAC,IAAI,GAAG,CAAC;;;;;;;;;AAUnD,SAAgB,2BAA2B,MAIpB;CACrB,MAAM,EAAE,eAAe,qBAAqB;CAC5C,MAAM,WAAW,IAAI,QAAQ,cAAc;CAC3C,MAAM,iBAAiB,KAAK,kBAAkB;CAE9C,MAAMA,SAA4B,OAAO,UAAyB,kBAA4B;EAC5F,MAAMC,QAA6B,EAAE;AACrC,OAAK,MAAM,SAAS,eAAe;GACjC,MAAM,MAAM,SAAS;GAGrB,MAAMC,OAA0B;IAC9B;IACA,KAHgB,MAAM,iBADJ,kBAAkB,IAAI,CACW;IAIpD;AAED,OAAI,CAAC,IAAI,OAAO,OAAO,eAAe,CACpC,MAAK,cAAc;AAGrB,SAAM,KAAK,KAAK;;AAGlB,SAAO,MAAM,IAAI,wBAAwB;;CAG3C,MAAMC,aAAkC,OAAO,MAAM,SAAS;AAE5D,SAAO,MAAM,iBADO,KAAK,yBAAyB,KAAK,CACb;;CAG5C,MAAMC,oBAAuC,OAAO,MAAM,SAAS;AAEjE,SAAO,MAAM,iBADO,KAAK,kBAAkB,KAAK,CACN;;CAG5C,MAAMC,gBAA+B,OAAO,UAAsB;AAEhE,SAAO,MAAM,iBADO,aAAa,mBAAmB,MAAM,CAChB;;AAG5C,QAAO;EAAE,MAAM;EAAgB;EAAQ;EAAY;EAAmB;EAAe;;;;;;AAOvF,SAAgB,6BAAgD;AAC9D,SAAQ,UAAyB,kBAA4B;EAC3D,MAAMC,WAAyB,EAAE;AAEjC,OAAK,MAAM,SAAS,eAAe;GACjC,MAAMJ,OAA0B;IAC9B,KAAK,SAAS;IACd,KAAK,IAAI,WAAW,GAAG,CAAC,KAAK,EAAE;IAChC;AACD,YAAS,KAAK,wBAAwB,KAAK,CAAC;;AAG9C,SAAO,QAAQ,QAAQ,SAAS"}