@algorandfoundation/algokit-utils 10.0.0-alpha.9 → 10.0.0-beta.2

package/packages/transact/src/logicsig.mjs

@@ -1,46 +1,83 @@
 import { concatArrays } from "../../common/src/array.mjs";
-import { Address, isValidAddress } from "../../common/src/address.mjs";
-import { hash } from "../../common/src/crypto.mjs";
+import { Address } from "../../common/src/address.mjs";
 import { decodeMsgpack } from "../../common/src/msgpack.mjs";
-import { logicSignatureCodec } from "./transactions/signed-transaction-meta.mjs";
-import { encodeSignedTransaction } from "./transactions/signed-transaction.mjs";
-
+import { hash } from "../../crypto/src/hash.mjs";
+import { logicSigSignatureCodec } from "./transactions/signed-transaction-meta.mjs";
+import { encodeSignedTransaction, validateSignedTransaction } from "./transactions/signed-transaction.mjs";
+import { MultisigAccount } from "./multisig.mjs";
 //#region packages/transact/src/logicsig.ts
-const base64regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
-/** sanityCheckProgram performs heuristic program validation:
-* check if passed in bytes are Algorand address or is B64 encoded, rather than Teal bytes
-*
-* @param program - Program bytes to check
-*/
-function sanityCheckProgram(program) {
-	if (!program || program.length === 0) throw new Error("empty program");
-	const lineBreakOrd = "\n".charCodeAt(0);
-	const blankSpaceOrd = " ".charCodeAt(0);
-	const tildeOrd = "~".charCodeAt(0);
-	const isPrintable = (x) => blankSpaceOrd <= x && x <= tildeOrd;
-	if (program.every((x) => x === lineBreakOrd || isPrintable(x))) {
-		const programStr = new TextDecoder().decode(program);
-		if (isValidAddress(programStr)) throw new Error("requesting program bytes, get Algorand address");
-		if (base64regex.test(programStr)) throw new Error("program should not be b64 encoded");
-		throw new Error("program bytes are all ASCII printable characters, not looking like Teal byte code");
-	}
-}
 const PROGRAM_TAG = new TextEncoder().encode("Program");
 const MSIG_PROGRAM_TAG = new TextEncoder().encode("MsigProgram");
 const SIGN_PROGRAM_DATA_PREFIX = new TextEncoder().encode("ProgData");
