@algorandfoundation/algokit-utils 10.0.0-alpha.4 → 10.0.0-alpha.41

package/packages/testing/src/globalSetup.mjs

@@ -0,0 +1,36 @@
+import { getMockServer } from "./mockServer.mjs";
+import { config } from "dotenv";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region packages/testing/src/globalSetup.ts
+/**
+* Vitest global setup factory for mock server lifecycle.
+* Set MOCK_ALGOD_URL / MOCK_INDEXER_URL / MOCK_KMD_URL to use an external server.
+*/
+config({ path: resolve(resolve(resolve(fileURLToPath(import.meta.url), ".."), "..", "..", ".."), ".env") });
+const log = process.env.DEBUG_MOCK_SERVER === "true" ? console.log.bind(console) : () => {};
+function createGlobalSetup(clientType) {
+	let mockServer = null;
+	return async function setup() {
+		log(`[MockServer] Connecting to ${clientType} mock server...`);
+		try {
+			mockServer = await getMockServer(clientType);
+			log(`[MockServer] ${clientType} server ready at ${mockServer.baseUrl}`);
+			return async () => {
+				log(`[MockServer] Disconnecting from ${clientType} mock server...`);
+				log(`[MockServer] ${clientType} server disconnected`);
+			};
+		} catch (error) {
+			console.error(`[MockServer] Failed to connect to ${clientType} server:`, error);
+			throw error;
+		}
+	};
+}
+const algodGlobalSetup = createGlobalSetup("algod");
+const indexerGlobalSetup = createGlobalSetup("indexer");
+const kmdGlobalSetup = createGlobalSetup("kmd");
+
+//#endregion
+export { algodGlobalSetup, createGlobalSetup, indexerGlobalSetup, kmdGlobalSetup };
+//# sourceMappingURL=globalSetup.mjs.map

package/packages/testing/src/globalSetup.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalSetup.mjs","names":[],"sources":["../../../../packages/testing/src/globalSetup.ts"],"sourcesContent":["/**\n * Vitest global setup factory for mock server lifecycle.\n * Set MOCK_ALGOD_URL / MOCK_INDEXER_URL / MOCK_KMD_URL to use an external server.\n */\n\nimport { config } from 'dotenv'\nimport { resolve } from 'node:path'\nimport { fileURLToPath } from 'node:url'\nimport { getMockServer, type ClientType, type MockServer } from './mockServer'\n\nconst currentDir = resolve(fileURLToPath(import.meta.url), '..')\nconst projectRoot = resolve(currentDir, '..', '..', '..')\nconfig({ path: resolve(projectRoot, '.env') })\n\nconst debug = process.env.DEBUG_MOCK_SERVER === 'true'\nconst log = debug ? console.log.bind(console) : () => {}\n\nexport function createGlobalSetup(clientType: ClientType) {\n  let mockServer: MockServer | null = null\n\n  return async function setup(): Promise<() => Promise<void>> {\n    log(`[MockServer] Connecting to ${clientType} mock server...`)\n\n    try {\n      mockServer = await getMockServer(clientType)\n      log(`[MockServer] ${clientType} server ready at ${mockServer.baseUrl}`)\n\n      return async () => {\n        log(`[MockServer] Disconnecting from ${clientType} mock server...`)\n        log(`[MockServer] ${clientType} server disconnected`)\n      }\n    } catch (error) {\n      console.error(`[MockServer] Failed to connect to ${clientType} server:`, error)\n      throw error\n    }\n  }\n}\n\nexport const algodGlobalSetup = createGlobalSetup('algod')\nexport const indexerGlobalSetup = createGlobalSetup('indexer')\nexport const kmdGlobalSetup = createGlobalSetup('kmd')\n"],"mappings":";;;;;;;;;;AAYA,OAAO,EAAE,MAAM,QADK,QADD,QAAQ,cAAc,OAAO,KAAK,IAAI,EAAE,KAAK,EACxB,MAAM,MAAM,KAAK,EACrB,OAAO,EAAE,CAAC;AAG9C,MAAM,MADQ,QAAQ,IAAI,sBAAsB,SAC5B,QAAQ,IAAI,KAAK,QAAQ,SAAS;AAEtD,SAAgB,kBAAkB,YAAwB;CACxD,IAAI,aAAgC;AAEpC,QAAO,eAAe,QAAsC;AAC1D,MAAI,8BAA8B,WAAW,iBAAiB;AAE9D,MAAI;AACF,gBAAa,MAAM,cAAc,WAAW;AAC5C,OAAI,gBAAgB,WAAW,mBAAmB,WAAW,UAAU;AAEvE,UAAO,YAAY;AACjB,QAAI,mCAAmC,WAAW,iBAAiB;AACnE,QAAI,gBAAgB,WAAW,sBAAsB;;WAEhD,OAAO;AACd,WAAQ,MAAM,qCAAqC,WAAW,WAAW,MAAM;AAC/E,SAAM;;;;AAKZ,MAAa,mBAAmB,kBAAkB,QAAQ;AAC1D,MAAa,qBAAqB,kBAAkB,UAAU;AAC9D,MAAa,iBAAiB,kBAAkB,MAAM"}

