@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/{init-DvVgKCaP2.cjs → init-bzvl1JhF.cjs}

@@ -1,7 +1,7 @@
 require("./chunk-9hOWP6kD.cjs");
 require("./_polyfill-buffer-patch-BycQkEkK.cjs");
-const require_serializable = require("./serializable-DWgkHhv_.cjs");
-const require_key_value_store = require("./key-value-store-B-XRIwaM.cjs");
+const require_serializable = require("./serializable-n3UoxbZc.cjs");
+const require_key_value_store = require("./key-value-store-Htj4RgMe.cjs");
 //#region ../../packages/module/storage-web-indexeddb/src/storage-api-adapter.ts
 const DB_NAME = "lace-storage";
 const OBJECT_STORE_NAME = "key-value";

package/dist/{init-BgrY29gW.js → init-dsYkC_0B.js}

@@ -1,7 +1,7 @@
-import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-VdbuqBsI.js";
-import { t as whileActive } from "./while-active-CNXeLxre.js";
-import { c as POLLING_INTERVAL_MS, i as shouldFetchPriceHistory, l as SUPPORTED_CURRENCIES_FEATURE_FLAG, o as DEFAULT_CURRENCY_PREFERENCE, r as shouldFetchPrice, u as TOKEN_PRICING_NETWORK_TYPE } from "./utils-DrtzChYN.js";
-import { r as tokenPricingReducers } from "./slice-KiNoGwD9.js";
+import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-Bu5Yn5ua.js";
+import { t as whileActive } from "./while-active-CDBnUlQA.js";
+import { d as TOKEN_PRICING_NETWORK_TYPE, i as shouldFetchPriceHistory, l as POLLING_INTERVAL_MS, r as shouldFetchPrice, s as DEFAULT_CURRENCY_PREFERENCE, u as SUPPORTED_CURRENCIES_FEATURE_FLAG } from "./utils-DcnoETEP.js";
+import { r as tokenPricingReducers } from "./slice-DlTEqIoI.js";
 import { EMPTY, catchError, concat, distinctUntilChanged, exhaustMap, filter, interval, map, merge, of, startWith, switchMap, withLatestFrom } from "rxjs";
 import { createMigrate } from "redux-persist";
 //#region ../../packages/lib/util-store/src/by-blockchain-name.ts

package/dist/{init-B5BsI3DR.cjs → init-kvn5FlPS.cjs}

@@ -1,10 +1,10 @@
 require("./chunk-9hOWP6kD.cjs");
 require("./_polyfill-buffer-patch-BycQkEkK.cjs");
