@algorandfoundation/algokit-utils 10.0.0-alpha.3 → 10.0.0-alpha.32

package/packages/kmd_client/src/core/api-error.mjs

@@ -4,7 +4,9 @@ var ApiError = class extends Error {
 	status;
 	body;
 	constructor(url, status, body) {
-		super(`Request to ${url} failed with status ${status}`);
+		let message = `Request to ${url} failed with status ${status}`;
+		if (body && typeof body === "object" && "message" in body && body.message) message += `: ${body.message}`;
+		super(message);
 		this.url = url;
 		this.status = status;
 		this.body = body;

package/packages/kmd_client/src/core/api-error.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"api-error.mjs","names":[],"sources":["../../../../../packages/kmd_client/src/core/api-error.ts"],"sourcesContent":["export class ApiError<T = unknown> extends Error {\n  public readonly url: string\n  public readonly status: number\n  public readonly body: T | undefined\n\n  constructor(url: string, status: number, body?: T) {\n    super(`Request to ${url} failed with status ${status}`)\n    this.url = url\n    this.status = status\n    this.body = body\n  }\n}\n"],"mappings":";AAAA,IAAa,WAAb,cAA2C,MAAM;CAC/C,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAEhB,YAAY,KAAa,QAAgB,MAAU;AACjD,QAAM,cAAc,IAAI,sBAAsB,SAAS;AACvD,OAAK,MAAM;AACX,OAAK,SAAS;AACd,OAAK,OAAO"}
+{"version":3,"file":"api-error.mjs","names":[],"sources":["../../../../../packages/kmd_client/src/core/api-error.ts"],"sourcesContent":["export class ApiError<T = unknown> extends Error {\n  public readonly url: string\n  public readonly status: number\n  public readonly body: T | undefined\n\n  constructor(url: string, status: number, body?: T) {\n    let message = `Request to ${url} failed with status ${status}`\n    if (body && typeof body === 'object' && 'message' in body && body.message) {\n      message += `: ${body.message}`\n    }\n\n    super(message)\n    this.url = url\n    this.status = status\n    this.body = body\n  }\n}\n"],"mappings":";AAAA,IAAa,WAAb,cAA2C,MAAM;CAC/C,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAEhB,YAAY,KAAa,QAAgB,MAAU;EACjD,IAAI,UAAU,cAAc,IAAI,sBAAsB;AACtD,MAAI,QAAQ,OAAO,SAAS,YAAY,aAAa,QAAQ,KAAK,QAChE,YAAW,KAAK,KAAK;AAGvB,QAAM,QAAQ;AACd,OAAK,MAAM;AACX,OAAK,SAAS;AACd,OAAK,OAAO"}

package/packages/kmd_client/src/core/model-runtime.js

@@ -1,25 +1,15 @@
 const require_object_model = require('../../../common/src/codecs/models/object-model.js');
 const require_json = require('../../../common/src/json.js');
-const require_msgpack = require('../../../common/src/msgpack.js');
 
 //#region packages/kmd_client/src/core/model-runtime.ts
-function encodeJson(value, meta) {
-	return require_json.stringifyJson(new require_object_model.ObjectModelCodec(meta).encode(value, "json"));
-}
-function encodeMsgpack$1(value, meta) {
-	return require_msgpack.encodeMsgpack(new require_object_model.ObjectModelCodec(meta).encode(value, "msgpack"));
+function encodeJson(value, meta, space) {
+	return require_json.stringifyJson(new require_object_model.ObjectModelCodec(meta).encode(value, "json"), void 0, space);
 }
 function decodeJson(value, meta) {
 	return new require_object_model.ObjectModelCodec(meta).decode(value, "json");
 }
-function decodeMsgpack$1(value, meta) {
-	const wire = require_msgpack.decodeMsgpack(value);
-	return new require_object_model.ObjectModelCodec(meta).decode(wire, "msgpack");
-}
 
 //#endregion
 exports.decodeJson = decodeJson;
-exports.decodeMsgpack = decodeMsgpack$1;
 exports.encodeJson = encodeJson;
-exports.encodeMsgpack = encodeMsgpack$1;
 //# sourceMappingURL=model-runtime.js.map

package/packages/kmd_client/src/core/model-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"model-runtime.js","names":["stringifyJson","ObjectModelCodec","encodeMsgpack","rawEncodeMsgpack","decodeMsgpack","rawDecodeMsgpack"],"sources":["../../../../../packages/kmd_client/src/core/model-runtime.ts"],"sourcesContent":["import {\n  ObjectModelCodec,\n  decodeMsgpack as rawDecodeMsgpack,\n  encodeMsgpack as rawEncodeMsgpack,\n  stringifyJson,\n  type ObjectModelMetadata,\n} from '@algorandfoundation/algokit-common'\n\nexport function encodeJson<T extends Record<string, unknown>>(value: T, meta: ObjectModelMetadata<T>): string {\n  const wire = new ObjectModelCodec(meta).encode(value, 'json')\n  return stringifyJson(wire)\n}\nexport function encodeMsgpack<T extends Record<string, unknown>>(value: T, meta: ObjectModelMetadata<T>): Uint8Array {\n  const wire = new ObjectModelCodec(meta).encode(value, 'msgpack')\n  return rawEncodeMsgpack(wire)\n}\nexport function decodeJson<T extends Record<string, unknown>>(value: Record<string, unknown>, meta: ObjectModelMetadata<T>): T {\n  return new ObjectModelCodec<T>(meta).decode(value, 'json')\n}\nexport function decodeMsgpack<T extends Record<string, unknown>>(value: Uint8Array, meta: ObjectModelMetadata<T>): T {\n  const wire = rawDecodeMsgpack(value)\n  return new ObjectModelCodec<T>(meta).decode(wire, 'msgpack')\n}\n"],"mappings":";;;;;AAQA,SAAgB,WAA8C,OAAU,MAAsC;AAE5G,QAAOA,2BADM,IAAIC,sCAAiB,KAAK,CAAC,OAAO,OAAO,OAAO,CACnC;;AAE5B,SAAgBC,gBAAiD,OAAU,MAA0C;AAEnH,QAAOC,8BADM,IAAIF,sCAAiB,KAAK,CAAC,OAAO,OAAO,UAAU,CACnC;;AAE/B,SAAgB,WAA8C,OAAgC,MAAiC;AAC7H,QAAO,IAAIA,sCAAoB,KAAK,CAAC,OAAO,OAAO,OAAO;;AAE5D,SAAgBG,gBAAiD,OAAmB,MAAiC;CACnH,MAAM,OAAOC,8BAAiB,MAAM;AACpC,QAAO,IAAIJ,sCAAoB,KAAK,CAAC,OAAO,MAAM,UAAU"}
+{"version":3,"file":"model-runtime.js","names":["stringifyJson","ObjectModelCodec"],"sources":["../../../../../packages/kmd_client/src/core/model-runtime.ts"],"sourcesContent":["import {\n  ObjectModelCodec,\n  decodeMsgpack as rawDecodeMsgpack,\n  encodeMsgpack as rawEncodeMsgpack,\n  stringifyJson,\n  type ObjectModelMetadata,\n} from '@algorandfoundation/algokit-common'\n\nexport function encodeJson<T extends Record<string, unknown>>(value: T, meta: ObjectModelMetadata<T>, space?: string | number): string {\n  const wire = new ObjectModelCodec(meta).encode(value, 'json')\n  return stringifyJson(wire, undefined, space)\n}\nexport function encodeMsgpack<T extends Record<string, unknown>>(value: T, meta: ObjectModelMetadata<T>): Uint8Array {\n  const wire = new ObjectModelCodec(meta).encode(value, 'msgpack')\n  return rawEncodeMsgpack(wire)\n}\nexport function decodeJson<T extends Record<string, unknown>>(value: Record<string, unknown>, meta: ObjectModelMetadata<T>): T {\n  return new ObjectModelCodec<T>(meta).decode(value, 'json')\n}\nexport function decodeMsgpack<T extends Record<string, unknown>>(value: Uint8Array, meta: ObjectModelMetadata<T>): T {\n  const wire = rawDecodeMsgpack(value)\n  return new ObjectModelCodec<T>(meta).decode(wire, 'msgpack')\n}\n"],"mappings":";;;;AAQA,SAAgB,WAA8C,OAAU,MAA8B,OAAiC;AAErI,QAAOA,2BADM,IAAIC,sCAAiB,KAAK,CAAC,OAAO,OAAO,OAAO,EAClC,QAAW,MAAM;;AAM9C,SAAgB,WAA8C,OAAgC,MAAiC;AAC7H,QAAO,IAAIA,sCAAoB,KAAK,CAAC,OAAO,OAAO,OAAO"}

package/packages/kmd_client/src/core/model-runtime.mjs

@@ -1,22 +1,14 @@
 import { ObjectModelCodec } from "../../../common/src/codecs/models/object-model.mjs";
 import { stringifyJson } from "../../../common/src/json.mjs";
-import { decodeMsgpack, encodeMsgpack } from "../../../common/src/msgpack.mjs";
 
 //#region packages/kmd_client/src/core/model-runtime.ts
-function encodeJson(value, meta) {
-	return stringifyJson(new ObjectModelCodec(meta).encode(value, "json"));
-}
-function encodeMsgpack$1(value, meta) {
-	return encodeMsgpack(new ObjectModelCodec(meta).encode(value, "msgpack"));
+function encodeJson(value, meta, space) {
+	return stringifyJson(new ObjectModelCodec(meta).encode(value, "json"), void 0, space);
 }
 function decodeJson(value, meta) {
 	return new ObjectModelCodec(meta).decode(value, "json");
 }
-function decodeMsgpack$1(value, meta) {
-	const wire = decodeMsgpack(value);
-	return new ObjectModelCodec(meta).decode(wire, "msgpack");
-}
 
 //#endregion
-export { decodeJson, decodeMsgpack$1 as decodeMsgpack, encodeJson, encodeMsgpack$1 as encodeMsgpack };
+export { decodeJson, encodeJson };
 //# sourceMappingURL=model-runtime.mjs.map

package/packages/kmd_client/src/core/model-runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"model-runtime.mjs","names":["encodeMsgpack","rawEncodeMsgpack","decodeMsgpack","rawDecodeMsgpack"],"sources":["../../../../../packages/kmd_client/src/core/model-runtime.ts"],"sourcesContent":["import {\n  ObjectModelCodec,\n  decodeMsgpack as rawDecodeMsgpack,\n  encodeMsgpack as rawEncodeMsgpack,\n  stringifyJson,\n  type ObjectModelMetadata,\n} from '@algorandfoundation/algokit-common'\n\nexport function encodeJson<T extends Record<string, unknown>>(value: T, meta: ObjectModelMetadata<T>): string {\n  const wire = new ObjectModelCodec(meta).encode(value, 'json')\n  return stringifyJson(wire)\n}\nexport function encodeMsgpack<T extends Record<string, unknown>>(value: T, meta: ObjectModelMetadata<T>): Uint8Array {\n  const wire = new ObjectModelCodec(meta).encode(value, 'msgpack')\n  return rawEncodeMsgpack(wire)\n}\nexport function decodeJson<T extends Record<string, unknown>>(value: Record<string, unknown>, meta: ObjectModelMetadata<T>): T {\n  return new ObjectModelCodec<T>(meta).decode(value, 'json')\n}\nexport function decodeMsgpack<T extends Record<string, unknown>>(value: Uint8Array, meta: ObjectModelMetadata<T>): T {\n  const wire = rawDecodeMsgpack(value)\n  return new ObjectModelCodec<T>(meta).decode(wire, 'msgpack')\n}\n"],"mappings":";;;;;AAQA,SAAgB,WAA8C,OAAU,MAAsC;AAE5G,QAAO,cADM,IAAI,iBAAiB,KAAK,CAAC,OAAO,OAAO,OAAO,CACnC;;AAE5B,SAAgBA,gBAAiD,OAAU,MAA0C;AAEnH,QAAOC,cADM,IAAI,iBAAiB,KAAK,CAAC,OAAO,OAAO,UAAU,CACnC;;AAE/B,SAAgB,WAA8C,OAAgC,MAAiC;AAC7H,QAAO,IAAI,iBAAoB,KAAK,CAAC,OAAO,OAAO,OAAO;;AAE5D,SAAgBC,gBAAiD,OAAmB,MAAiC;CACnH,MAAM,OAAOC,cAAiB,MAAM;AACpC,QAAO,IAAI,iBAAoB,KAAK,CAAC,OAAO,MAAM,UAAU"}
+{"version":3,"file":"model-runtime.mjs","names":[],"sources":["../../../../../packages/kmd_client/src/core/model-runtime.ts"],"sourcesContent":["import {\n  ObjectModelCodec,\n  decodeMsgpack as rawDecodeMsgpack,\n  encodeMsgpack as rawEncodeMsgpack,\n  stringifyJson,\n  type ObjectModelMetadata,\n} from '@algorandfoundation/algokit-common'\n\nexport function encodeJson<T extends Record<string, unknown>>(value: T, meta: ObjectModelMetadata<T>, space?: string | number): string {\n  const wire = new ObjectModelCodec(meta).encode(value, 'json')\n  return stringifyJson(wire, undefined, space)\n}\nexport function encodeMsgpack<T extends Record<string, unknown>>(value: T, meta: ObjectModelMetadata<T>): Uint8Array {\n  const wire = new ObjectModelCodec(meta).encode(value, 'msgpack')\n  return rawEncodeMsgpack(wire)\n}\nexport function decodeJson<T extends Record<string, unknown>>(value: Record<string, unknown>, meta: ObjectModelMetadata<T>): T {\n  return new ObjectModelCodec<T>(meta).decode(value, 'json')\n}\nexport function decodeMsgpack<T extends Record<string, unknown>>(value: Uint8Array, meta: ObjectModelMetadata<T>): T {\n  const wire = rawDecodeMsgpack(value)\n  return new ObjectModelCodec<T>(meta).decode(wire, 'msgpack')\n}\n"],"mappings":";;;;AAQA,SAAgB,WAA8C,OAAU,MAA8B,OAAiC;AAErI,QAAO,cADM,IAAI,iBAAiB,KAAK,CAAC,OAAO,OAAO,OAAO,EAClC,QAAW,MAAM;;AAM9C,SAAgB,WAA8C,OAAgC,MAAiC;AAC7H,QAAO,IAAI,iBAAoB,KAAK,CAAC,OAAO,OAAO,OAAO"}

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

@@ -1,47 +1,49 @@
-import { Address } from "../../common/src/address.js";
-import { LogicSignature, MultisigSignature } from "./transactions/signed-transaction.js";
+import { Address, Addressable } from "../../common/src/address.js";
+import { LogicSigSignature, MultisigSignature } from "./transactions/signed-transaction.js";
 import { MultisigAccount } from "./multisig.js";
-import { TransactionSigner } from "./signer.js";
+import { AddressWithDelegatedLsigSigner, TransactionSigner } from "./signer.js";
 
 //#region packages/transact/src/logicsig.d.ts
 
-/** 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
- */
-declare function sanityCheckProgram(program: Uint8Array): void;
-/** Function for signing logic signatures for delegation */
-type DelegatedLsigSigner = (lsig: LogicSigAccount, msig?: MultisigAccount) => Promise<Uint8Array>;
+/** Function for signing logic signatures for delegation
+ *  @param lsig - The logic signature that is being signed for delegation
+ *  @param msig - Optional multisig account that should be set when a public key is signing as a subsigner of a multisig
+ *  @returns The address of the delegator
+ * */
+type DelegatedLsigSigner = (lsig: LogicSigAccount, msig?: MultisigAccount) => Promise<{
+  addr: Address;
+} & ({
+  sig?: Uint8Array;
+} | {
+  lmsig?: MultisigSignature;
+})>;
 /** Function for signing program data for a logic signature */
-type ProgramDataSigner = (data: Uint8Array, lsig: LogicSigAccount) => Promise<Uint8Array>;
-declare class LogicSigAccount {
+type ProgramDataSigner = (data: Uint8Array, lsig: LogicSig) => Promise<Uint8Array>;
+declare class LogicSig implements Addressable {
   logic: Uint8Array;
   args: Uint8Array[];
-  sig?: Uint8Array;
-  msig?: MultisigSignature;
-  lmsig?: MultisigSignature;
-  constructor(program: Uint8Array, programArgs?: Array<Uint8Array> | null);
-  get signer(): TransactionSigner;
-  get addr(): 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
-   */
+  protected _addr: Address;
+  constructor(program: Uint8Array, programArgs?: Array<Uint8Array>);
+  static fromSignature(signature: LogicSigSignature): LogicSig;
+  static fromBytes(encodedLsig: Uint8Array): LogicSig;
   address(): Address;
-  delegate(signer: DelegatedLsigSigner): Promise<void>;
-  delegateMultisig(msig: MultisigAccount): Promise<void>;
+  get addr(): Address;
   bytesToSignForDelegation(msig?: MultisigAccount): Uint8Array;
   signProgramData(data: Uint8Array, signer: ProgramDataSigner): Promise<Uint8Array>;
   programDataToSign(data: Uint8Array): Uint8Array;
+  account(): LogicSigAccount;
+  delegatedAccount(delegator: Address): LogicSigAccount;
+}
+declare class LogicSigAccount extends LogicSig {
+  sig?: Uint8Array;
+  msig?: MultisigSignature;
+  lmsig?: MultisigSignature;
+  static fromSignature(signature: LogicSigSignature, delegator?: Address): LogicSigAccount;
+  static fromBytes(encodedLsig: Uint8Array, delegator?: Address): LogicSigAccount;
+  constructor(program: Uint8Array, programArgs?: Array<Uint8Array> | null, delegator?: Address);
+  get signer(): TransactionSigner;
+  signForDelegation(delegator: AddressWithDelegatedLsigSigner): Promise<void>;
 }
-/**
- * Decodes MsgPack bytes into a logic signature.
- *
- * @param encodedLogicSignature - The MsgPack encoded logic signature
- * @returns The decoded LogicSignature or an error if decoding fails.
- */
-declare function decodeLogicSignature(encodedLogicSignature: Uint8Array): LogicSignature;
 //#endregion
-export { DelegatedLsigSigner, LogicSigAccount, ProgramDataSigner, decodeLogicSignature, sanityCheckProgram };
+export { DelegatedLsigSigner, LogicSig, LogicSigAccount, ProgramDataSigner };
 //# sourceMappingURL=logicsig.d.ts.map

package/packages/transact/src/logicsig.js

@@ -4,43 +4,81 @@ 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_multisig = require('./multisig.js');
 
 //#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 (require_address.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 require_address.Address(require_crypto.hash(require_array.concatArrays(PROGRAM_TAG, this.logic)));
+	}
+	static fromSignature(signature) {
+		return new LogicSig(signature.logic, signature.args || []);
+	}
+	static fromBytes(encodedLsig) {
+		const decoded = require_msgpack.decodeMsgpack(encodedLsig);
+		const lsigSignature = require_signed_transaction_meta.logicSigSignatureCodec.decode(decoded, "msgpack");
+		return LogicSig.fromSignature(lsigSignature);
+	}
+	address() {
+		return this._addr;
+	}
+	get addr() {
+		return this._addr;
+	}
+	bytesToSignForDelegation(msig) {
+		if (msig) return require_array.concatArrays(MSIG_PROGRAM_TAG, msig.addr.publicKey, this.logic);
+		else return require_array.concatArrays(PROGRAM_TAG, this.logic);
+	}
+	signProgramData(data, signer) {
+		return signer(data, this);
+	}
+	programDataToSign(data) {
+		return require_array.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 = require_multisig.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 = require_msgpack.decodeMsgpack(encodedLsig);
+		const lsigSignature = require_signed_transaction_meta.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,63 +94,23 @@ var LogicSigAccount = class {
 						sig: this.sig
 					}
 				};
+				if (!stxn.txn.sender.equals(this.addr)) stxn.authAddress = this.addr;
+				require_signed_transaction.validateSignedTransaction(stxn);
 				signedTxns.push(require_signed_transaction.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 require_address.Address(require_crypto.hash(require_array.concatArrays(PROGRAM_TAG, this.logic)));
-	}
-	async delegate(signer) {
-		this.sig = await signer(this);
-	}
-	async delegateMultisig(msig) {
-		if (this.lmsig == void 0) this.lmsig = {
-			subsignatures: [],
-			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.subsignatures.push({
-				publicKey: addr.publicKey,
-				signature
-			});
-		}
-	}
-	bytesToSignForDelegation(msig) {
-		if (msig) return require_array.concatArrays(MSIG_PROGRAM_TAG, msig.addr.publicKey, this.logic);
-		else return require_array.concatArrays(PROGRAM_TAG, this.logic);
-	}
-	signProgramData(data, signer) {
-		return signer(data, this);
-	}
-	programDataToSign(data) {
-		return require_array.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 = require_msgpack.decodeMsgpack(encodedLogicSignature);
-	return require_signed_transaction_meta.logicSignatureCodec.decode(decodedData, "msgpack");
-}
 
 //#endregion
+exports.LogicSig = LogicSig;
 exports.LogicSigAccount = LogicSigAccount;
-exports.decodeLogicSignature = decodeLogicSignature;
-exports.sanityCheckProgram = sanityCheckProgram;
 //# sourceMappingURL=logicsig.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"logicsig.js","names":["isValidAddress","args: Uint8Array[]","signedTxns: Uint8Array[]","stxn: SignedTransaction","encodeSignedTransaction","Address","hash","concatArrays","decodeMsgpack","logicSignatureCodec"],"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        subsignatures: [],\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.subsignatures.push({ publicKey: addr.publicKey, 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,MAAIA,+BAAe,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,IAAIC,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,KAAKC,mDAAwB,KAAK,CAAC;;AAGhD,UAAO;;;CAIX,IAAI,OAAgB;AAClB,SAAO,KAAK,SAAS;;;;;;CAOvB,UAAmB;AAGjB,SAAO,IAAIC,wBADDC,oBADSC,2BAAa,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,eAAe,EAAE;GACjB,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,cAAc,KAAK;IAAE,WAAW,KAAK;IAAW;IAAW,CAAC;;;CAI3E,yBAAyB,MAAoC;AAC3D,MAAI,KACF,QAAOA,2BAAa,kBAAkB,KAAK,KAAK,WAAW,KAAK,MAAM;MAEtE,QAAOA,2BAAa,aAAa,KAAK,MAAM;;CAIhD,gBAAgB,MAAkB,QAAgD;AAChF,SAAO,OAAO,MAAM,KAAK;;CAG3B,kBAAkB,MAA8B;AAC9C,SAAOA,2BAAa,0BAA0B,KAAK,SAAS,CAAC,WAAW,KAAK;;;;;;;;;AAUjF,SAAgB,qBAAqB,uBAAmD;CACtF,MAAM,cAAcC,8BAAc,sBAAsB;AACxD,QAAOC,oDAAoB,OAAO,aAAa,UAAU"}
+{"version":3,"file":"logicsig.js","names":["Address","hash","concatArrays","decodeMsgpack","logicSigSignatureCodec","MultisigAccount","signedTxns: Uint8Array[]","stxn: SignedTransaction","encodeSignedTransaction"],"sources":["../../../../packages/transact/src/logicsig.ts"],"sourcesContent":["import { Address, Addressable, concatArrays, decodeMsgpack, hash } from '@algorandfoundation/algokit-common'\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/logicsig.mjs

@@ -1,46 +1,84 @@
 import { concatArrays } from "../../common/src/array.mjs";
-import { Address, isValidAddress } from "../../common/src/address.mjs";
+import { Address } from "../../common/src/address.mjs";
 import { hash } from "../../common/src/crypto.mjs";
 import { decodeMsgpack } from "../../common/src/msgpack.mjs";
-import { logicSignatureCodec } from "./transactions/signed-transaction-meta.mjs";
-import { encodeSignedTransaction } from "./transactions/signed-transaction.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 +94,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 = {
-			subsignatures: [],
-			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.subsignatures.push({
-				publicKey: addr.publicKey,
-				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