package/packages/testing/src/mockServer.js

@@ -0,0 +1,95 @@
+
+//#region packages/testing/src/mockServer.ts
+/** Environment variable names for external mock server URLs */
+const EXTERNAL_URL_ENV_VARS = {
+	algod: "MOCK_ALGOD_URL",
+	indexer: "MOCK_INDEXER_URL",
+	kmd: "MOCK_KMD_URL"
+};
+/** Default token used for mock server authentication */
+const DEFAULT_TOKEN = "a".repeat(64);
+/** Default ports for mock servers when running locally (matches algokit-polytest defaults) */
+const MOCK_PORTS = {
+	algod: { host: 8e3 },
+	indexer: { host: 8002 },
+	kmd: { host: 8001 }
+};
+/**
+* Check if a server is reachable by performing a health check.
+*
+* @param url - The base URL of the server to check
+* @param timeout - Maximum time to wait for the server to respond (default: 5000ms)
+* @returns Promise resolving to true if server is healthy, false otherwise
+*/
+async function checkServerHealth(url, timeout = 5e3) {
+	const healthUrl = `${url.replace(/\/$/, "")}/health`;
+	const start = Date.now();
+	while (Date.now() - start < timeout) try {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 2e3);
+		try {
+			await fetch(healthUrl, { signal: controller.signal });
+			clearTimeout(timeoutId);
+			return true;
+		} catch (error) {
+			clearTimeout(timeoutId);
+			if (error instanceof Error && error.name === "AbortError") {
+				await new Promise((resolve) => setTimeout(resolve, 200));
+				continue;
+			}
+			throw error;
+		}
+	} catch {
+		await new Promise((resolve) => setTimeout(resolve, 200));
+	}
+	return false;
+}
+/**
+* Get a mock server instance for the specified client type.
+*
+* Reads the appropriate environment variable (MOCK_ALGOD_URL, MOCK_INDEXER_URL, or MOCK_KMD_URL)
+* and validates that the server is reachable before returning a MockServer instance.
+*
+* @param clientType - The type of client to get a mock server for ('algod', 'indexer', or 'kmd')
+* @returns Promise resolving to a MockServer instance
+* @throws Error if the environment variable is not set or the server is not reachable
+*
+* @example
+* ```typescript
+* const server = await getMockServer('algod')
+* const client = new AlgodClient(DEFAULT_TOKEN, server.baseUrl)
+* // ... run tests ...
+* ```
+*/
+async function getMockServer(clientType) {
+	const envVar = EXTERNAL_URL_ENV_VARS[clientType];
+	const externalUrl = process.env[envVar];
+	if (!externalUrl) throw new Error(`Environment variable ${envVar} is not set. Please start the mock server externally and set the URL. See the "Mock Server for Client Tests" section in README.md for local development setup.`);
+	if (!await checkServerHealth(externalUrl)) throw new Error(`Mock ${clientType} server at ${externalUrl} is not reachable. Please ensure the server is running and accessible.`);
+	return {
+		baseUrl: externalUrl.replace(/\/$/, ""),
+		clientType
+	};
+}
+const TEST_ADDRESS = "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE";
+const TEST_APP_ID = 718348254;
+const TEST_APP_ID_WITH_BOXES = 742949200;
+const TEST_BOX_NAME = "b64:cBbHBNV+zUy/Mz5IRhIrBLxr1on5wmidhXEavV+SasC8";
+const TEST_ASSET_ID = 705457144;
+const TEST_TXID = "VIXTUMAPT7NR4RB2WVOGMETW4QY43KIDA3HWDWWXS3UEDKGTEECQ";
+const TEST_ROUND = 24099447;
+
+//#endregion
+exports.DEFAULT_TOKEN = DEFAULT_TOKEN;
+exports.EXTERNAL_URL_ENV_VARS = EXTERNAL_URL_ENV_VARS;
+exports.MOCK_PORTS = MOCK_PORTS;
+exports.TEST_ADDRESS = TEST_ADDRESS;
+exports.TEST_APP_ID = TEST_APP_ID;
+exports.TEST_APP_ID_WITH_BOXES = TEST_APP_ID_WITH_BOXES;
+exports.TEST_ASSET_ID = TEST_ASSET_ID;
+exports.TEST_BOX_NAME = TEST_BOX_NAME;
+exports.TEST_ROUND = TEST_ROUND;
+exports.TEST_TXID = TEST_TXID;
+exports.checkServerHealth = checkServerHealth;
+exports.getMockServer = getMockServer;
+//# sourceMappingURL=mockServer.js.map

