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

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

@@ -1,115 +1,10 @@
 import { Address } from "../../common/src/address.js";
 import { Transaction } from "./transactions/transaction.js";
-import { MultisigSignature } from "./transactions/signed-transaction.js";
+import { MultisigSignature, SignedTransaction } from "./transactions/signed-transaction.js";
+import { DelegatedLsigSigner } from "./logicsig.js";
 import { AddressWithDelegatedLsigSigner, AddressWithTransactionSigner, TransactionSigner } from "./signer.js";
 
 //#region packages/transact/src/multisig.d.ts
-
-/**
- * Creates an empty multisignature signature from a list of participant public keys.
- */
-declare function newMultisigSignature(version: number, threshold: number, participants: Uint8Array[]): MultisigSignature;
-/**
- * Returns the list of participant public keys from a multisignature signature.
- */
-declare function participantsFromMultisigSignature(multisigSignature: MultisigSignature): Uint8Array[];
-/**
- * Returns the address of the multisignature account.
- */
-declare function addressFromMultisigSignature(multisigSignature: MultisigSignature): Address;
-/**
- * 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.
- */
-declare function applyMultisigSubsignature(multisigSignature: MultisigSignature, participant: Uint8Array, signature: Uint8Array): MultisigSignature;
-/**
- * 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.
- */
-declare function mergeMultisignatures(multisigSignatureA: MultisigSignature, multisigSignatureB: MultisigSignature): MultisigSignature;
-declare const MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG = "Not enough multisig transactions to merge. Need at least two";
-declare const MULTISIG_MERGE_MISMATCH_ERROR_MSG = "Cannot merge txs. txIDs differ";
-declare const MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG = "Cannot merge txs. Auth addrs differ";
-declare const MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = "Cannot merge txs. Multisig preimages differ";
-declare const MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = "Cannot merge txs. subsigs are mismatched.";
-declare const MULTISIG_NO_MUTATE_ERROR_MSG = "Cannot mutate a multisig field as it would invalidate all existing signatures.";
-declare const MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG = "Cannot sign a multisig transaction using `signTxn`. Use `partialSignTxn` instead.";
-declare const MULTISIG_SIGNATURE_LENGTH_ERROR_MSG = "Cannot add multisig signature. Signature is not of the correct length.";
-/**
- * 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
- */
-declare function createMultisigTransaction(txn: Transaction, {
-  version,
-  threshold,
-  addrs
-}: MultisigMetadata): Uint8Array;
-/**
- * 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
- */
-declare function mergeMultisigTransactions(multisigTxnBlobs: Uint8Array[]): Uint8Array;
-/**
- * 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
- */
-declare function appendSignRawMultisigSignature(multisigTxnBlob: Uint8Array, {
-  version,
-  threshold,
-  addrs
-}: MultisigMetadata, signerAddr: string | Address, signature: Uint8Array): {
-  txID: string;
-  blob: Uint8Array;
-};
-/**
- * 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
- */
-declare function addressFromMultisigPreImg({
-  version,
-  threshold,
-  publicKeys
-}: Omit<MultisigMetadata, 'addrs'> & {
-  publicKeys: Uint8Array[];
-}): Address;
-/**
- * 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
- */
-declare function addressFromMultisigPreImgAddrs({
-  version,
-  threshold,
-  addrs
-}: MultisigMetadata): Address;
-/**
- * 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
- */
-declare const multisigAddress: typeof addressFromMultisigPreImgAddrs;
 interface MultisigMetadata {
   /**
    * Multisig version
@@ -126,11 +21,12 @@ interface MultisigMetadata {
   addrs: Array<Address>;
 }
 /** Account wrapper that supports partial or full multisig signing. */
-declare class MultisigAccount implements AddressWithTransactionSigner {
+declare class MultisigAccount implements AddressWithTransactionSigner, AddressWithDelegatedLsigSigner {
   _params: MultisigMetadata;
   _subSigners: (AddressWithTransactionSigner & AddressWithDelegatedLsigSigner)[];
   _addr: Address;
   _signer: TransactionSigner;
+  _lsigSigner: DelegatedLsigSigner;
   /** The parameters for the multisig account */
   get params(): Readonly<MultisigMetadata>;
   /** The list of accounts that are present to sign transactions or lsigs */
@@ -139,15 +35,14 @@ declare class MultisigAccount implements AddressWithTransactionSigner {
   get addr(): Readonly<Address>;
   /** The transaction signer for the multisig account */
   get signer(): TransactionSigner;
+  get lsigSigner(): DelegatedLsigSigner;
+  static fromSignature(signature: MultisigSignature): MultisigAccount;
   constructor(multisigParams: MultisigMetadata, subSigners: (AddressWithTransactionSigner & AddressWithDelegatedLsigSigner)[]);
+  createMultisigTransaction(txn: Transaction): SignedTransaction;
+  createMultisigSignature(): MultisigSignature;
+  applySignatureToTxn(txn: SignedTransaction, pubkey: Uint8Array, signature: Uint8Array): void;
+  applySignature(msigSignature: MultisigSignature, pubkey: Uint8Array, signature: Uint8Array): MultisigSignature;
 }
-/**
- * Decodes MsgPack bytes into a multi signature.
- *
- * @param encodedMultiSignature - The MsgPack encoded multi signature
- * @returns The decoded MultisigSignature or an error if decoding fails.
- */
-declare function decodeMultiSignature(encodedMultiSignature: Uint8Array): MultisigSignature;
 //#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, MultisigMetadata, addressFromMultisigPreImg, addressFromMultisigPreImgAddrs, addressFromMultisigSignature, appendSignRawMultisigSignature, applyMultisigSubsignature, createMultisigTransaction, decodeMultiSignature, mergeMultisigTransactions, mergeMultisignatures, multisigAddress, newMultisigSignature, participantsFromMultisigSignature };
+export { MultisigAccount, MultisigMetadata };
 //# sourceMappingURL=multisig.d.ts.map

package/packages/transact/src/multisig.js

@@ -1,43 +1,11 @@
-const require_array = require('../../common/src/array.js');
-const require_constants = require('../../common/src/constants.js');
-const require_address = require('../../common/src/address.js');
-const require_crypto = require('../../common/src/crypto.js');
-const require_msgpack = require('../../common/src/msgpack.js');
-const require_signed_transaction_meta = require('./transactions/signed-transaction-meta.js');
-const require_signed_transaction = require('./transactions/signed-transaction.js');
-
+const require_array = require("../../common/src/array.js");
+require("../../common/src/constants.js");
+const require_address = require("../../common/src/address.js");
+const require_hash = require("../../crypto/src/hash.js");
+const require_signed_transaction = require("./transactions/signed-transaction.js");
 //#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) => require_address.getAddress(addr).publicKey);
 /**
-* Returns the address of the multisignature account.
-*/
-function addressFromMultisigSignature(multisigSignature) {
-	return addressFromMultisigPreImg({
-		version: multisigSignature.version,
-		threshold: multisigSignature.threshold,
-		publicKeys: 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 +13,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 (require_array.arrayEqual(subsig.publicKey, participant)) {
 			found = true;
 			return {
 				...subsig,
-				signature
+				sig: signature
 			};
 		}
 		return subsig;
@@ -58,30 +26,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) => require_array.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 +52,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,9 +67,9 @@ 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({
@@ -136,11 +79,11 @@ function createMultisigTransaction(txn, { version, threshold, addrs }) {
 	});
 	let authAddress;
 	if (!msigAddr.equals(txn.sender)) authAddress = msigAddr;
-	return require_signed_transaction.encodeSignedTransaction({
+	return {
 		txn,
 		msig,
 		authAddress
-	});
+	};
 }
 /**
 * creates a multisig transaction blob with an included signature.
@@ -153,30 +96,30 @@ function createMultisigTransaction(txn, { version, threshold, addrs }) {
 * @returns encoded multisig blob
 */
 function createMultisigTransactionWithSignature(txn, { rawSig, myPk }, { version, threshold, publicKeys }) {
-	const signedTxn = require_signed_transaction.decodeSignedTransaction(createMultisigTransaction(txn, {
+	const signedTxn = createMultisigTransaction(txn, {
 		version,
 		threshold,
 		addrs: publicKeys.map((pk) => new require_address.Address(pk))
-	}));
+	});
 	let keyExist = false;
-	const updatedSubsigs = signedTxn.msig.subsignatures.map((subsig) => {
+	const updatedSubsigs = signedTxn.msig.subsigs.map((subsig) => {
 		if (require_array.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 require_signed_transaction.encodeSignedTransaction({
+	return {
 		...signedTxn,
 		msig: {
 			...signedTxn.msig,
-			subsignatures: updatedSubsigs
+			subsigs: updatedSubsigs
 		}
-	});
+	};
 }
 /**
 * takes a list of multisig transaction blobs, and merges them.
@@ -185,44 +128,44 @@ function createMultisigTransactionWithSignature(txn, { rawSig, myPk }, { version
 */
 function mergeMultisigTransactions(multisigTxnBlobs) {
 	if (multisigTxnBlobs.length < 2) throw new Error(MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG);
-	const refSigTx = require_signed_transaction.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,
-		publicKeys: 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 = require_signed_transaction.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,
-			publicKeys: 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 && !require_array.arrayEqual(uniSubsig.signature, current.signature)) throw new Error(MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG);
-			current.signature = uniSubsig.signature;
+			if (current.sig && !require_array.arrayEqual(uniSubsig.sig, current.sig)) throw new Error(MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG);
+			current.sig = uniSubsig.sig;
 		});
 	}
-	return require_signed_transaction.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
@@ -234,7 +177,7 @@ function mergeMultisigTransactions(multisigTxnBlobs) {
 * @returns an encoded, partially signed multisig transaction.
 */
 function partialSignWithMultisigSignature(transaction, metadata, signerAddr, signature) {
-	if (signature.length != require_constants.SIGNATURE_BYTE_LENGTH) throw new Error(MULTISIG_SIGNATURE_LENGTH_ERROR_MSG);
+	if (signature.length != 64) throw new Error(MULTISIG_SIGNATURE_LENGTH_ERROR_MSG);
 	return createMultisigTransactionWithSignature(transaction, {
 		rawSig: signature,
 		myPk: (typeof signerAddr === "string" ? require_address.Address.fromString(signerAddr) : signerAddr).publicKey
@@ -251,18 +194,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) {
+function appendSignRawMultisigSignature(multisigTxn, { version, threshold, addrs }, signerAddr, signature) {
 	const publicKeys = toPublicKeys(addrs);
-	const multisigTxObj = require_signed_transaction.decodeSignedTransaction(multisigTxnBlob);
-	const partialSignedBlob = partialSignWithMultisigSignature(multisigTxObj.txn, {
+	return mergeMultisigTransactions([multisigTxn, partialSignWithMultisigSignature(multisigTxn.txn, {
 		version,
 		threshold,
 		publicKeys
-	}, signerAddr, signature);
-	return {
-		txID: multisigTxObj.txn.txId(),
-		blob: mergeMultisigTransactions([multisigTxnBlob, partialSignedBlob])
-	};
+	}, signerAddr, signature)]);
 }
 /**
 * Takes multisig parameters and returns a 32 byte typed array public key,
@@ -276,8 +214,8 @@ function appendSignRawMultisigSignature(multisigTxnBlob, { version, threshold, a
 function addressFromMultisigPreImg({ version, threshold, publicKeys }) {
 	if (version > 255 || version < 0) throw new Error(`${INVALID_MSIG_VERSION_ERROR_MSG}: ${version}`);
 	if (threshold === 0 || publicKeys.length === 0 || threshold > publicKeys.length || threshold > 255) throw new Error(INVALID_MSIG_THRESHOLD_ERROR_MSG);
-	const pkLen = require_address.ALGORAND_ADDRESS_BYTE_LENGTH - require_address.ALGORAND_CHECKSUM_BYTE_LENGTH;
-	if (pkLen !== require_constants.PUBLIC_KEY_BYTE_LENGTH) throw new Error(UNEXPECTED_PK_LEN_ERROR_MSG);
+	const pkLen = 32;
+	if (pkLen !== 32) throw new Error(UNEXPECTED_PK_LEN_ERROR_MSG);
 	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);
@@ -286,7 +224,7 @@ function addressFromMultisigPreImg({ version, threshold, publicKeys }) {
 		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 require_address.Address(Uint8Array.from(require_crypto.hash(merged)));
+	return new require_address.Address(Uint8Array.from(require_hash.hash(merged)));
 }
 /**
 * Takes multisig parameters and returns a human readable Algorand address.
@@ -310,11 +248,12 @@ 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;
 	_signer;
+	_lsigSigner;
 	/** The parameters for the multisig account */
 	get params() {
 		return this._params;
@@ -331,6 +270,16 @@ var MultisigAccount = class {
 	get signer() {
 		return this._signer;
 	}
+	get lsigSigner() {
+		return this._lsigSigner;
+	}
+	static fromSignature(signature) {
+		return new MultisigAccount({
+			version: signature.version,
+			threshold: signature.threshold,
+			addrs: signature.subsigs.map((subsig) => new require_address.Address(subsig.publicKey))
+		}, []);
+	}
 	constructor(multisigParams, subSigners) {
 		this._params = multisigParams;
 		this._subSigners = subSigners;
@@ -344,45 +293,65 @@ var MultisigAccount = class {
 					const stxn = (await subSigner.signer([txn], [0]))[0];
 					const sig = require_signed_transaction.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((stxn) => {
+				require_signed_transaction.validateSignedTransaction(stxn);
+				return require_signed_transaction.encodeSignedTransaction(stxn);
+			});
 		};
+		this._lsigSigner = async (lsig, _) => {
+			let lmsig = lsig.lmsig ?? this.createMultisigSignature();
+			for (const addrWithSigner of this.subSigners) {
+				const { lsigSigner, addr } = addrWithSigner;
+				const result = await lsigSigner(lsig, this);
+				if (!("sig" in result) || !result.sig) throw new Error(`Signer for address ${addr.toString()} did not produce a valid signature when signing logic sig for multisig account ${this._addr.toString()}`);
+				lmsig = this.applySignature(lmsig, addr.publicKey, result.sig);
+			}
+			return {
+				addr: this.addr,
+				lmsig
+			};
+		};
+	}
+	createMultisigTransaction(txn) {
+		return createMultisigTransaction(txn, this._params);
+	}
+	createMultisigSignature() {
+		const subsignatures = toPublicKeys(this._params.addrs).map((pk) => ({
+			publicKey: pk,
+			sig: 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 require_address.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 = require_msgpack.decodeMsgpack(encodedMultiSignature);
-	return require_signed_transaction_meta.multiSignatureCodec.decode(decodedData, "msgpack");
-}
-
 //#endregion
-exports.MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG = MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG;
-exports.MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG = MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG;
-exports.MULTISIG_MERGE_MISMATCH_ERROR_MSG = MULTISIG_MERGE_MISMATCH_ERROR_MSG;
-exports.MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG;
-exports.MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG;
-exports.MULTISIG_NO_MUTATE_ERROR_MSG = MULTISIG_NO_MUTATE_ERROR_MSG;
-exports.MULTISIG_SIGNATURE_LENGTH_ERROR_MSG = MULTISIG_SIGNATURE_LENGTH_ERROR_MSG;
-exports.MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG = MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG;
 exports.MultisigAccount = MultisigAccount;
-exports.addressFromMultisigPreImg = addressFromMultisigPreImg;
-exports.addressFromMultisigPreImgAddrs = addressFromMultisigPreImgAddrs;
-exports.addressFromMultisigSignature = addressFromMultisigSignature;
-exports.appendSignRawMultisigSignature = appendSignRawMultisigSignature;
-exports.applyMultisigSubsignature = applyMultisigSubsignature;
-exports.createMultisigTransaction = createMultisigTransaction;
-exports.decodeMultiSignature = decodeMultiSignature;
-exports.mergeMultisigTransactions = mergeMultisigTransactions;
-exports.mergeMultisignatures = mergeMultisignatures;
-exports.multisigAddress = multisigAddress;
-exports.newMultisigSignature = newMultisigSignature;
-exports.participantsFromMultisigSignature = participantsFromMultisigSignature;
+
 //# sourceMappingURL=multisig.js.map