-require("./serializable-DWgkHhv_.cjs");
-const require_is_redux_persist_state = require("./is-redux-persist-state-DxJSsvxB.cjs");
-const require_account_id_vo = require("./account-id.vo-Xpgnu-av.cjs");
-const require_activity_type_stable = require("./activity-type.stable-ClO9j_PH.cjs");
-const require_slice = require("./slice-exhhmucR.cjs");
+require("./serializable-n3UoxbZc.cjs");
+const require_is_redux_persist_state = require("./is-redux-persist-state-C5luvPEH.cjs");
+const require_account_id_vo = require("./account-id.vo-DYZBZQsz.cjs");
+const require_activity_type = require("./activity-type-BPXxdHBP.cjs");
+const require_slice = require("./slice-DtitVc9L.cjs");
 let redux_persist = require("redux-persist");
 //#region ../../packages/contract/activities/src/store/migrations/reset-reward-activity-dates.ts
 /**
@@ -29,7 +29,7 @@ const resetRewardActivities = (state) => {
 		const list = activitiesMap[key];
 		if (!Array.isArray(list)) continue;
 		desiredLoadedActivitiesCountPerAccount[accountId] = list.length;
-		activitiesMap[key] = list.filter((activity) => activity.type !== require_activity_type_stable.ActivityType.Rewards);
+		activitiesMap[key] = list.filter((activity) => activity.type !== require_activity_type.ActivityType.Rewards);
 	}
 	return {
 		...typedState,
@@ -49,7 +49,7 @@ const rewardEpochDisplay = (state) => {
 	const activitiesMap = typedState.activities ?? {};
 	for (const list of Object.values(activitiesMap)) {
 		if (!Array.isArray(list)) continue;
-		for (const activity of list) if (activity.type === require_activity_type_stable.ActivityType.Rewards && activity.blockchainSpecific && typeof activity.blockchainSpecific.epoch === "number") {
+		for (const activity of list) if (activity.type === require_activity_type.ActivityType.Rewards && activity.blockchainSpecific && typeof activity.blockchainSpecific.epoch === "number") {
 			const meta = activity.blockchainSpecific;
 			meta.epoch = meta.epoch + REWARD_EPOCH_DISPLAY_OFFSET;
 		}

package/dist/init-vfy9DW_E.js

@@ -0,0 +1,119 @@
+import { t as contextLogger } from "./logging-BAMMfn5j.js";
+import { n as Ok, t as Err } from "./asyncoption-DZQGfznq.js";
+import { i as toProviderError } from "./error-CvEYL98P.js";
+import { t as HttpClient } from "./http-client-B7_kBTYn.js";
+import { n as BitcoinNetwork } from "./types-DXSxXGz0.js";
+import { from } from "rxjs";
+import memoize from "lodash/memoize.js";
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/mempool/mempool-fee-market-provider.ts
+const MIN_FEE_RATE = 11e-6;
+const DEFAULT_MARKETS = {
+	fast: {
+		feeRate: 25e-6,
+		targetConfirmationTime: 1
+	},
+	standard: {
+		feeRate: 15e-6,
+		targetConfirmationTime: 3
+	},
+	slow: {
+		feeRate: 11e-6,
+		targetConfirmationTime: 6
+	}
+};
+/**
+* Converts a fee rate in satoshis per vbyte to BTC per kilobyte.
+* @param satsPerVByte - The fee rate in satoshis per vbyte.
+*/
+const satsPerVByteToBtcPerKB = (satsPerVByte) => satsPerVByte * 1e3 / 1e8;
+/**
+* High-level REST wrapper around Mempool.space's Bitcoin feemarket API API.
+*/
+var MempoolFeeMarketProvider = class {
+	logger;
+	#client;
+	/**
+	* Creates a new instance of the Mempool FeeMarket provider.
+	*
+	* @param client - Pre-configured HTTP client.
+	* @param logger - Any ts-log compatible logger implementation.
+	*/
+	constructor(client, logger) {
+		this.#client = client;
+		this.logger = contextLogger(logger, this.constructor.name);
+	}
+	/**
+	* Estimates the transaction fee in BTC per kilobyte based on the desired confirmation time and fee estimation mode.
+	*
+	* This method queries a blockchain fee estimation service to determine the appropriate fee
+	* rate required for a transaction to be confirmed within the specified number of blocks.
+	*
+	* @returns A promise that resolves to the estimated fee in satoshis per byte.
+	*                            This value can be used to calculate the total transaction fee
+	*                            based on the size of the transaction in bytes.
+	*/
+	async getFeeMarket(network) {
+		try {
+			if (network === BitcoinNetwork.Testnet) return DEFAULT_MARKETS;
+			const feeData = await this.request("/api/v1/fees/recommended");
+			const fastEstimate = feeData.fastestFee;
+			const standardEstimate = feeData.halfHourFee;
+			const slowEstimate = feeData.hourFee;
+			return {
+				fast: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(fastEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 600
+				},
+				standard: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(standardEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 1800
+				},
+				slow: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(slowEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 3600
+				}
+			};
+		} catch (error) {
+			this.logger.error("Failed to fetch fee market:", error);
+		}
+		return DEFAULT_MARKETS;
+	}
+	/**
+	* Performs a generic HTTP request to the Mempool.space API.
+	*/
+	async request(endpoint, options) {
+		try {
+			this.logger.debug("request", endpoint);
+			const response = await this.#client.request(endpoint, options);
+			this.logger.debug("response", JSON.stringify(response));
+			return response.data;
+		} catch (error) {
+			this.logger.debug("error", error);
+			throw toProviderError(error);
+		}
+	}
+};
+//#endregion
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/store/dependencies.ts
+const computeMaestroConfigIdentifier = ({ url }) => `${url}`;
+const getMempoolSpaceClient = memoize(({ url }) => {
+	return new HttpClient({ baseUrl: url });
+}, computeMaestroConfigIdentifier);
+const getMempoolSpaceApiProvider = memoize((config, logger) => {
+	return new MempoolFeeMarketProvider(getMempoolSpaceClient(config), logger);
+}, computeMaestroConfigIdentifier);
+const getMempoolSpaceConfig = (context, configs) => {
+	const config = configs[context.network];
+	if (!config) throw new Error(`Assertion failed: no blockfrost config found (${context.network}`);
+	return config;
+};
+const initializeDependencies = async ({ runtime: { config: { bitcoinFeeMarketProvider: { mempoolSpaceConfig } } } }, { logger }) => {
+	return { bitcoinFeeMarketProvider: { getFeeMarket: (context) => {
+		return from(getMempoolSpaceApiProvider(getMempoolSpaceConfig(context, mempoolSpaceConfig), logger).getFeeMarket(context.network).then(Ok).catch(Err));
+	} } };
+};
+//#endregion
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/store/init.ts
+const redux = async (props, dependencies) => ({ sideEffectDependencies: await initializeDependencies(props, dependencies) });
+//#endregion
+export { redux as default };