package/packages/testing/src/mockServer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockServer.js","names":[],"sources":["../../../../packages/testing/src/mockServer.ts"],"sourcesContent":["/**\n * Mock server infrastructure for algod/indexer/kmd client testing.\n *\n * Connects to externally managed mock servers that replay pre-recorded HAR files.\n * The mock server must be started separately (via GitHub Action in CI, or manually via bun for local dev).\n *\n * Set MOCK_ALGOD_URL / MOCK_INDEXER_URL / MOCK_KMD_URL environment variables to specify server URLs.\n */\n\n/** Supported client types for mock servers */\nexport type ClientType = 'algod' | 'indexer' | 'kmd'\n\n/** Environment variable names for external mock server URLs */\nexport const EXTERNAL_URL_ENV_VARS: Record<ClientType, string> = {\n  algod: 'MOCK_ALGOD_URL',\n  indexer: 'MOCK_INDEXER_URL',\n  kmd: 'MOCK_KMD_URL',\n}\n\n/** Default token used for mock server authentication */\nexport const DEFAULT_TOKEN = 'a'.repeat(64)\n\n/** Default ports for mock servers when running locally (matches algokit-polytest defaults) */\nexport const MOCK_PORTS = {\n  algod: { host: 8000 },\n  indexer: { host: 8002 },\n  kmd: { host: 8001 },\n} as const\n\n/** Mock server instance representing a connection to an external server */\nexport interface MockServer {\n  /** Base URL of the mock server */\n  baseUrl: string\n  /** Type of client this server mocks */\n  clientType: ClientType\n}\n\n/**\n * Check if a server is reachable by performing a health check.\n *\n * @param url - The base URL of the server to check\n * @param timeout - Maximum time to wait for the server to respond (default: 5000ms)\n * @returns Promise resolving to true if server is healthy, false otherwise\n */\nexport async function checkServerHealth(url: string, timeout = 5000): Promise<boolean> {\n  const healthUrl = `${url.replace(/\\/$/, '')}/health`\n  const start = Date.now()\n\n  while (Date.now() - start < timeout) {\n    try {\n      const controller = new AbortController()\n      const timeoutId = setTimeout(() => controller.abort(), 2000)\n      try {\n        await fetch(healthUrl, { signal: controller.signal })\n        clearTimeout(timeoutId)\n        // Any HTTP response (including 500) indicates the server is reachable\n        // The mock server returns 500 for unrecorded endpoints like /health\n        return true\n      } catch (error) {\n        clearTimeout(timeoutId)\n        // If it's a network error, retry\n        if (error instanceof Error && error.name === 'AbortError') {\n          await new Promise((resolve) => setTimeout(resolve, 200))\n          continue\n        }\n        throw error\n      }\n    } catch {\n      await new Promise((resolve) => setTimeout(resolve, 200))\n    }\n  }\n  return false\n}\n\n/**\n * Get a mock server instance for the specified client type.\n *\n * Reads the appropriate environment variable (MOCK_ALGOD_URL, MOCK_INDEXER_URL, or MOCK_KMD_URL)\n * and validates that the server is reachable before returning a MockServer instance.\n *\n * @param clientType - The type of client to get a mock server for ('algod', 'indexer', or 'kmd')\n * @returns Promise resolving to a MockServer instance\n * @throws Error if the environment variable is not set or the server is not reachable\n *\n * @example\n * ```typescript\n * const server = await getMockServer('algod')\n * const client = new AlgodClient(DEFAULT_TOKEN, server.baseUrl)\n * // ... run tests ...\n * ```\n */\nexport async function getMockServer(clientType: ClientType): Promise<MockServer> {\n  const envVar = EXTERNAL_URL_ENV_VARS[clientType]\n  const externalUrl = process.env[envVar]\n\n  if (!externalUrl) {\n    throw new Error(\n      `Environment variable ${envVar} is not set. ` +\n        `Please start the mock server externally and set the URL. ` +\n        `See the \"Mock Server for Client Tests\" section in README.md for local development setup.`,\n    )\n  }\n\n  const isHealthy = await checkServerHealth(externalUrl)\n  if (!isHealthy) {\n    throw new Error(\n      `Mock ${clientType} server at ${externalUrl} is not reachable. ` + `Please ensure the server is running and accessible.`,\n    )\n  }\n\n  return {\n    baseUrl: externalUrl.replace(/\\/$/, ''),\n    clientType,\n  }\n}\n\n// Test data constants matching mock server recordings\nexport const TEST_ADDRESS = '25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE'\nexport const TEST_APP_ID = 718348254\nexport const TEST_APP_ID_WITH_BOXES = 742949200\nexport const TEST_BOX_NAME = 'b64:cBbHBNV+zUy/Mz5IRhIrBLxr1on5wmidhXEavV+SasC8'\nexport const TEST_ASSET_ID = 705457144\nexport const TEST_TXID = 'VIXTUMAPT7NR4RB2WVOGMETW4QY43KIDA3HWDWWXS3UEDKGTEECQ'\nexport const TEST_ROUND = 24099447\n"],"mappings":";;;AAaA,MAAa,wBAAoD;CAC/D,OAAO;CACP,SAAS;CACT,KAAK;CACN;;AAGD,MAAa,gBAAgB,IAAI,OAAO,GAAG;;AAG3C,MAAa,aAAa;CACxB,OAAO,EAAE,MAAM,KAAM;CACrB,SAAS,EAAE,MAAM,MAAM;CACvB,KAAK,EAAE,MAAM,MAAM;CACpB;;;;;;;;AAiBD,eAAsB,kBAAkB,KAAa,UAAU,KAAwB;CACrF,MAAM,YAAY,GAAG,IAAI,QAAQ,OAAO,GAAG,CAAC;CAC5C,MAAM,QAAQ,KAAK,KAAK;AAExB,QAAO,KAAK,KAAK,GAAG,QAAQ,QAC1B,KAAI;EACF,MAAM,aAAa,IAAI,iBAAiB;EACxC,MAAM,YAAY,iBAAiB,WAAW,OAAO,EAAE,IAAK;AAC5D,MAAI;AACF,SAAM,MAAM,WAAW,EAAE,QAAQ,WAAW,QAAQ,CAAC;AACrD,gBAAa,UAAU;AAGvB,UAAO;WACA,OAAO;AACd,gBAAa,UAAU;AAEvB,OAAI,iBAAiB,SAAS,MAAM,SAAS,cAAc;AACzD,UAAM,IAAI,SAAS,YAAY,WAAW,SAAS,IAAI,CAAC;AACxD;;AAEF,SAAM;;SAEF;AACN,QAAM,IAAI,SAAS,YAAY,WAAW,SAAS,IAAI,CAAC;;AAG5D,QAAO;;;;;;;;;;;;;;;;;;;AAoBT,eAAsB,cAAc,YAA6C;CAC/E,MAAM,SAAS,sBAAsB;CACrC,MAAM,cAAc,QAAQ,IAAI;AAEhC,KAAI,CAAC,YACH,OAAM,IAAI,MACR,wBAAwB,OAAO,gKAGhC;AAIH,KAAI,CADc,MAAM,kBAAkB,YAAY,CAEpD,OAAM,IAAI,MACR,QAAQ,WAAW,aAAa,YAAY,wEAC7C;AAGH,QAAO;EACL,SAAS,YAAY,QAAQ,OAAO,GAAG;EACvC;EACD;;AAIH,MAAa,eAAe;AAC5B,MAAa,cAAc;AAC3B,MAAa,yBAAyB;AACtC,MAAa,gBAAgB;AAC7B,MAAa,gBAAgB;AAC7B,MAAa,YAAY;AACzB,MAAa,aAAa"}

package/packages/testing/src/mockServer.mjs

@@ -0,0 +1,83 @@
+//#region packages/testing/src/mockServer.ts
+/** Environment variable names for external mock server URLs */
+const EXTERNAL_URL_ENV_VARS = {
+	algod: "MOCK_ALGOD_URL",
+	indexer: "MOCK_INDEXER_URL",
+	kmd: "MOCK_KMD_URL"
+};
+/** Default token used for mock server authentication */
+const DEFAULT_TOKEN = "a".repeat(64);
+/** Default ports for mock servers when running locally (matches algokit-polytest defaults) */
+const MOCK_PORTS = {
+	algod: { host: 8e3 },
+	indexer: { host: 8002 },
+	kmd: { host: 8001 }
+};
+/**
+* Check if a server is reachable by performing a health check.
+*
+* @param url - The base URL of the server to check
+* @param timeout - Maximum time to wait for the server to respond (default: 5000ms)
+* @returns Promise resolving to true if server is healthy, false otherwise
+*/
+async function checkServerHealth(url, timeout = 5e3) {
+	const healthUrl = `${url.replace(/\/$/, "")}/health`;
+	const start = Date.now();
+	while (Date.now() - start < timeout) try {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 2e3);
+		try {
+			await fetch(healthUrl, { signal: controller.signal });
+			clearTimeout(timeoutId);
+			return true;
+		} catch (error) {
+			clearTimeout(timeoutId);
+			if (error instanceof Error && error.name === "AbortError") {
+				await new Promise((resolve) => setTimeout(resolve, 200));
+				continue;
+			}
+			throw error;
+		}
+	} catch {
+		await new Promise((resolve) => setTimeout(resolve, 200));
+	}
+	return false;
+}
+/**
+* Get a mock server instance for the specified client type.
+*
+* Reads the appropriate environment variable (MOCK_ALGOD_URL, MOCK_INDEXER_URL, or MOCK_KMD_URL)
+* and validates that the server is reachable before returning a MockServer instance.
+*
+* @param clientType - The type of client to get a mock server for ('algod', 'indexer', or 'kmd')
+* @returns Promise resolving to a MockServer instance
+* @throws Error if the environment variable is not set or the server is not reachable
+*
+* @example
+* ```typescript
+* const server = await getMockServer('algod')
+* const client = new AlgodClient(DEFAULT_TOKEN, server.baseUrl)
+* // ... run tests ...
+* ```
+*/
+async function getMockServer(clientType) {
+	const envVar = EXTERNAL_URL_ENV_VARS[clientType];
+	const externalUrl = process.env[envVar];
+	if (!externalUrl) throw new Error(`Environment variable ${envVar} is not set. Please start the mock server externally and set the URL. See the "Mock Server for Client Tests" section in README.md for local development setup.`);
+	if (!await checkServerHealth(externalUrl)) throw new Error(`Mock ${clientType} server at ${externalUrl} is not reachable. Please ensure the server is running and accessible.`);
+	return {
+		baseUrl: externalUrl.replace(/\/$/, ""),
+		clientType
+	};
+}
+const TEST_ADDRESS = "25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE";
+const TEST_APP_ID = 718348254;
+const TEST_APP_ID_WITH_BOXES = 742949200;
+const TEST_BOX_NAME = "b64:cBbHBNV+zUy/Mz5IRhIrBLxr1on5wmidhXEavV+SasC8";
+const TEST_ASSET_ID = 705457144;
+const TEST_TXID = "VIXTUMAPT7NR4RB2WVOGMETW4QY43KIDA3HWDWWXS3UEDKGTEECQ";
+const TEST_ROUND = 24099447;
+
+//#endregion
+export { DEFAULT_TOKEN, EXTERNAL_URL_ENV_VARS, MOCK_PORTS, TEST_ADDRESS, TEST_APP_ID, TEST_APP_ID_WITH_BOXES, TEST_ASSET_ID, TEST_BOX_NAME, TEST_ROUND, TEST_TXID, checkServerHealth, getMockServer };
+//# sourceMappingURL=mockServer.mjs.map

package/packages/testing/src/mockServer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockServer.mjs","names":[],"sources":["../../../../packages/testing/src/mockServer.ts"],"sourcesContent":["/**\n * Mock server infrastructure for algod/indexer/kmd client testing.\n *\n * Connects to externally managed mock servers that replay pre-recorded HAR files.\n * The mock server must be started separately (via GitHub Action in CI, or manually via bun for local dev).\n *\n * Set MOCK_ALGOD_URL / MOCK_INDEXER_URL / MOCK_KMD_URL environment variables to specify server URLs.\n */\n\n/** Supported client types for mock servers */\nexport type ClientType = 'algod' | 'indexer' | 'kmd'\n\n/** Environment variable names for external mock server URLs */\nexport const EXTERNAL_URL_ENV_VARS: Record<ClientType, string> = {\n  algod: 'MOCK_ALGOD_URL',\n  indexer: 'MOCK_INDEXER_URL',\n  kmd: 'MOCK_KMD_URL',\n}\n\n/** Default token used for mock server authentication */\nexport const DEFAULT_TOKEN = 'a'.repeat(64)\n\n/** Default ports for mock servers when running locally (matches algokit-polytest defaults) */\nexport const MOCK_PORTS = {\n  algod: { host: 8000 },\n  indexer: { host: 8002 },\n  kmd: { host: 8001 },\n} as const\n\n/** Mock server instance representing a connection to an external server */\nexport interface MockServer {\n  /** Base URL of the mock server */\n  baseUrl: string\n  /** Type of client this server mocks */\n  clientType: ClientType\n}\n\n/**\n * Check if a server is reachable by performing a health check.\n *\n * @param url - The base URL of the server to check\n * @param timeout - Maximum time to wait for the server to respond (default: 5000ms)\n * @returns Promise resolving to true if server is healthy, false otherwise\n */\nexport async function checkServerHealth(url: string, timeout = 5000): Promise<boolean> {\n  const healthUrl = `${url.replace(/\\/$/, '')}/health`\n  const start = Date.now()\n\n  while (Date.now() - start < timeout) {\n    try {\n      const controller = new AbortController()\n      const timeoutId = setTimeout(() => controller.abort(), 2000)\n      try {\n        await fetch(healthUrl, { signal: controller.signal })\n        clearTimeout(timeoutId)\n        // Any HTTP response (including 500) indicates the server is reachable\n        // The mock server returns 500 for unrecorded endpoints like /health\n        return true\n      } catch (error) {\n        clearTimeout(timeoutId)\n        // If it's a network error, retry\n        if (error instanceof Error && error.name === 'AbortError') {\n          await new Promise((resolve) => setTimeout(resolve, 200))\n          continue\n        }\n        throw error\n      }\n    } catch {\n      await new Promise((resolve) => setTimeout(resolve, 200))\n    }\n  }\n  return false\n}\n\n/**\n * Get a mock server instance for the specified client type.\n *\n * Reads the appropriate environment variable (MOCK_ALGOD_URL, MOCK_INDEXER_URL, or MOCK_KMD_URL)\n * and validates that the server is reachable before returning a MockServer instance.\n *\n * @param clientType - The type of client to get a mock server for ('algod', 'indexer', or 'kmd')\n * @returns Promise resolving to a MockServer instance\n * @throws Error if the environment variable is not set or the server is not reachable\n *\n * @example\n * ```typescript\n * const server = await getMockServer('algod')\n * const client = new AlgodClient(DEFAULT_TOKEN, server.baseUrl)\n * // ... run tests ...\n * ```\n */\nexport async function getMockServer(clientType: ClientType): Promise<MockServer> {\n  const envVar = EXTERNAL_URL_ENV_VARS[clientType]\n  const externalUrl = process.env[envVar]\n\n  if (!externalUrl) {\n    throw new Error(\n      `Environment variable ${envVar} is not set. ` +\n        `Please start the mock server externally and set the URL. ` +\n        `See the \"Mock Server for Client Tests\" section in README.md for local development setup.`,\n    )\n  }\n\n  const isHealthy = await checkServerHealth(externalUrl)\n  if (!isHealthy) {\n    throw new Error(\n      `Mock ${clientType} server at ${externalUrl} is not reachable. ` + `Please ensure the server is running and accessible.`,\n    )\n  }\n\n  return {\n    baseUrl: externalUrl.replace(/\\/$/, ''),\n    clientType,\n  }\n}\n\n// Test data constants matching mock server recordings\nexport const TEST_ADDRESS = '25M5BT2DMMED3V6CWDEYKSNEFGPXX4QBIINCOICLXXRU3UGTSGRMF3MTOE'\nexport const TEST_APP_ID = 718348254\nexport const TEST_APP_ID_WITH_BOXES = 742949200\nexport const TEST_BOX_NAME = 'b64:cBbHBNV+zUy/Mz5IRhIrBLxr1on5wmidhXEavV+SasC8'\nexport const TEST_ASSET_ID = 705457144\nexport const TEST_TXID = 'VIXTUMAPT7NR4RB2WVOGMETW4QY43KIDA3HWDWWXS3UEDKGTEECQ'\nexport const TEST_ROUND = 24099447\n"],"mappings":";;AAaA,MAAa,wBAAoD;CAC/D,OAAO;CACP,SAAS;CACT,KAAK;CACN;;AAGD,MAAa,gBAAgB,IAAI,OAAO,GAAG;;AAG3C,MAAa,aAAa;CACxB,OAAO,EAAE,MAAM,KAAM;CACrB,SAAS,EAAE,MAAM,MAAM;CACvB,KAAK,EAAE,MAAM,MAAM;CACpB;;;;;;;;AAiBD,eAAsB,kBAAkB,KAAa,UAAU,KAAwB;CACrF,MAAM,YAAY,GAAG,IAAI,QAAQ,OAAO,GAAG,CAAC;CAC5C,MAAM,QAAQ,KAAK,KAAK;AAExB,QAAO,KAAK,KAAK,GAAG,QAAQ,QAC1B,KAAI;EACF,MAAM,aAAa,IAAI,iBAAiB;EACxC,MAAM,YAAY,iBAAiB,WAAW,OAAO,EAAE,IAAK;AAC5D,MAAI;AACF,SAAM,MAAM,WAAW,EAAE,QAAQ,WAAW,QAAQ,CAAC;AACrD,gBAAa,UAAU;AAGvB,UAAO;WACA,OAAO;AACd,gBAAa,UAAU;AAEvB,OAAI,iBAAiB,SAAS,MAAM,SAAS,cAAc;AACzD,UAAM,IAAI,SAAS,YAAY,WAAW,SAAS,IAAI,CAAC;AACxD;;AAEF,SAAM;;SAEF;AACN,QAAM,IAAI,SAAS,YAAY,WAAW,SAAS,IAAI,CAAC;;AAG5D,QAAO;;;;;;;;;;;;;;;;;;;AAoBT,eAAsB,cAAc,YAA6C;CAC/E,MAAM,SAAS,sBAAsB;CACrC,MAAM,cAAc,QAAQ,IAAI;AAEhC,KAAI,CAAC,YACH,OAAM,IAAI,MACR,wBAAwB,OAAO,gKAGhC;AAIH,KAAI,CADc,MAAM,kBAAkB,YAAY,CAEpD,OAAM,IAAI,MACR,QAAQ,WAAW,aAAa,YAAY,wEAC7C;AAGH,QAAO;EACL,SAAS,YAAY,QAAQ,OAAO,GAAG;EACvC;EACD;;AAIH,MAAa,eAAe;AAC5B,MAAa,cAAc;AAC3B,MAAa,yBAAyB;AACtC,MAAa,gBAAgB;AAC7B,MAAa,gBAAgB;AAC7B,MAAa,YAAY;AACzB,MAAa,aAAa"}

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

@@ -1,46 +1,84 @@
 const require_array = require('../../common/src/array.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_hash = require('../../crypto/src/hash.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_hash.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","encodeSignedTransaction"],"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":";;;;;;;;;AAcA,MAAM,cAAc,IAAI,aAAa,CAAC,OAAO,UAAU;AACvD,MAAM,mBAAmB,IAAI,aAAa,CAAC,OAAO,cAAc;AAChE,MAAM,2BAA2B,IAAI,aAAa,CAAC,OAAO,WAAW;AAerE,IAAa,WAAb,MAAa,SAAgC;CAC3C;CACA;CACA,AAAU;CAEV,YAAY,SAAqB,aAAiC;AAChE,OAAK,QAAQ;AACb,OAAK,OAAO,eAAe,EAAE;AAG7B,OAAK,QAAQ,IAAIA,wBADPC,kBADSC,2BAAa,aAAa,KAAK,MAAM,CAC9B,CACC;;CAG7B,OAAO,cAAc,WAAwC;AAC3D,SAAO,IAAI,SAAS,UAAU,OAAO,UAAU,QAAQ,EAAE,CAAC;;CAG5D,OAAO,UAAU,aAAmC;EAClD,MAAM,UAAUC,8BAAc,YAAY;EAC1C,MAAM,gBAAgBC,uDAAuB,OAAO,SAAS,UAAU;AACvE,SAAO,SAAS,cAAc,cAAc;;CAG9C,UAAmB;AACjB,SAAO,KAAK;;CAGd,IAAI,OAAgB;AAClB,SAAO,KAAK;;CAGd,yBAAyB,MAAoC;AAC3D,MAAI,KACF,QAAOF,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;;CAG/E,UAA2B;AACzB,SAAO,IAAI,gBAAgB,KAAK,OAAO,KAAK,KAAK;;CAGnD,iBAAiB,WAAqC;AACpD,SAAO,IAAI,gBAAgB,KAAK,OAAO,KAAK,MAAM,UAAU;;;AAIhE,IAAa,kBAAb,MAAa,wBAAwB,SAAS;CAC5C;CACA;CACA;CAEA,OAAO,cAAc,WAA8B,WAAsC;AACvF,MAAI,UAAU,SAAS,UAAU,MAAM;GACrC,MAAM,WAAWG,iCAAgB,cAAe,UAAU,SAAS,UAAU,KAAO,CAAC;AAErF,OAAI,aAAa,CAAC,SAAS,OAAO,UAAU,CAC1C,OAAM,IAAI,MAAM,6DAA6D;GAG/E,MAAM,OAAO,IAAI,gBAAgB,UAAU,OAAO,UAAU,QAAQ,EAAE,EAAE,SAAS;AACjF,QAAK,QAAQ,UAAU;AACvB,QAAK,OAAO,UAAU;AACtB,UAAO;;EAGT,MAAM,cAAc,IAAI,gBAAgB,UAAU,OAAO,UAAU,QAAQ,EAAE,EAAE,UAAU;AAEzF,MAAI,UAAU,OAAO,cAAc,OACjC,OAAM,IAAI,MAAM,oEAAoE;AAGtF,MAAI,UAAU,KAAK;AACjB,eAAY,MAAM,UAAU;AAC5B,UAAO;;AAGT,SAAO;;CAGT,OAAO,UAAU,aAAyB,WAAsC;EAC9E,MAAM,UAAUF,8BAAc,YAAY;EAC1C,MAAM,gBAAgBC,uDAAuB,OAAO,SAAS,UAAU;AACvE,SAAO,gBAAgB,cAAc,eAAe,UAAU;;CAGhE,YAAY,SAAqB,aAAwC,WAAqB;AAC5F,QAAM,SAAS,eAAe,OAAU;AACxC,OAAK,QAAQ,aAAa,KAAK;;CAGjC,IAAI,SAA4B;AAC9B,SAAO,OAAO,MAAqB,YAAsB;GACvD,MAAM,aAA2B,EAAE;AACnC,QAAK,MAAM,SAAS,SAAS;IAG3B,MAAM,OAA0B;KAC9B,KAHU,KAAK;KAIf,MAAM;MAAE,OAAO,KAAK;MAAO,MAAM,KAAK;MAAM,MAAM,KAAK;MAAM,OAAO,KAAK;MAAO,KAAK,KAAK;MAAK;KAChG;AAED,QAAI,CAAC,KAAK,IAAI,OAAO,OAAO,KAAK,KAAK,CACpC,MAAK,cAAc,KAAK;AAG1B,yDAA0B,KAAK;AAC/B,eAAW,KAAKE,mDAAwB,KAAK,CAAC;;AAGhD,UAAO;;;CAIX,MAAM,kBAAkB,WAA2C;EACjE,MAAM,SAAS,MAAM,UAAU,WAAW,KAAK;AAE/C,MAAI,CAAC,OAAO,KAAK,OAAO,KAAK,MAAM,CACjC,OAAM,IAAI,MACR,sFAAsF,KAAK,MAAM,UAAU,CAAC,SAAS,OAAO,KAAK,UAAU,GAC5I;AAGH,MAAI,SAAS,UAAU,OAAO,IAC5B,MAAK,MAAM,OAAO;WACT,WAAW,UAAU,OAAO,MACrC,MAAK,QAAQ,OAAO;MAEpB,OAAM,IAAI,MAAM,0DAA0D"}