-var LogicSigAccount = class {
+var LogicSig = class LogicSig {
 	logic;
 	args;
+	_addr;
+	constructor(program, programArgs) {
+		this.logic = program;
+		this.args = programArgs ?? [];
+		this._addr = new Address(hash(concatArrays(PROGRAM_TAG, this.logic)));
+	}
+	static fromSignature(signature) {
+		return new LogicSig(signature.logic, signature.args || []);
+	}
+	static fromBytes(encodedLsig) {
+		const decoded = decodeMsgpack(encodedLsig);
+		const lsigSignature = logicSigSignatureCodec.decode(decoded, "msgpack");
+		return LogicSig.fromSignature(lsigSignature);
+	}
+	address() {
+		return this._addr;
+	}
+	get addr() {
+		return this._addr;
+	}
+	bytesToSignForDelegation(msig) {
+		if (msig) return concatArrays(MSIG_PROGRAM_TAG, msig.addr.publicKey, this.logic);
+		else return concatArrays(PROGRAM_TAG, this.logic);
+	}
+	signProgramData(data, signer) {
+		return signer(data, this);
+	}
+	programDataToSign(data) {
+		return concatArrays(SIGN_PROGRAM_DATA_PREFIX, this.address().publicKey, data);
+	}
+	account() {
+		return new LogicSigAccount(this.logic, this.args);
+	}
+	delegatedAccount(delegator) {
+		return new LogicSigAccount(this.logic, this.args, delegator);
+	}
+};
+var LogicSigAccount = class LogicSigAccount extends LogicSig {
 	sig;
 	msig;
 	lmsig;
-	constructor(program, programArgs) {
-		if (programArgs && (!Array.isArray(programArgs) || !programArgs.every((arg) => arg.constructor === Uint8Array))) throw new TypeError("Invalid arguments");
-		let args = [];
-		if (programArgs != null) args = programArgs.map((arg) => new Uint8Array(arg));
-		sanityCheckProgram(program);
-		this.logic = program;
-		this.args = args;
+	static fromSignature(signature, delegator) {
+		if (signature.lmsig || signature.msig) {
+			const msigAddr = MultisigAccount.fromSignature(signature.lmsig || signature.msig).addr;
+			if (delegator && !msigAddr.equals(delegator)) throw new Error("Provided delegator address does not match multisig address");
+			const lsig = new LogicSigAccount(signature.logic, signature.args || [], msigAddr);
+			lsig.lmsig = signature.lmsig;
+			lsig.msig = signature.msig;
+			return lsig;
+		}
+		const lsigAccount = new LogicSigAccount(signature.logic, signature.args || [], delegator);
+		if (signature.sig && delegator === void 0) throw new Error("Delegated address must be provided when logic sig has a signature");
+		if (signature.sig) {
+			lsigAccount.sig = signature.sig;
+			return lsigAccount;
+		}
+		return lsigAccount;
+	}
+	static fromBytes(encodedLsig, delegator) {
+		const decoded = decodeMsgpack(encodedLsig);
+		const lsigSignature = logicSigSignatureCodec.decode(decoded, "msgpack");
+		return LogicSigAccount.fromSignature(lsigSignature, delegator);
+	}
+	constructor(program, programArgs, delegator) {
+		super(program, programArgs ?? void 0);
+		this._addr = delegator ?? this._addr;
 	}
 	get signer() {
 		return async (txns, indexes) => {
@@ -56,61 +93,22 @@ var LogicSigAccount = class {
 						sig: this.sig
 					}
 				};
+				if (!stxn.txn.sender.equals(this.addr)) stxn.authAddress = this.addr;
+				validateSignedTransaction(stxn);
 				signedTxns.push(encodeSignedTransaction(stxn));
 			}
 			return signedTxns;
 		};
 	}
-	get addr() {
-		return this.address();
-	}
-	/**
-	* Compute hash of the logic sig program (that is the same as escrow account address) as string address
-	* @returns String representation of the address
-	*/
-	address() {
-		return new Address(hash(concatArrays(PROGRAM_TAG, this.logic)));
-	}
-	async delegate(signer) {
-		this.sig = await signer(this);
-	}
-	async delegateMultisig(msig) {
-		if (this.lmsig == void 0) this.lmsig = {
-			subsigs: [],
-			version: msig.params.version,
-			threshold: msig.params.threshold
-		};
-		for (const addrWithSigner of msig.subSigners) {
-			const { lsigSigner, addr } = addrWithSigner;
-			const signature = await lsigSigner(this, msig);
-			this.lmsig.subsigs.push({
-				publicKey: addr.publicKey,
-				sig: signature
-			});
-		}
-	}
-	bytesToSignForDelegation(msig) {
-		if (msig) return concatArrays(MSIG_PROGRAM_TAG, msig.addr.publicKey, this.logic);
-		else return concatArrays(PROGRAM_TAG, this.logic);
-	}
-	signProgramData(data, signer) {
-		return signer(data, this);
-	}
-	programDataToSign(data) {
-		return concatArrays(SIGN_PROGRAM_DATA_PREFIX, this.address().publicKey, data);
+	async signForDelegation(delegator) {
+		const result = await delegator.lsigSigner(this);
+		if (!result.addr.equals(this._addr)) throw new Error(`Delegator address from signer does not match expected delegator address. Expected: ${this._addr.toString()}, got: ${result.addr.toString()}`);
+		if ("sig" in result && result.sig) this.sig = result.sig;
+		else if ("lmsig" in result && result.lmsig) this.lmsig = result.lmsig;
+		else throw new Error("Delegated lsig signer must return either a sig or lmsig");
 	}
 };
-/**
-* Decodes MsgPack bytes into a logic signature.
-*
-* @param encodedLogicSignature - The MsgPack encoded logic signature
-* @returns The decoded LogicSignature or an error if decoding fails.
-*/
-function decodeLogicSignature(encodedLogicSignature) {
-	const decodedData = decodeMsgpack(encodedLogicSignature);
-	return logicSignatureCodec.decode(decodedData, "msgpack");
-}
-
 //#endregion
-export { LogicSigAccount, decodeLogicSignature, sanityCheckProgram };
+export { LogicSig, LogicSigAccount };
+
 //# sourceMappingURL=logicsig.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"logicsig.mjs","names":["args: Uint8Array[]","signedTxns: Uint8Array[]","stxn: SignedTransaction"],"sources":["../../../../packages/transact/src/logicsig.ts"],"sourcesContent":["import { Address, concatArrays, decodeMsgpack, hash, isValidAddress } from '@algorandfoundation/algokit-common'\nimport { MultisigAccount } from './multisig'\nimport { TransactionSigner } from './signer'\nimport { LogicSignature, MultisigSignature, SignedTransaction, encodeSignedTransaction } from './transactions/signed-transaction'\nimport { logicSignatureCodec } from './transactions/signed-transaction-meta'\nimport { Transaction } from './transactions/transaction'\n\n// base64regex is the regex to test for base64 strings\nconst base64regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/\n\n/** sanityCheckProgram performs heuristic program validation:\n * check if passed in bytes are Algorand address or is B64 encoded, rather than Teal bytes\n *\n * @param program - Program bytes to check\n */\nexport function sanityCheckProgram(program: Uint8Array) {\n  if (!program || program.length === 0) throw new Error('empty program')\n\n  const lineBreakOrd = '\\n'.charCodeAt(0)\n  const blankSpaceOrd = ' '.charCodeAt(0)\n  const tildeOrd = '~'.charCodeAt(0)\n\n  const isPrintable = (x: number) => blankSpaceOrd <= x && x <= tildeOrd\n  const isAsciiPrintable = program.every((x: number) => x === lineBreakOrd || isPrintable(x))\n\n  if (isAsciiPrintable) {\n    const programStr = new TextDecoder().decode(program)\n\n    if (isValidAddress(programStr)) throw new Error('requesting program bytes, get Algorand address')\n\n    if (base64regex.test(programStr)) throw new Error('program should not be b64 encoded')\n\n    throw new Error('program bytes are all ASCII printable characters, not looking like Teal byte code')\n  }\n}\n\nconst PROGRAM_TAG = new TextEncoder().encode('Program')\nconst MSIG_PROGRAM_TAG = new TextEncoder().encode('MsigProgram')\nconst SIGN_PROGRAM_DATA_PREFIX = new TextEncoder().encode('ProgData')\n\n/** Function for signing logic signatures for delegation */\nexport type DelegatedLsigSigner = (lsig: LogicSigAccount, msig?: MultisigAccount) => Promise<Uint8Array>\n\n/** Function for signing program data for a logic signature */\nexport type ProgramDataSigner = (data: Uint8Array, lsig: LogicSigAccount) => Promise<Uint8Array>\n\nexport class LogicSigAccount {\n  logic: Uint8Array\n  args: Uint8Array[]\n  sig?: Uint8Array\n  msig?: MultisigSignature\n  lmsig?: MultisigSignature\n\n  constructor(program: Uint8Array, programArgs?: Array<Uint8Array> | null) {\n    if (programArgs && (!Array.isArray(programArgs) || !programArgs.every((arg) => arg.constructor === Uint8Array))) {\n      throw new TypeError('Invalid arguments')\n    }\n\n    let args: Uint8Array[] = []\n    if (programArgs != null) args = programArgs.map((arg) => new Uint8Array(arg))\n\n    sanityCheckProgram(program)\n\n    this.logic = program\n    this.args = args\n  }\n\n  get signer(): TransactionSigner {\n    return async (txns: Transaction[], indexes: number[]) => {\n      const signedTxns: Uint8Array[] = []\n      for (const index of indexes) {\n        const txn = txns[index]\n\n        const stxn: SignedTransaction = {\n          txn,\n          lsig: { logic: this.logic, args: this.args, msig: this.msig, lmsig: this.lmsig, sig: this.sig },\n        }\n\n        signedTxns.push(encodeSignedTransaction(stxn))\n      }\n\n      return signedTxns\n    }\n  }\n\n  get addr(): Address {\n    return this.address()\n  }\n\n  /**\n   * Compute hash of the logic sig program (that is the same as escrow account address) as string address\n   * @returns String representation of the address\n   */\n  address(): Address {\n    const toBeSigned = concatArrays(PROGRAM_TAG, this.logic)\n    const h = hash(toBeSigned)\n    return new Address(h)\n  }\n\n  async delegate(signer: DelegatedLsigSigner) {\n    this.sig = await signer(this)\n  }\n\n  async delegateMultisig(msig: MultisigAccount) {\n    if (this.lmsig == undefined) {\n      this.lmsig = {\n        subsigs: [],\n        version: msig.params.version,\n        threshold: msig.params.threshold,\n      }\n    }\n    for (const addrWithSigner of msig.subSigners) {\n      const { lsigSigner, addr } = addrWithSigner\n      const signature = await lsigSigner(this, msig)\n\n      this.lmsig.subsigs.push({ publicKey: addr.publicKey, sig: signature })\n    }\n  }\n\n  bytesToSignForDelegation(msig?: MultisigAccount): Uint8Array {\n    if (msig) {\n      return concatArrays(MSIG_PROGRAM_TAG, msig.addr.publicKey, this.logic)\n    } else {\n      return concatArrays(PROGRAM_TAG, this.logic)\n    }\n  }\n\n  signProgramData(data: Uint8Array, signer: ProgramDataSigner): Promise<Uint8Array> {\n    return signer(data, this)\n  }\n\n  programDataToSign(data: Uint8Array): Uint8Array {\n    return concatArrays(SIGN_PROGRAM_DATA_PREFIX, this.address().publicKey, data)\n  }\n}\n\n/**\n * Decodes MsgPack bytes into a logic signature.\n *\n * @param encodedLogicSignature - The MsgPack encoded logic signature\n * @returns The decoded LogicSignature or an error if decoding fails.\n */\nexport function decodeLogicSignature(encodedLogicSignature: Uint8Array): LogicSignature {\n  const decodedData = decodeMsgpack(encodedLogicSignature)\n  return logicSignatureCodec.decode(decodedData, 'msgpack')\n}\n"],"mappings":";;;;;;;;AAQA,MAAM,cAAc;;;;;;AAOpB,SAAgB,mBAAmB,SAAqB;AACtD,KAAI,CAAC,WAAW,QAAQ,WAAW,EAAG,OAAM,IAAI,MAAM,gBAAgB;CAEtE,MAAM,eAAe,KAAK,WAAW,EAAE;CACvC,MAAM,gBAAgB,IAAI,WAAW,EAAE;CACvC,MAAM,WAAW,IAAI,WAAW,EAAE;CAElC,MAAM,eAAe,MAAc,iBAAiB,KAAK,KAAK;AAG9D,KAFyB,QAAQ,OAAO,MAAc,MAAM,gBAAgB,YAAY,EAAE,CAAC,EAErE;EACpB,MAAM,aAAa,IAAI,aAAa,CAAC,OAAO,QAAQ;AAEpD,MAAI,eAAe,WAAW,CAAE,OAAM,IAAI,MAAM,iDAAiD;AAEjG,MAAI,YAAY,KAAK,WAAW,CAAE,OAAM,IAAI,MAAM,oCAAoC;AAEtF,QAAM,IAAI,MAAM,oFAAoF;;;AAIxG,MAAM,cAAc,IAAI,aAAa,CAAC,OAAO,UAAU;AACvD,MAAM,mBAAmB,IAAI,aAAa,CAAC,OAAO,cAAc;AAChE,MAAM,2BAA2B,IAAI,aAAa,CAAC,OAAO,WAAW;AAQrE,IAAa,kBAAb,MAA6B;CAC3B;CACA;CACA;CACA;CACA;CAEA,YAAY,SAAqB,aAAwC;AACvE,MAAI,gBAAgB,CAAC,MAAM,QAAQ,YAAY,IAAI,CAAC,YAAY,OAAO,QAAQ,IAAI,gBAAgB,WAAW,EAC5G,OAAM,IAAI,UAAU,oBAAoB;EAG1C,IAAIA,OAAqB,EAAE;AAC3B,MAAI,eAAe,KAAM,QAAO,YAAY,KAAK,QAAQ,IAAI,WAAW,IAAI,CAAC;AAE7E,qBAAmB,QAAQ;AAE3B,OAAK,QAAQ;AACb,OAAK,OAAO;;CAGd,IAAI,SAA4B;AAC9B,SAAO,OAAO,MAAqB,YAAsB;GACvD,MAAMC,aAA2B,EAAE;AACnC,QAAK,MAAM,SAAS,SAAS;IAG3B,MAAMC,OAA0B;KAC9B,KAHU,KAAK;KAIf,MAAM;MAAE,OAAO,KAAK;MAAO,MAAM,KAAK;MAAM,MAAM,KAAK;MAAM,OAAO,KAAK;MAAO,KAAK,KAAK;MAAK;KAChG;AAED,eAAW,KAAK,wBAAwB,KAAK,CAAC;;AAGhD,UAAO;;;CAIX,IAAI,OAAgB;AAClB,SAAO,KAAK,SAAS;;;;;;CAOvB,UAAmB;AAGjB,SAAO,IAAI,QADD,KADS,aAAa,aAAa,KAAK,MAAM,CAC9B,CACL;;CAGvB,MAAM,SAAS,QAA6B;AAC1C,OAAK,MAAM,MAAM,OAAO,KAAK;;CAG/B,MAAM,iBAAiB,MAAuB;AAC5C,MAAI,KAAK,SAAS,OAChB,MAAK,QAAQ;GACX,SAAS,EAAE;GACX,SAAS,KAAK,OAAO;GACrB,WAAW,KAAK,OAAO;GACxB;AAEH,OAAK,MAAM,kBAAkB,KAAK,YAAY;GAC5C,MAAM,EAAE,YAAY,SAAS;GAC7B,MAAM,YAAY,MAAM,WAAW,MAAM,KAAK;AAE9C,QAAK,MAAM,QAAQ,KAAK;IAAE,WAAW,KAAK;IAAW,KAAK;IAAW,CAAC;;;CAI1E,yBAAyB,MAAoC;AAC3D,MAAI,KACF,QAAO,aAAa,kBAAkB,KAAK,KAAK,WAAW,KAAK,MAAM;MAEtE,QAAO,aAAa,aAAa,KAAK,MAAM;;CAIhD,gBAAgB,MAAkB,QAAgD;AAChF,SAAO,OAAO,MAAM,KAAK;;CAG3B,kBAAkB,MAA8B;AAC9C,SAAO,aAAa,0BAA0B,KAAK,SAAS,CAAC,WAAW,KAAK;;;;;;;;;AAUjF,SAAgB,qBAAqB,uBAAmD;CACtF,MAAM,cAAc,cAAc,sBAAsB;AACxD,QAAO,oBAAoB,OAAO,aAAa,UAAU"}
+{"version":3,"file":"logicsig.mjs","names":[],"sources":["../../../../packages/transact/src/logicsig.ts"],"sourcesContent":["import { Address, Addressable, concatArrays, decodeMsgpack } from '@algorandfoundation/algokit-common'\nimport { hash } from '@algorandfoundation/algokit-crypto'\nimport { MultisigAccount } from './multisig'\nimport { AddressWithDelegatedLsigSigner, TransactionSigner } from './signer'\nimport {\n  LogicSigSignature,\n  MultisigSignature,\n  SignedTransaction,\n  encodeSignedTransaction,\n  validateSignedTransaction,\n} from './transactions/signed-transaction'\nimport { logicSigSignatureCodec } from './transactions/signed-transaction-meta'\nimport { Transaction } from './transactions/transaction'\n\nconst PROGRAM_TAG = new TextEncoder().encode('Program')\nconst MSIG_PROGRAM_TAG = new TextEncoder().encode('MsigProgram')\nconst SIGN_PROGRAM_DATA_PREFIX = new TextEncoder().encode('ProgData')\n\n/** Function for signing logic signatures for delegation\n *  @param lsig - The logic signature that is being signed for delegation\n *  @param msig - Optional multisig account that should be set when a public key is signing as a subsigner of a multisig\n *  @returns The address of the delegator\n * */\nexport type DelegatedLsigSigner = (\n  lsig: LogicSigAccount,\n  msig?: MultisigAccount,\n) => Promise<{ addr: Address } & ({ sig?: Uint8Array } | { lmsig?: MultisigSignature })>\n\n/** Function for signing program data for a logic signature */\nexport type ProgramDataSigner = (data: Uint8Array, lsig: LogicSig) => Promise<Uint8Array>\n\nexport class LogicSig implements Addressable {\n  logic: Uint8Array\n  args: Uint8Array[]\n  protected _addr: Address\n\n  constructor(program: Uint8Array, programArgs?: Array<Uint8Array>) {\n    this.logic = program\n    this.args = programArgs ?? []\n    const toBeSigned = concatArrays(PROGRAM_TAG, this.logic)\n    const h = hash(toBeSigned)\n    this._addr = new Address(h)\n  }\n\n  static fromSignature(signature: LogicSigSignature): LogicSig {\n    return new LogicSig(signature.logic, signature.args || [])\n  }\n\n  static fromBytes(encodedLsig: Uint8Array): LogicSig {\n    const decoded = decodeMsgpack(encodedLsig)\n    const lsigSignature = logicSigSignatureCodec.decode(decoded, 'msgpack')\n    return LogicSig.fromSignature(lsigSignature)\n  }\n\n  address(): Address {\n    return this._addr\n  }\n\n  get addr(): Address {\n    return this._addr\n  }\n\n  bytesToSignForDelegation(msig?: MultisigAccount): Uint8Array {\n    if (msig) {\n      return concatArrays(MSIG_PROGRAM_TAG, msig.addr.publicKey, this.logic)\n    } else {\n      return concatArrays(PROGRAM_TAG, this.logic)\n    }\n  }\n\n  signProgramData(data: Uint8Array, signer: ProgramDataSigner): Promise<Uint8Array> {\n    return signer(data, this)\n  }\n\n  programDataToSign(data: Uint8Array): Uint8Array {\n    return concatArrays(SIGN_PROGRAM_DATA_PREFIX, this.address().publicKey, data)\n  }\n\n  account(): LogicSigAccount {\n    return new LogicSigAccount(this.logic, this.args)\n  }\n\n  delegatedAccount(delegator: Address): LogicSigAccount {\n    return new LogicSigAccount(this.logic, this.args, delegator)\n  }\n}\n\nexport class LogicSigAccount extends LogicSig {\n  sig?: Uint8Array\n  msig?: MultisigSignature\n  lmsig?: MultisigSignature\n\n  static fromSignature(signature: LogicSigSignature, delegator?: Address): LogicSigAccount {\n    if (signature.lmsig || signature.msig) {\n      const msigAddr = MultisigAccount.fromSignature((signature.lmsig || signature.msig)!).addr\n\n      if (delegator && !msigAddr.equals(delegator)) {\n        throw new Error('Provided delegator address does not match multisig address')\n      }\n\n      const lsig = new LogicSigAccount(signature.logic, signature.args || [], msigAddr)\n      lsig.lmsig = signature.lmsig\n      lsig.msig = signature.msig\n      return lsig\n    }\n\n    const lsigAccount = new LogicSigAccount(signature.logic, signature.args || [], delegator)\n\n    if (signature.sig && delegator === undefined) {\n      throw new Error('Delegated address must be provided when logic sig has a signature')\n    }\n\n    if (signature.sig) {\n      lsigAccount.sig = signature.sig\n      return lsigAccount\n    }\n\n    return lsigAccount\n  }\n\n  static fromBytes(encodedLsig: Uint8Array, delegator?: Address): LogicSigAccount {\n    const decoded = decodeMsgpack(encodedLsig)\n    const lsigSignature = logicSigSignatureCodec.decode(decoded, 'msgpack')\n    return LogicSigAccount.fromSignature(lsigSignature, delegator)\n  }\n\n  constructor(program: Uint8Array, programArgs?: Array<Uint8Array> | null, delegator?: Address) {\n    super(program, programArgs ?? undefined)\n    this._addr = delegator ?? this._addr\n  }\n\n  get signer(): TransactionSigner {\n    return async (txns: Transaction[], indexes: number[]) => {\n      const signedTxns: Uint8Array[] = []\n      for (const index of indexes) {\n        const txn = txns[index]\n\n        const stxn: SignedTransaction = {\n          txn,\n          lsig: { logic: this.logic, args: this.args, msig: this.msig, lmsig: this.lmsig, sig: this.sig },\n        }\n\n        if (!stxn.txn.sender.equals(this.addr)) {\n          stxn.authAddress = this.addr\n        }\n\n        validateSignedTransaction(stxn)\n        signedTxns.push(encodeSignedTransaction(stxn))\n      }\n\n      return signedTxns\n    }\n  }\n\n  async signForDelegation(delegator: AddressWithDelegatedLsigSigner) {\n    const result = await delegator.lsigSigner(this)\n\n    if (!result.addr.equals(this._addr)) {\n      throw new Error(\n        `Delegator address from signer does not match expected delegator address. Expected: ${this._addr.toString()}, got: ${result.addr.toString()}`,\n      )\n    }\n\n    if ('sig' in result && result.sig) {\n      this.sig = result.sig\n    } else if ('lmsig' in result && result.lmsig) {\n      this.lmsig = result.lmsig\n    } else {\n      throw new Error('Delegated lsig signer must return either a sig or lmsig')\n    }\n  }\n}\n"],"mappings":"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"}

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