package/dist/{init-BE_6Jyc4.js → init-w7xl6LsP.js}

@@ -1,6 +1,6 @@
-import { n as v4, t as init_esm_browser } from "./esm-browser-BBVQuyQv.js";
-import { a as FolderId, t as reducers } from "./slice-DaNVz7_l.js";
-import { t as firstStateOfStatus } from "./first-state-of-status-D7XzEuSa.js";
+import { n as v4, t as init_esm_browser } from "./esm-browser-DpAD_RKv.js";
+import { a as FolderId, t as reducers } from "./slice-ByNWnxKS.js";
+import { t as firstStateOfStatus } from "./first-state-of-status-BscbKj_t.js";
 import { switchMap, withLatestFrom } from "rxjs";
 import { createMigrate } from "redux-persist";
 //#region ../../packages/contract/tokens/src/store/side-effects.ts

package/dist/{init-DEsWVyn5.cjs → init-wgiBUmyW.cjs}

@@ -1,5 +1,5 @@
 require("./chunk-9hOWP6kD.cjs");
-const require_composite_signer_factory = require("./composite-signer-factory-BizuNPP7.cjs");
+const require_composite_signer_factory = require("./composite-signer-factory-v4Pxn8bA.cjs");
 //#region ../../packages/contract/signer/src/store/dependencies.ts
 const initializeSignerSideEffectDependencies = async ({ loadModules }) => {
 	return { signerFactory: new require_composite_signer_factory.CompositeSignerFactory(await loadModules("addons.loadSignerFactory")) };

package/dist/{is-retriable-error-DWv_ob-f.js → is-retriable-error-CmFR20pe.js}

@@ -1,5 +1,5 @@
 import { r as ProviderFailure } from "./errors-CAOTqN4_.js";
-import { n as errorHasReason } from "./error-DHKO2iS4.js";
+import { n as errorHasReason } from "./error-CvEYL98P.js";
 //#region ../../packages/lib/util-provider/src/is-retriable-error.ts
 /**
 * Determines if a ProviderError should be retried based on its failure type.

package/dist/{is-retriable-error-Dtb4JGjd.cjs → is-retriable-error-D2yo0_lS.cjs}

@@ -1,5 +1,5 @@
 const require_errors = require("./errors-lg3enbYs.cjs");
-const require_error = require("./error-ggOihIfv.cjs");
+const require_error = require("./error-B6wj9nPv.cjs");
 //#region ../../packages/lib/util-provider/src/is-retriable-error.ts
 /**
 * Determines if a ProviderError should be retried based on its failure type.

package/dist/jubjub-authoriser-A2c8vmkN.js

@@ -0,0 +1,84 @@
+import "./_polyfill-buffer-patch-JcrfT1gU.js";
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-CziaOsba.js";
+import { t as DeviceCommitmentHex } from "./device-commitment-hex.vo-D9FsYLn7.js";
+import { t as UnknownCircuitError } from "./artefact-loader-D0T2f6F7.js";
+import { n as ROTATE_ENC_KEY_CIRCUIT, t as APPEND_INBOX_CIRCUIT } from "./enc-key-circuits-0Dud78IB.js";
+import { d as REVOKE_ALL_GRANTS_CIRCUIT, f as REVOKE_GRANT_CIRCUIT, r as issueGrantBinding, u as ISSUE_GRANT_CIRCUIT } from "./grants-CYY0AquW.js";
+import { a as pureCircuits } from "./acc-module-ur8CkBd1.js";
+//#region ../../packages/module/passport-account/src/acc/challenges.ts
+const address = (context) => ({ bytes: context.contractAddress });
+/**
+* Per-circuit challenge builders for the jubjub-gated circuits this module
+* calls. The preimage layout is produced by the contract's own exported
+* pure circuits: a per-circuit domain separation tag, the account address,
+* the signature announcement, the device public key, the circuit's
+* arguments in declaration order, the auth nonce, and the grind nonce.
+* The grant lifecycle circuits sit in the same tag family as the device
+* circuits; the issue challenge carries the grant id and the scope digest
+* rather than the scope's fields. The encryption key circuits bind the
+* key `enc_key` is replaced with and the entry appended to the inbox.
+* `activate_initial_device_with_jubjub` is permissionless and has no
+* challenge.
+*/
+const jubjubChallenges = {
+	addDevice: (context, pk, newEntry) => (sigR, grindNonce) => pureCircuits.challenge_add_device_with_jubjub(address(context), sigR, pk, newEntry, context.authNonce, grindNonce),
+	removeDevice: (context, pk, entry) => (sigR, grindNonce) => pureCircuits.challenge_remove_device_with_jubjub(address(context), sigR, pk, entry, context.authNonce, grindNonce),
+	issueGrant: (context, pk, binding) => (sigR, grindNonce) => pureCircuits.challenge_issue_grant_with_jubjub(address(context), sigR, pk, binding.grantId, binding.scopeDigest, context.authNonce, grindNonce),
+	revokeGrant: (context, pk, grantId) => (sigR, grindNonce) => pureCircuits.challenge_revoke_grant_with_jubjub(address(context), sigR, pk, grantId, context.authNonce, grindNonce),
+	rotateEncKey: (context, pk, newKey) => (sigR, grindNonce) => pureCircuits.challenge_rotate_enc_key_with_jubjub(address(context), sigR, pk, newKey, context.authNonce, grindNonce),
+	appendInbox: (context, pk, entry) => (sigR, grindNonce) => pureCircuits.challenge_append_inbox_with_jubjub(address(context), sigR, pk, entry, context.authNonce, grindNonce),
+	revokeAllGrants: (context, pk) => (sigR, grindNonce) => pureCircuits.challenge_revoke_all_grants_with_jubjub(address(context), sigR, pk, context.authNonce, grindNonce)
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/jubjub-authoriser.ts
+const HEX_BYTE_PATTERN = /^(?:[0-9a-f]{2})*$/;
+const accountToBytes = (account) => {
+	if (!HEX_BYTE_PATTERN.test(account)) throw new Error(`AccAddress is not lowercase hex of whole bytes: "${account}"`);
+	return ByteArray.fromHex(HexBytes(account));
+};
+const bytesArgument = (request) => {
+	const [entry] = request.args;
+	if (!(entry instanceof Uint8Array)) throw new Error(`Circuit ${request.circuit} expects a byte-array entry as its first argument`);
+	return entry;
+};
+const noArguments = (request) => {
+	if (request.args.length > 0) throw new Error(`Circuit ${request.circuit} takes no argument`);
+};
+const challengeBuilders = {
+	add_device_with_jubjub: (context, pk, request) => jubjubChallenges.addDevice(context, pk, bytesArgument(request)),
+	remove_device_with_jubjub: (context, pk, request) => jubjubChallenges.removeDevice(context, pk, bytesArgument(request)),
+	[ISSUE_GRANT_CIRCUIT]: (context, pk, request) => jubjubChallenges.issueGrant(context, pk, issueGrantBinding(request.args)),
+	[REVOKE_GRANT_CIRCUIT]: (context, pk, request) => jubjubChallenges.revokeGrant(context, pk, bytesArgument(request)),
+	[REVOKE_ALL_GRANTS_CIRCUIT]: (context, pk, request) => {
+		noArguments(request);
+		return jubjubChallenges.revokeAllGrants(context, pk);
+	},
+	[ROTATE_ENC_KEY_CIRCUIT]: (context, pk, request) => jubjubChallenges.rotateEncKey(context, pk, bytesArgument(request)),
+	[APPEND_INBOX_CIRCUIT]: (context, pk, request) => jubjubChallenges.appendInbox(context, pk, bytesArgument(request))
+};
+/**
+* A PassportAuthoriser over any JubJub device key source. Authorises the
+* device-management, grant lifecycle and encryption key circuits this
+* module calls and rejects everything else, including the permissionless
+* `activate_initial_device_with_jubjub`, which needs no authorisation.
+*/
+const createJubjubAuthoriser = (runWithDevice) => ({
+	scheme: "jubjub-schnorr",
+	deviceCommitment: async (account, epoch, counter) => runWithDevice((device) => DeviceCommitmentHex(HexBytes.fromByteArray(device.entryAt(accountToBytes(account), epoch, counter)))),
+	deviceCommitments: async (account, epoch, counters) => runWithDevice((device) => {
+		const accountBytes = accountToBytes(account);
+		return counters.map((counter) => DeviceCommitmentHex(HexBytes.fromByteArray(device.entryAt(accountBytes, epoch, counter))));
+	}),
+	devicePublicKey: async () => runWithDevice((device) => device.pk),
+	authorise: async (request) => runWithDevice((device) => {
+		const toBuilder = challengeBuilders[request.circuit];
+		if (!toBuilder) throw new UnknownCircuitError(request.circuit);
+		const context = {
+			contractAddress: accountToBytes(request.account),
+			authNonce: request.authNonce
+		};
+		return device.sign(toBuilder(context, device.pk, request), request.useCounter);
+	})
+});
+//#endregion
+export { createJubjubAuthoriser };

package/dist/jubjub-authoriser-D3ZDgzcF.cjs

@@ -0,0 +1,85 @@
+require("./chunk-9hOWP6kD.cjs");
+require("./_polyfill-buffer-patch-BycQkEkK.cjs");
+const require_bytes_vo = require("./bytes.vo-hecRu3YZ.cjs");
+const require_device_commitment_hex_vo = require("./device-commitment-hex.vo-BIUYUNz1.cjs");
+const require_artefact_loader = require("./artefact-loader-Cqc9eSkL.cjs");
+const require_enc_key_circuits = require("./enc-key-circuits-yjPHbuo_.cjs");
+const require_grants = require("./grants-CIb6nOV7.cjs");
+const require_acc_module = require("./acc-module-NL_8mEHH.cjs");
+//#region ../../packages/module/passport-account/src/acc/challenges.ts
+const address = (context) => ({ bytes: context.contractAddress });
+/**
+* Per-circuit challenge builders for the jubjub-gated circuits this module
+* calls. The preimage layout is produced by the contract's own exported
+* pure circuits: a per-circuit domain separation tag, the account address,
+* the signature announcement, the device public key, the circuit's
+* arguments in declaration order, the auth nonce, and the grind nonce.
+* The grant lifecycle circuits sit in the same tag family as the device
+* circuits; the issue challenge carries the grant id and the scope digest
+* rather than the scope's fields. The encryption key circuits bind the
+* key `enc_key` is replaced with and the entry appended to the inbox.
+* `activate_initial_device_with_jubjub` is permissionless and has no
+* challenge.
+*/
+const jubjubChallenges = {
+	addDevice: (context, pk, newEntry) => (sigR, grindNonce) => require_acc_module.pureCircuits.challenge_add_device_with_jubjub(address(context), sigR, pk, newEntry, context.authNonce, grindNonce),
+	removeDevice: (context, pk, entry) => (sigR, grindNonce) => require_acc_module.pureCircuits.challenge_remove_device_with_jubjub(address(context), sigR, pk, entry, context.authNonce, grindNonce),
+	issueGrant: (context, pk, binding) => (sigR, grindNonce) => require_acc_module.pureCircuits.challenge_issue_grant_with_jubjub(address(context), sigR, pk, binding.grantId, binding.scopeDigest, context.authNonce, grindNonce),
+	revokeGrant: (context, pk, grantId) => (sigR, grindNonce) => require_acc_module.pureCircuits.challenge_revoke_grant_with_jubjub(address(context), sigR, pk, grantId, context.authNonce, grindNonce),
+	rotateEncKey: (context, pk, newKey) => (sigR, grindNonce) => require_acc_module.pureCircuits.challenge_rotate_enc_key_with_jubjub(address(context), sigR, pk, newKey, context.authNonce, grindNonce),
+	appendInbox: (context, pk, entry) => (sigR, grindNonce) => require_acc_module.pureCircuits.challenge_append_inbox_with_jubjub(address(context), sigR, pk, entry, context.authNonce, grindNonce),
+	revokeAllGrants: (context, pk) => (sigR, grindNonce) => require_acc_module.pureCircuits.challenge_revoke_all_grants_with_jubjub(address(context), sigR, pk, context.authNonce, grindNonce)
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/jubjub-authoriser.ts
+const HEX_BYTE_PATTERN = /^(?:[0-9a-f]{2})*$/;
+const accountToBytes = (account) => {
+	if (!HEX_BYTE_PATTERN.test(account)) throw new Error(`AccAddress is not lowercase hex of whole bytes: "${account}"`);
+	return require_bytes_vo.ByteArray.fromHex(require_bytes_vo.HexBytes(account));
+};
+const bytesArgument = (request) => {
+	const [entry] = request.args;
+	if (!(entry instanceof Uint8Array)) throw new Error(`Circuit ${request.circuit} expects a byte-array entry as its first argument`);
+	return entry;
+};
+const noArguments = (request) => {
+	if (request.args.length > 0) throw new Error(`Circuit ${request.circuit} takes no argument`);
+};
+const challengeBuilders = {
+	add_device_with_jubjub: (context, pk, request) => jubjubChallenges.addDevice(context, pk, bytesArgument(request)),
+	remove_device_with_jubjub: (context, pk, request) => jubjubChallenges.removeDevice(context, pk, bytesArgument(request)),
+	[require_grants.ISSUE_GRANT_CIRCUIT]: (context, pk, request) => jubjubChallenges.issueGrant(context, pk, require_grants.issueGrantBinding(request.args)),
+	[require_grants.REVOKE_GRANT_CIRCUIT]: (context, pk, request) => jubjubChallenges.revokeGrant(context, pk, bytesArgument(request)),
+	[require_grants.REVOKE_ALL_GRANTS_CIRCUIT]: (context, pk, request) => {
+		noArguments(request);
+		return jubjubChallenges.revokeAllGrants(context, pk);
+	},
+	[require_enc_key_circuits.ROTATE_ENC_KEY_CIRCUIT]: (context, pk, request) => jubjubChallenges.rotateEncKey(context, pk, bytesArgument(request)),
+	[require_enc_key_circuits.APPEND_INBOX_CIRCUIT]: (context, pk, request) => jubjubChallenges.appendInbox(context, pk, bytesArgument(request))
+};
+/**
+* A PassportAuthoriser over any JubJub device key source. Authorises the
+* device-management, grant lifecycle and encryption key circuits this
+* module calls and rejects everything else, including the permissionless
+* `activate_initial_device_with_jubjub`, which needs no authorisation.
+*/
+const createJubjubAuthoriser = (runWithDevice) => ({
+	scheme: "jubjub-schnorr",
+	deviceCommitment: async (account, epoch, counter) => runWithDevice((device) => require_device_commitment_hex_vo.DeviceCommitmentHex(require_bytes_vo.HexBytes.fromByteArray(device.entryAt(accountToBytes(account), epoch, counter)))),
+	deviceCommitments: async (account, epoch, counters) => runWithDevice((device) => {
+		const accountBytes = accountToBytes(account);
+		return counters.map((counter) => require_device_commitment_hex_vo.DeviceCommitmentHex(require_bytes_vo.HexBytes.fromByteArray(device.entryAt(accountBytes, epoch, counter))));
+	}),
+	devicePublicKey: async () => runWithDevice((device) => device.pk),
+	authorise: async (request) => runWithDevice((device) => {
+		const toBuilder = challengeBuilders[request.circuit];
+		if (!toBuilder) throw new require_artefact_loader.UnknownCircuitError(request.circuit);
+		const context = {
+			contractAddress: accountToBytes(request.account),
+			authNonce: request.authNonce
+		};
+		return device.sign(toBuilder(context, device.pk, request), request.useCounter);
+	})
+});
+//#endregion
+exports.createJubjubAuthoriser = createJubjubAuthoriser;