@algorandfoundation/algokit-utils 10.0.0-alpha.2 → 10.0.0-alpha.20

package/packages/transact/src/multisig.mjs

@@ -2,42 +2,11 @@ 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).
@@ -45,12 +14,12 @@ function addressFromMultisigSignature(multisigSignature) {
 */
 function applyMultisigSubsignature(multisigSignature, participant, signature) {
 	let found = false;
-	const newSubsignatures = multisigSignature.subsignatures.map((subsig) => {
+	const newSubsignatures = multisigSignature.subsigs.map((subsig) => {
 		if (arrayEqual(subsig.publicKey, participant)) {
 			found = true;
 			return {
 				...subsig,
-				signature
+				sig: signature
 			};
 		}
 		return subsig;
@@ -58,30 +27,7 @@ function applyMultisigSubsignature(multisigSignature, participant, signature) {
 	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
+		subsigs: newSubsignatures
 	};
 }
 const MULTISIG_PREIMG2ADDR_PREFIX = new Uint8Array([
@@ -107,8 +53,6 @@ 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";
 /**
@@ -124,23 +68,23 @@ function createMultisigTransaction(txn, { version, threshold, addrs }) {
 	const msig = {
 		version,
 		threshold,
-		subsignatures: pks.map((pk) => ({
+		subsigs: pks.map((pk) => ({
 			publicKey: pk,
-			signature: void 0
+			sig: void 0
 		}))
 	};
 	const msigAddr = addressFromMultisigPreImg({
 		version,
 		threshold,
-		pks
+		publicKeys: pks
 	});
 	let authAddress;
 	if (!msigAddr.equals(txn.sender)) authAddress = msigAddr;
-	return encodeSignedTransaction({
+	return {
 		txn,
 		msig,
 		authAddress
-	});
+	};
 }
 /**
 * creates a multisig transaction blob with an included signature.
@@ -152,31 +96,31 @@ function createMultisigTransaction(txn, { version, threshold, addrs }) {
 * @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, {
+function createMultisigTransactionWithSignature(txn, { rawSig, myPk }, { version, threshold, publicKeys }) {
+	const signedTxn = createMultisigTransaction(txn, {
 		version,
 		threshold,
-		addrs: pks.map((pk) => new Address(pk))
-	}));
+		addrs: publicKeys.map((pk) => new Address(pk))
+	});
 	let keyExist = false;
-	const updatedSubsigs = signedTxn.msig.subsignatures.map((subsig) => {
+	const updatedSubsigs = signedTxn.msig.subsigs.map((subsig) => {
 		if (arrayEqual(subsig.publicKey, myPk)) {
 			keyExist = true;
 			return {
 				...subsig,
-				signature: rawSig
+				sig: rawSig
 			};
 		}
 		return subsig;
 	});
 	if (!keyExist) throw new Error(MULTISIG_KEY_NOT_EXIST_ERROR_MSG);
-	return encodeSignedTransaction({
+	return {
 		...signedTxn,
 		msig: {
 			...signedTxn.msig,
-			subsignatures: updatedSubsigs
+			subsigs: updatedSubsigs
 		}
-	});
+	};
 }
 /**
 * takes a list of multisig transaction blobs, and merges them.
@@ -185,44 +129,44 @@ function createMultisigTransactionWithSignature(txn, { rawSig, myPk }, { version
 */
 function mergeMultisigTransactions(multisigTxnBlobs) {
 	if (multisigTxnBlobs.length < 2) throw new Error(MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG);
-	const refSigTx = decodeSignedTransaction(multisigTxnBlobs[0]);
+	const refSigTx = 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)
+		publicKeys: refSigTx.msig.subsigs.map((subsig) => subsig.publicKey)
 	});
-	const newSubsigs = refSigTx.msig.subsignatures.map((sig) => ({ ...sig }));
+	const newSubsigs = refSigTx.msig.subsigs.map((sig) => ({ ...sig }));
 	for (let i = 1; i < multisigTxnBlobs.length; i++) {
-		const unisig = decodeSignedTransaction(multisigTxnBlobs[i]);
+		const unisig = 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);
+		if (unisig.msig.subsigs.length !== refSigTx.msig.subsigs.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)
+			publicKeys: unisig.msig.subsigs.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;
+		unisig.msig.subsigs.forEach((uniSubsig, index) => {
+			if (!uniSubsig.sig) 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;
+			if (current.sig && !arrayEqual(uniSubsig.sig, current.sig)) throw new Error(MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG);
+			current.sig = uniSubsig.sig;
 		});
 	}
-	return encodeSignedTransaction({
+	return {
 		txn: refSigTx.txn,
 		msig: {
 			version: refSigTx.msig.version,
 			threshold: refSigTx.msig.threshold,
-			subsignatures: newSubsigs
+			subsigs: newSubsigs
 		},
 		authAddress: refAuthAddr
-	});
+	};
 }
 /**
 * Partially signs this transaction with an external raw multisig signature and returns
@@ -251,18 +195,13 @@ function partialSignWithMultisigSignature(transaction, metadata, signerAddr, sig
 * @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, {
+function appendSignRawMultisigSignature(multisigTxn, { version, threshold, addrs }, signerAddr, signature) {
+	const publicKeys = toPublicKeys(addrs);
+	return mergeMultisigTransactions([multisigTxn, partialSignWithMultisigSignature(multisigTxn.txn, {
 		version,
 		threshold,
-		pks
-	}, signerAddr, signature);
-	return {
-		txID: multisigTxObj.txn.txId(),
-		blob: mergeMultisigTransactions([multisigTxnBlob, partialSignedBlob])
-	};
+		publicKeys
+	}, signerAddr, signature)]);
 }
 /**
 * Takes multisig parameters and returns a 32 byte typed array public key,
@@ -273,18 +212,18 @@ function appendSignRawMultisigSignature(multisigTxnBlob, { version, threshold, a
 * @param threshold - multisig threshold
 * @param pks - array of typed array public keys
 */
-function addressFromMultisigPreImg({ version, threshold, pks }) {
+function addressFromMultisigPreImg({ version, threshold, publicKeys }) {
 	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);
+	if (threshold === 0 || publicKeys.length === 0 || threshold > publicKeys.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);
+	const merged = new Uint8Array(MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + pkLen * publicKeys.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);
+	for (let i = 0; i < publicKeys.length; i++) {
+		if (publicKeys[i].length !== pkLen) throw new Error(INVALID_MSIG_PK_ERROR_MSG);
+		merged.set(publicKeys[i], MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + i * pkLen);
 	}
 	return new Address(Uint8Array.from(hash(merged)));
 }
@@ -299,7 +238,7 @@ function addressFromMultisigPreImgAddrs({ version, threshold, addrs }) {
 	return addressFromMultisigPreImg({
 		version,
 		threshold,
-		pks: toPublicKeys(addrs)
+		publicKeys: toPublicKeys(addrs)
 	});
 }
 /**
@@ -310,7 +249,7 @@ function addressFromMultisigPreImgAddrs({ version, threshold, addrs }) {
 */
 const multisigAddress = addressFromMultisigPreImgAddrs;
 /** Account wrapper that supports partial or full multisig signing. */
-var MultisigAccount = class {
+var MultisigAccount = class MultisigAccount {
 	_params;
 	_subSigners;
 	_addr;
@@ -331,6 +270,13 @@ var MultisigAccount = class {
 	get signer() {
 		return this._signer;
 	}
+	static fromSignature(signature) {
+		return new MultisigAccount({
+			version: signature.version,
+			threshold: signature.threshold,
+			addrs: signature.subsigs.map((subsig) => new Address(subsig.publicKey))
+		}, []);
+	}
 	constructor(multisigParams, subSigners) {
 		this._params = multisigParams;
 		this._subSigners = subSigners;
@@ -344,25 +290,49 @@ var MultisigAccount = class {
 					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;
+					signedMsigTxn = appendSignRawMultisigSignature(signedMsigTxn, this._params, subSigner.addr, sig);
 				}
 				signedMsigTxns.push(signedMsigTxn);
 			}
-			return signedMsigTxns;
+			return signedMsigTxns.map(encodeSignedTransaction);
+		};
+	}
+	createMultisigTransaction(txn) {
+		return createMultisigTransaction(txn, this._params);
+	}
+	createMultisigSignature() {
+		const subsignatures = toPublicKeys(this._params.addrs).map((pk) => ({
+			publicKey: pk,
+			signature: void 0
+		}));
+		return {
+			version: this._params.version,
+			threshold: this._params.threshold,
+			subsigs: subsignatures
 		};
 	}
+	applySignatureToTxn(txn, pubkey, signature) {
+		if (!txn.msig) txn.msig = this.createMultisigTransaction(txn.txn).msig;
+		txn.msig = applyMultisigSubsignature(txn.msig, pubkey, signature);
+	}
+	applySignature(msigSignature, pubkey, signature) {
+		if (msigSignature.version !== this._params.version || msigSignature.threshold !== this._params.threshold) {
+			const thisParams = {
+				version: this._params.version,
+				threshold: this._params.threshold,
+				participants: this._params.addrs.map((addr) => addr.toString())
+			};
+			const givenParams = {
+				version: msigSignature.version,
+				threshold: msigSignature.threshold,
+				participants: msigSignature.subsigs.map((subsig) => new Address(subsig.publicKey).toString())
+			};
+			throw new Error(`Multisig signature parameters do not match expected multisig parameters. Multisig params: ${JSON.stringify(thisParams)}, signature: ${JSON.stringify(givenParams)}`);
+		}
+		return applyMultisigSubsignature(msigSignature, pubkey, signature);
+	}
 };
-/**
-* 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 };
+export { MultisigAccount };
 //# sourceMappingURL=multisig.mjs.map

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

@@ -1 +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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"}
+{"version":3,"file":"multisig.mjs","names":["msig: MultisigSignature","authAddress: Address | undefined","newSubsigs: MultisigSubsignature[]","multisigAddress: typeof addressFromMultisigPreImgAddrs","signedMsigTxns: SignedTransaction[]","subsignatures: MultisigSubsignature[]"],"sources":["../../../../packages/transact/src/multisig.ts"],"sourcesContent":["import {\n  Address,\n  ALGORAND_ADDRESS_BYTE_LENGTH,\n  ALGORAND_CHECKSUM_BYTE_LENGTH,\n  arrayEqual,\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 { Transaction } from './transactions/transaction'\n\nconst toPublicKeys = (addrs: Array<string | Address>): Uint8Array[] => addrs.map((addr) => getAddress(addr).publicKey)\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 */\nfunction applyMultisigSubsignature(\n  multisigSignature: MultisigSignature,\n  participant: Uint8Array,\n  signature: Uint8Array,\n): MultisigSignature {\n  let found = false\n  const newSubsignatures = multisigSignature.subsigs.map((subsig) => {\n    if (arrayEqual(subsig.publicKey, participant)) {\n      found = true\n      return { ...subsig, sig: signature } satisfies MultisigSubsignature\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    subsigs: newSubsignatures,\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\nconst MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG = 'Not enough multisig transactions to merge. Need at least two'\nconst MULTISIG_MERGE_MISMATCH_ERROR_MSG = 'Cannot merge txs. txIDs differ'\nconst MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG = 'Cannot merge txs. Auth addrs differ'\nconst MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = 'Cannot merge txs. Multisig preimages differ'\nconst MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = 'Cannot merge txs. subsigs are mismatched.'\nconst 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 */\nfunction createMultisigTransaction(txn: Transaction, { version, threshold, addrs }: MultisigMetadata) {\n  // construct the appendable multisigned transaction format\n  const pks = toPublicKeys(addrs)\n  const subsignatures = pks.map(\n    (pk) =>\n      ({\n        publicKey: pk,\n        sig: undefined,\n      }) satisfies MultisigSubsignature,\n  )\n\n  const msig: MultisigSignature = {\n    version,\n    threshold,\n    subsigs: 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    publicKeys: 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 signedTxn\n}\n\ninterface MultisigOptions {\n  rawSig: Uint8Array\n  myPk: Uint8Array\n}\n\ninterface MultisigMetadataWithPublicKeys extends Omit<MultisigMetadata, 'addrs'> {\n  publicKeys: 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, publicKeys }: MultisigMetadataWithPublicKeys,\n): SignedTransaction {\n  // Create an empty encoded multisig transaction\n  const signedTxn = createMultisigTransaction(txn, {\n    version,\n    threshold,\n    addrs: publicKeys.map((pk) => new Address(pk)),\n  })\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!.subsigs.map((subsig) => {\n    if (arrayEqual(subsig.publicKey, myPk)) {\n      keyExist = true\n      return { ...subsig, sig: 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      subsigs: updatedSubsigs,\n    },\n  }\n\n  return 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 */\nfunction mergeMultisigTransactions(multisigTxnBlobs: SignedTransaction[]): SignedTransaction {\n  if (multisigTxnBlobs.length < 2) {\n    throw new Error(MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG)\n  }\n  const refSigTx = 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    publicKeys: refSigTx.msig.subsigs.map((subsig) => subsig.publicKey),\n  }\n  const refMsigAddr = addressFromMultisigPreImg(refPreImage)\n\n  const newSubsigs: MultisigSubsignature[] = refSigTx.msig.subsigs.map((sig) => ({ ...sig }))\n  for (let i = 1; i < multisigTxnBlobs.length; i++) {\n    const unisig = 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.subsigs.length !== refSigTx.msig.subsigs.length) {\n      throw new Error(MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG)\n    }\n    const preimg: MultisigMetadataWithPublicKeys = {\n      version: unisig.msig.version,\n      threshold: unisig.msig.threshold,\n      publicKeys: unisig.msig.subsigs.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.subsigs.forEach((uniSubsig, index) => {\n      if (!uniSubsig.sig) return\n      const current = newSubsigs[index]\n      if (current.sig && !arrayEqual(uniSubsig.sig, current.sig)) {\n        // mismatch\n        throw new Error(MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG)\n      }\n      current.sig = uniSubsig.sig\n    })\n  }\n\n  const msig: MultisigSignature = {\n    version: refSigTx.msig.version,\n    threshold: refSigTx.msig.threshold,\n    subsigs: newSubsigs,\n  }\n\n  const signedTxn: SignedTransaction = {\n    txn: refSigTx.txn,\n    msig: msig,\n    authAddress: refAuthAddr,\n  }\n\n  return 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: MultisigMetadataWithPublicKeys,\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 */\nfunction appendSignRawMultisigSignature(\n  multisigTxn: SignedTransaction,\n  { version, threshold, addrs }: MultisigMetadata,\n  signerAddr: string | Address,\n  signature: Uint8Array,\n): SignedTransaction {\n  const publicKeys = toPublicKeys(addrs)\n  // obtain underlying txn, sign it, and merge it\n  const partialSigned = partialSignWithMultisigSignature(multisigTxn.txn, { version, threshold, publicKeys }, signerAddr, signature)\n  return mergeMultisigTransactions([multisigTxn, partialSigned])\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 */\nfunction addressFromMultisigPreImg({\n  version,\n  threshold,\n  publicKeys,\n}: Omit<MultisigMetadata, 'addrs'> & {\n  publicKeys: 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 || publicKeys.length === 0 || threshold > publicKeys.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 * publicKeys.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 < publicKeys.length; i++) {\n    if (publicKeys[i].length !== pkLen) {\n      throw new Error(INVALID_MSIG_PK_ERROR_MSG)\n    }\n    merged.set(publicKeys[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 */\nfunction addressFromMultisigPreImgAddrs({ version, threshold, addrs }: MultisigMetadata): Address {\n  return addressFromMultisigPreImg({\n    version,\n    threshold,\n    publicKeys: 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 */\nconst 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  static fromSignature(signature: MultisigSignature): MultisigAccount {\n    const params: MultisigMetadata = {\n      version: signature.version,\n      threshold: signature.threshold,\n      addrs: signature.subsigs.map((subsig) => new Address(subsig.publicKey)),\n    }\n\n    return new MultisigAccount(params, [])\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: SignedTransaction[] = []\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)\n        }\n\n        signedMsigTxns.push(signedMsigTxn)\n      }\n\n      return signedMsigTxns.map(encodeSignedTransaction)\n    }\n  }\n\n  createMultisigTransaction(txn: Transaction): SignedTransaction {\n    return createMultisigTransaction(txn, this._params)\n  }\n\n  createMultisigSignature(): MultisigSignature {\n    const pks = toPublicKeys(this._params.addrs)\n    const subsignatures: MultisigSubsignature[] = pks.map((pk) => ({\n      publicKey: pk,\n      signature: undefined,\n    }))\n\n    return {\n      version: this._params.version,\n      threshold: this._params.threshold,\n      subsigs: subsignatures,\n    }\n  }\n\n  applySignatureToTxn(txn: SignedTransaction, pubkey: Uint8Array, signature: Uint8Array): void {\n    if (!txn.msig) {\n      const createdTxn = this.createMultisigTransaction(txn.txn)\n      txn.msig = createdTxn.msig\n    }\n\n    txn.msig = applyMultisigSubsignature(txn.msig!, pubkey, signature)\n  }\n\n  applySignature(msigSignature: MultisigSignature, pubkey: Uint8Array, signature: Uint8Array): MultisigSignature {\n    if (msigSignature.version !== this._params.version || msigSignature.threshold !== this._params.threshold) {\n      const thisParams = {\n        version: this._params.version,\n        threshold: this._params.threshold,\n        participants: this._params.addrs.map((addr) => addr.toString()),\n      }\n\n      const givenParams = {\n        version: msigSignature.version,\n        threshold: msigSignature.threshold,\n        participants: msigSignature.subsigs.map((subsig) => new Address(subsig.publicKey).toString()),\n      }\n\n      throw new Error(\n        `Multisig signature parameters do not match expected multisig parameters. Multisig params: ${JSON.stringify(thisParams)}, signature: ${JSON.stringify(givenParams)}`,\n      )\n    }\n\n    return applyMultisigSubsignature(msigSignature, pubkey, signature)\n  }\n}\n"],"mappings":"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"}

package/packages/transact/src/transactions/app-call.d.ts

@@ -1,5 +1,4 @@
 import { Address } from "../../../common/src/address.js";
-import { TransactionValidationError } from "./common.js";
 
 //#region packages/transact/src/transactions/app-call.d.ts
 
@@ -88,10 +87,10 @@ type AppCallTransactionFields = {
   /**
    * Resources accessed by the application
    */
-  accessReferences?: AccessReference[];
+  accessReferences?: ResourceReference[];
   /**
-   * The lowest application version for which this transaction should immediately fail. 0 indicates that no version check should be performed.
-   */
+   * If set, the transaction will be rejected when the app's version is greater than or equal to this value. This can be used to prevent calling an app after it has been updated. Set to 0 or leave undefined to skip the version check.
+   * */
   rejectVersion?: number;
 };
 /**
@@ -169,7 +168,7 @@ type BoxReference = {
 /**
  * Names a single resource reference. Only one of the fields should be set.
  */
-interface AccessReference {
+type ResourceReference = {
   /** Any account addresses whose balance record is accessible by the executing ApprovalProgram or ClearStateProgram. */
   address?: Address;
   /** Application ID whose GlobalState may be read by the executing ApprovalProgram or ClearStateProgram. */
@@ -182,28 +181,24 @@ interface AccessReference {
   locals?: LocalsReference;
   /** Defines a box by its name and the application ID it belongs to. */
   box?: BoxReference;
-}
+};
 /**
  * A grouping of the asset index and address of the account
  */
-interface HoldingReference {
+type HoldingReference = {
   /** The asset index of the holding */
   assetId: bigint;
   /** The address of the account holding the asset */
   address: Address;
-}
+};
 /** A grouping of the application index and address of the account
  */
-interface LocalsReference {
+type LocalsReference = {
   /** The application index of the local state */
   appId: bigint;
   /** The address of the account holding the local state */
   address: Address;
-}
-/**
- * Validate app call transaction fields
- */
-declare function validateAppCallTransaction(appCall: AppCallTransactionFields): TransactionValidationError[];
+};
 //#endregion
-export { AccessReference, AppCallTransactionFields, BoxReference, HoldingReference, LocalsReference, OnApplicationComplete, StateSchema, validateAppCallTransaction };
+export { AppCallTransactionFields, BoxReference, HoldingReference, LocalsReference, OnApplicationComplete, ResourceReference, StateSchema };
 //# sourceMappingURL=app-call.d.ts.map