@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/grants-CIb6nOV7.cjs

@@ -0,0 +1,273 @@
+const require_bytes_vo = require("./bytes.vo-hecRu3YZ.cjs");
+const require_grant_rules = require("./grant-rules-B7eDuD5G.cjs");
+const require_errors = require("./errors-BA3b8aVu.cjs");
+const require_acc_module = require("./acc-module-NL_8mEHH.cjs");
+//#region ../../packages/module/passport-account/src/acc/grant-circuits.ts
+/**
+* The gated circuits the grant flows authorise, named once so the flow
+* that submits a call, the authoriser that builds its challenge and the
+* signer that scopes a key session to it agree on the circuit.
+*/
+const ISSUE_GRANT_CIRCUIT = "issue_grant_with_jubjub";
+const REVOKE_GRANT_CIRCUIT = "revoke_grant_with_jubjub";
+const REVOKE_ALL_GRANTS_CIRCUIT = "revoke_all_grants_with_jubjub";
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/grants.ts
+/** Domain tag of the origin hash; it fills its 32-byte pad exactly. */
+const GRANT_ORIGIN_TAG = "midnight:account:grant:origin:v1";
+const ORIGIN_TAG_LENGTH = 32;
+const SCOPE_SALT_LENGTH = 32;
+const GRANT_SLOT_COUNT = 256;
+const SCOPE_ARG_COUNT = 16;
+/** Lays the scope out in the circuit's declaration order. */
+const scopeArgs = (scope) => [
+	scope.opWithdrawUnshielded,
+	scope.opWithdrawShielded,
+	scope.opWithdrawShieldedToContract,
+	scope.read,
+	scope.color,
+	scope.recipientKind,
+	scope.recipient,
+	scope.maxCoinValue,
+	scope.perCallCap,
+	scope.cap,
+	scope.expiresAt,
+	scope.rpIdHash,
+	scope.readPkHash,
+	scope.windowLen,
+	scope.windowCap,
+	{
+		is_some: scope.caller !== void 0,
+		value: { bytes: scope.caller ?? require_grant_rules.zero32() }
+	}
+];
+/**
+* The salted digest of the plaintext scope, the single element through
+* which the issue challenge binds the whole scope, produced by the
+* contract's own pure circuit.
+*/
+const scopeDigest = (scopeSalt, args) => require_acc_module.pureCircuits.derive_grant_scope_digest(scopeSalt, ...args);
+/**
+* The commitment the contract stores for a grant's object: the colour,
+* recipient kind and value, and coin bound of its circuit scope, hidden
+* under the scope salt, as lowercase hex, produced by the contract's own
+* pure circuit.
+*/
+const grantObjectCommit = (scopeSalt, scope) => require_bytes_vo.HexBytes.fromByteArray(require_acc_module.pureCircuits.derive_grant_object_commit(scopeSalt, scope.color, scope.recipientKind, scope.recipient, scope.maxCoinValue));
+/**
+* The origin hash that enters a grant id: SHA-256 of the origin tag padded
+* to 32 bytes followed by the raw UTF-8 bytes of the client id. Computed
+* off chain only, so no circuit exports it. For this module the client id
+* is the relying party id of the consumer issuing the grant.
+*/
+const originHash = async (clientId) => {
+	const encoder = new TextEncoder();
+	const tag = new Uint8Array(ORIGIN_TAG_LENGTH);
+	tag.set(encoder.encode(GRANT_ORIGIN_TAG));
+	const client = encoder.encode(clientId);
+	const preimage = new Uint8Array(tag.length + client.length);
+	preimage.set(tag);
+	preimage.set(client, tag.length);
+	return new Uint8Array(await crypto.subtle.digest("SHA-256", preimage));
+};
+/**
+* The identity of a grant: the contract's own commitment to the account,
+* the grantee key, the origin hash and the slot, which keys the record in
+* the grants map.
+*/
+const deriveGrantId = ({ contractAddress, granteePublicKey, originHash: origin, slot }) => require_grant_rules.GrantId(require_bytes_vo.HexBytes.fromByteArray(require_acc_module.pureCircuits.derive_grant_id_with_jubjub({ bytes: contractAddress }, granteePublicKey, origin, BigInt(slot))));
+/**
+* The first slot under which this grantee and origin have no active grant,
+* with the id derived for it. The contract stores neither grantee nor
+* slot, so the slot is found by deriving the id of each candidate and
+* checking it against the roster. A revoked grant leaves a tombstone the
+* contract lets a new grant overwrite, so its slot counts as free.
+*
+* @throws {@link GrantLimitReachedError} when every slot is taken.
+*/
+const findFreeSlot = ({ contractAddress, grantee, originHash: origin, roster }) => {
+	const taken = new Set(roster.filter((record) => record.active).map((record) => record.id));
+	const granteePublicKey = require_grant_rules.granteePoint(grantee);
+	for (let candidate = 0; candidate < GRANT_SLOT_COUNT; candidate++) {
+		const slot = require_grant_rules.GrantSlot(candidate);
+		const grantId = deriveGrantId({
+			contractAddress,
+			granteePublicKey,
+			originHash: origin,
+			slot
+		});
+		if (!taken.has(grantId)) return {
+			slot,
+			grantId
+		};
+	}
+	throw new require_errors.GrantLimitReachedError("Every grant slot of this grantee under this origin is taken.");
+};
+/**
+* Prepares `issue_grant_with_jubjub`: encodes and checks the scope,
+* allocates the grantee's slot, derives the grant id and draws the scope
+* salt. The call's arguments are the grant id, the scope in declaration
+* order and the salt; the authoriser derives the scope digest it signs
+* from those same arguments, and the preparation carries that digest for
+* an authoriser that presents it ahead of the ceremony.
+*
+* @throws {@link GrantScopeInvalidError} when the scope is malformed or
+* breaks an issue rule.
+* @throws {@link GrantLimitReachedError} when the grantee has no free slot.
+*/
+const prepareIssueGrant = ({ contractAddress, scope, originHash: origin, roster, randomBytes = (length) => crypto.getRandomValues(new Uint8Array(length)) }) => {
+	const encoded = require_grant_rules.circuitScope(scope);
+	require_grant_rules.assertIssueRules(encoded);
+	const { slot, grantId } = findFreeSlot({
+		contractAddress,
+		grantee: scope.grantee,
+		originHash: origin,
+		roster
+	});
+	const salt = randomBytes(SCOPE_SALT_LENGTH);
+	const args = scopeArgs(encoded);
+	return {
+		grantId,
+		slot,
+		scopeSalt: require_grant_rules.GrantScopeSalt(require_bytes_vo.HexBytes.fromByteArray(salt)),
+		scopeDigest: require_bytes_vo.HexBytes.fromByteArray(scopeDigest(salt, args)),
+		call: {
+			circuit: ISSUE_GRANT_CIRCUIT,
+			args: [
+				require_bytes_vo.ByteArray.fromHex(require_bytes_vo.HexBytes(grantId)),
+				...args,
+				salt
+			]
+		}
+	};
+};
+/** Prepares `revoke_grant_with_jubjub` over one grant id. */
+const prepareRevokeGrant = (grantId) => ({
+	circuit: REVOKE_GRANT_CIRCUIT,
+	args: [require_bytes_vo.ByteArray.fromHex(require_bytes_vo.HexBytes(grantId))]
+});
+/** Prepares `revoke_all_grants_with_jubjub`, which takes no argument. */
+const prepareRevokeAllGrants = () => ({
+	circuit: REVOKE_ALL_GRANTS_CIRCUIT,
+	args: []
+});
+const SCOPE_ARG_KINDS = [
+	"boolean",
+	"boolean",
+	"boolean",
+	"boolean",
+	"bytes",
+	"bigint",
+	"bytes",
+	"bigint",
+	"bigint",
+	"bigint",
+	"bigint",
+	"bytes",
+	"bytes",
+	"bigint",
+	"bigint",
+	"caller"
+];
+const isCaller = (value) => typeof value === "object" && value !== null && typeof value.is_some === "boolean" && value.value?.bytes instanceof Uint8Array;
+const isScopeArgument = (value, kind) => {
+	switch (kind) {
+		case "boolean": return typeof value === "boolean";
+		case "bigint": return typeof value === "bigint";
+		case "bytes": return value instanceof Uint8Array;
+		case "caller": return isCaller(value);
+	}
+};
+const isScopeArgs = (values) => values.length === SCOPE_ARG_COUNT && values.every((value, index) => isScopeArgument(value, SCOPE_ARG_KINDS[index]));
+/**
+* Reads what the issue challenge binds out of the circuit's argument list
+* as it reaches an authoriser: the grant id and the digest of the scope,
+* derived here from the plaintext arguments and the salt so the signer
+* binds the scope it was shown and nothing else.
+*
+* @throws an Error when the arguments are not a grant id, sixteen scope
+* arguments and a scope salt.
+*/
+const issueGrantBinding = (args) => {
+	const [grantId, ...rest] = args;
+	const scopeSalt = rest.at(-1);
+	const scope = rest.slice(0, -1);
+	if (!(grantId instanceof Uint8Array) || !(scopeSalt instanceof Uint8Array) || !isScopeArgs(scope)) throw new Error(`Circuit ${ISSUE_GRANT_CIRCUIT} expects a grant id, ${SCOPE_ARG_COUNT} scope arguments and a scope salt`);
+	return {
+		grantId,
+		scopeDigest: scopeDigest(scopeSalt, scope)
+	};
+};
+//#endregion
+Object.defineProperty(exports, "ISSUE_GRANT_CIRCUIT", {
+	enumerable: true,
+	get: function() {
+		return ISSUE_GRANT_CIRCUIT;
+	}
+});
+Object.defineProperty(exports, "REVOKE_ALL_GRANTS_CIRCUIT", {
+	enumerable: true,
+	get: function() {
+		return REVOKE_ALL_GRANTS_CIRCUIT;
+	}
+});
+Object.defineProperty(exports, "REVOKE_GRANT_CIRCUIT", {
+	enumerable: true,
+	get: function() {
+		return REVOKE_GRANT_CIRCUIT;
+	}
+});
+Object.defineProperty(exports, "deriveGrantId", {
+	enumerable: true,
+	get: function() {
+		return deriveGrantId;
+	}
+});
+Object.defineProperty(exports, "grantObjectCommit", {
+	enumerable: true,
+	get: function() {
+		return grantObjectCommit;
+	}
+});
+Object.defineProperty(exports, "issueGrantBinding", {
+	enumerable: true,
+	get: function() {
+		return issueGrantBinding;
+	}
+});
+Object.defineProperty(exports, "originHash", {
+	enumerable: true,
+	get: function() {
+		return originHash;
+	}
+});
+Object.defineProperty(exports, "prepareIssueGrant", {
+	enumerable: true,
+	get: function() {
+		return prepareIssueGrant;
+	}
+});
+Object.defineProperty(exports, "prepareRevokeAllGrants", {
+	enumerable: true,
+	get: function() {
+		return prepareRevokeAllGrants;
+	}
+});
+Object.defineProperty(exports, "prepareRevokeGrant", {
+	enumerable: true,
+	get: function() {
+		return prepareRevokeGrant;
+	}
+});
+Object.defineProperty(exports, "scopeArgs", {
+	enumerable: true,
+	get: function() {
+		return scopeArgs;
+	}
+});
+Object.defineProperty(exports, "scopeDigest", {
+	enumerable: true,
+	get: function() {
+		return scopeDigest;
+	}
+});

package/dist/grants-CYY0AquW.js

@@ -0,0 +1,202 @@
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-CziaOsba.js";
+import { B as GrantScopeSalt, V as GrantId, a as zero32, i as granteePoint, n as assertIssueRules, r as circuitScope, z as GrantSlot } from "./grant-rules-qLrKUIR3.js";
+import { g as GrantLimitReachedError } from "./errors-pkQdxW-7.js";
+import { a as pureCircuits } from "./acc-module-ur8CkBd1.js";
+//#region ../../packages/module/passport-account/src/acc/grant-circuits.ts
+/**
+* The gated circuits the grant flows authorise, named once so the flow
+* that submits a call, the authoriser that builds its challenge and the
+* signer that scopes a key session to it agree on the circuit.
+*/
+const ISSUE_GRANT_CIRCUIT = "issue_grant_with_jubjub";
+const REVOKE_GRANT_CIRCUIT = "revoke_grant_with_jubjub";
+const REVOKE_ALL_GRANTS_CIRCUIT = "revoke_all_grants_with_jubjub";
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/grants.ts
+/** Domain tag of the origin hash; it fills its 32-byte pad exactly. */
+const GRANT_ORIGIN_TAG = "midnight:account:grant:origin:v1";
+const ORIGIN_TAG_LENGTH = 32;
+const SCOPE_SALT_LENGTH = 32;
+const GRANT_SLOT_COUNT = 256;
+const SCOPE_ARG_COUNT = 16;
+/** Lays the scope out in the circuit's declaration order. */
+const scopeArgs = (scope) => [
+	scope.opWithdrawUnshielded,
+	scope.opWithdrawShielded,
+	scope.opWithdrawShieldedToContract,
+	scope.read,
+	scope.color,
+	scope.recipientKind,
+	scope.recipient,
+	scope.maxCoinValue,
+	scope.perCallCap,
+	scope.cap,
+	scope.expiresAt,
+	scope.rpIdHash,
+	scope.readPkHash,
+	scope.windowLen,
+	scope.windowCap,
+	{
+		is_some: scope.caller !== void 0,
+		value: { bytes: scope.caller ?? zero32() }
+	}
+];
+/**
+* The salted digest of the plaintext scope, the single element through
+* which the issue challenge binds the whole scope, produced by the
+* contract's own pure circuit.
+*/
+const scopeDigest = (scopeSalt, args) => pureCircuits.derive_grant_scope_digest(scopeSalt, ...args);
+/**
+* The commitment the contract stores for a grant's object: the colour,
+* recipient kind and value, and coin bound of its circuit scope, hidden
+* under the scope salt, as lowercase hex, produced by the contract's own
+* pure circuit.
+*/
+const grantObjectCommit = (scopeSalt, scope) => HexBytes.fromByteArray(pureCircuits.derive_grant_object_commit(scopeSalt, scope.color, scope.recipientKind, scope.recipient, scope.maxCoinValue));
+/**
+* The origin hash that enters a grant id: SHA-256 of the origin tag padded
+* to 32 bytes followed by the raw UTF-8 bytes of the client id. Computed
+* off chain only, so no circuit exports it. For this module the client id
+* is the relying party id of the consumer issuing the grant.
+*/
+const originHash = async (clientId) => {
+	const encoder = new TextEncoder();
+	const tag = new Uint8Array(ORIGIN_TAG_LENGTH);
+	tag.set(encoder.encode(GRANT_ORIGIN_TAG));
+	const client = encoder.encode(clientId);
+	const preimage = new Uint8Array(tag.length + client.length);
+	preimage.set(tag);
+	preimage.set(client, tag.length);
+	return new Uint8Array(await crypto.subtle.digest("SHA-256", preimage));
+};
+/**
+* The identity of a grant: the contract's own commitment to the account,
+* the grantee key, the origin hash and the slot, which keys the record in
+* the grants map.
+*/
+const deriveGrantId = ({ contractAddress, granteePublicKey, originHash: origin, slot }) => GrantId(HexBytes.fromByteArray(pureCircuits.derive_grant_id_with_jubjub({ bytes: contractAddress }, granteePublicKey, origin, BigInt(slot))));
+/**
+* The first slot under which this grantee and origin have no active grant,
+* with the id derived for it. The contract stores neither grantee nor
+* slot, so the slot is found by deriving the id of each candidate and
+* checking it against the roster. A revoked grant leaves a tombstone the
+* contract lets a new grant overwrite, so its slot counts as free.
+*
+* @throws {@link GrantLimitReachedError} when every slot is taken.
+*/
+const findFreeSlot = ({ contractAddress, grantee, originHash: origin, roster }) => {
+	const taken = new Set(roster.filter((record) => record.active).map((record) => record.id));
+	const granteePublicKey = granteePoint(grantee);
+	for (let candidate = 0; candidate < GRANT_SLOT_COUNT; candidate++) {
+		const slot = GrantSlot(candidate);
+		const grantId = deriveGrantId({
+			contractAddress,
+			granteePublicKey,
+			originHash: origin,
+			slot
+		});
+		if (!taken.has(grantId)) return {
+			slot,
+			grantId
+		};
+	}
+	throw new GrantLimitReachedError("Every grant slot of this grantee under this origin is taken.");
+};
+/**
+* Prepares `issue_grant_with_jubjub`: encodes and checks the scope,
+* allocates the grantee's slot, derives the grant id and draws the scope
+* salt. The call's arguments are the grant id, the scope in declaration
+* order and the salt; the authoriser derives the scope digest it signs
+* from those same arguments, and the preparation carries that digest for
+* an authoriser that presents it ahead of the ceremony.
+*
+* @throws {@link GrantScopeInvalidError} when the scope is malformed or
+* breaks an issue rule.
+* @throws {@link GrantLimitReachedError} when the grantee has no free slot.
+*/
+const prepareIssueGrant = ({ contractAddress, scope, originHash: origin, roster, randomBytes = (length) => crypto.getRandomValues(new Uint8Array(length)) }) => {
+	const encoded = circuitScope(scope);
+	assertIssueRules(encoded);
+	const { slot, grantId } = findFreeSlot({
+		contractAddress,
+		grantee: scope.grantee,
+		originHash: origin,
+		roster
+	});
+	const salt = randomBytes(SCOPE_SALT_LENGTH);
+	const args = scopeArgs(encoded);
+	return {
+		grantId,
+		slot,
+		scopeSalt: GrantScopeSalt(HexBytes.fromByteArray(salt)),
+		scopeDigest: HexBytes.fromByteArray(scopeDigest(salt, args)),
+		call: {
+			circuit: ISSUE_GRANT_CIRCUIT,
+			args: [
+				ByteArray.fromHex(HexBytes(grantId)),
+				...args,
+				salt
+			]
+		}
+	};
+};
+/** Prepares `revoke_grant_with_jubjub` over one grant id. */
+const prepareRevokeGrant = (grantId) => ({
+	circuit: REVOKE_GRANT_CIRCUIT,
+	args: [ByteArray.fromHex(HexBytes(grantId))]
+});
+/** Prepares `revoke_all_grants_with_jubjub`, which takes no argument. */
+const prepareRevokeAllGrants = () => ({
+	circuit: REVOKE_ALL_GRANTS_CIRCUIT,
+	args: []
+});
+const SCOPE_ARG_KINDS = [
+	"boolean",
+	"boolean",
+	"boolean",
+	"boolean",
+	"bytes",
+	"bigint",
+	"bytes",
+	"bigint",
+	"bigint",
+	"bigint",
+	"bigint",
+	"bytes",
+	"bytes",
+	"bigint",
+	"bigint",
+	"caller"
+];
+const isCaller = (value) => typeof value === "object" && value !== null && typeof value.is_some === "boolean" && value.value?.bytes instanceof Uint8Array;
+const isScopeArgument = (value, kind) => {
+	switch (kind) {
+		case "boolean": return typeof value === "boolean";
+		case "bigint": return typeof value === "bigint";
+		case "bytes": return value instanceof Uint8Array;
+		case "caller": return isCaller(value);
+	}
+};
+const isScopeArgs = (values) => values.length === SCOPE_ARG_COUNT && values.every((value, index) => isScopeArgument(value, SCOPE_ARG_KINDS[index]));
+/**
+* Reads what the issue challenge binds out of the circuit's argument list
+* as it reaches an authoriser: the grant id and the digest of the scope,
+* derived here from the plaintext arguments and the salt so the signer
+* binds the scope it was shown and nothing else.
+*
+* @throws an Error when the arguments are not a grant id, sixteen scope
+* arguments and a scope salt.
+*/
+const issueGrantBinding = (args) => {
+	const [grantId, ...rest] = args;
+	const scopeSalt = rest.at(-1);
+	const scope = rest.slice(0, -1);
+	if (!(grantId instanceof Uint8Array) || !(scopeSalt instanceof Uint8Array) || !isScopeArgs(scope)) throw new Error(`Circuit ${ISSUE_GRANT_CIRCUIT} expects a grant id, ${SCOPE_ARG_COUNT} scope arguments and a scope salt`);
+	return {
+		grantId,
+		scopeDigest: scopeDigest(scopeSalt, scope)
+	};
+};
+//#endregion
+export { prepareIssueGrant as a, scopeArgs as c, REVOKE_ALL_GRANTS_CIRCUIT as d, REVOKE_GRANT_CIRCUIT as f, originHash as i, scopeDigest as l, grantObjectCommit as n, prepareRevokeAllGrants as o, issueGrantBinding as r, prepareRevokeGrant as s, deriveGrantId as t, ISSUE_GRANT_CIRCUIT as u };

package/dist/grants-DOsFSotP.js

@@ -0,0 +1,4 @@
+import "./_polyfill-buffer-patch-JcrfT1gU.js";
+import { i as granteePoint, n as assertIssueRules, r as circuitScope } from "./grant-rules-qLrKUIR3.js";
+import { a as prepareIssueGrant, c as scopeArgs, i as originHash, l as scopeDigest, n as grantObjectCommit, o as prepareRevokeAllGrants, r as issueGrantBinding, s as prepareRevokeGrant, t as deriveGrantId } from "./grants-CYY0AquW.js";
+export { assertIssueRules, circuitScope, deriveGrantId, grantObjectCommit, granteePoint, issueGrantBinding, originHash, prepareIssueGrant, prepareRevokeAllGrants, prepareRevokeGrant, scopeArgs, scopeDigest };

package/dist/{group-cardano-addresses-by-account-C-1GHUu8.cjs → group-cardano-addresses-by-account-BGOtPV-Y.cjs}

@@ -1,42 +1,12 @@
 const require_chunk = require("./chunk-9hOWP6kD.cjs");
-const require_Address = require("./Address-4KjeDt_x.cjs");
-const require_util = require("./util-P4PX2muj.cjs");
-const require_slice = require("./slice-Bjj2t2ut.cjs");
-const require_activity_type_stable = require("./activity-type.stable-ClO9j_PH.cjs");
-let rxjs = require("rxjs");
+const require_Address = require("./Address-AMKTo-dA.cjs");
+const require_util = require("./util-D1YlKzrc.cjs");
+const require_activity_type = require("./activity-type-BPXxdHBP.cjs");
 let lodash_groupBy = require("lodash/groupBy.js");
 lodash_groupBy = require_chunk.__toESM(lodash_groupBy);
 //#region ../../node_modules/@cardano-sdk/core/dist/esm/util/nativeScript.js
 const nativeScriptPolicyId = (script) => require_Address.PolicyId(require_Address.NativeScript.fromCore(script).hash());
 //#endregion
-//#region ../../packages/contract/failures/src/utils/auto-dismiss-failure-on-success.ts
-/**
-* RxJS operator that auto-dismisses a failure when an operation succeeds.
-*
-* This operator:
-* 1. Takes a failureId observable
-* 2. Checks if the failure exists in the store
-* 3. Only emits dismissFailure action if the failure actually exists
-*
-* This prevents unnecessary action dispatches when a failure has already been dismissed.
-*
-* @param selectFailureById$ - Observable of the selector function to check failure existence
-* @returns RxJS operator that emits dismissFailure actions only when failures exist
-*
-* @example
-* ```typescript
-* // In a side effect:
-* return operation$.pipe(
-*   // ... operation logic ...
-*   map(() => CardanoSyncFailureId('account-123')),
-*   autoDismissFailureOnSuccess(selectFailureById$),
-* );
-* ```
-*/
-const autoDismissFailureOnSuccess = (selectFailureById$) => (source) => source.pipe((0, rxjs.withLatestFrom)(selectFailureById$), (0, rxjs.filter)(([failureId, selectFailureById]) => {
-	return selectFailureById(failureId) !== void 0;
-}), (0, rxjs.map)(([failureId]) => require_slice.failuresActions.failures.dismissFailure(failureId)));
-//#endregion
 //#region ../../packages/contract/cardano-context/src/value-objects/utxo-cache-key.vo.ts
 const compareRewardAccounts = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 const UtxoCacheKey = (params) => `${params.topOnChainActivityId}:${[...params.stakeKeys].sort(compareRewardAccounts).join(",")}:n${params.accountAddressCount}`;
@@ -97,7 +67,7 @@ const extractUniqueStakeKeys = (accountAddresses) => {
 * for consumers that need to refresh on reward arrival (e.g. `rewardsSum`).
 */
 const getTopOnChainActivity = (activitiesByAccount, accountId, includeRewardActivities = false) => {
-	const top = activitiesByAccount[accountId]?.find((activity) => activity.type !== require_activity_type_stable.ActivityType.Pending && (includeRewardActivities || activity.type !== require_activity_type_stable.ActivityType.Rewards));
+	const top = activitiesByAccount[accountId]?.find((activity) => activity.type !== require_activity_type.ActivityType.Pending && (includeRewardActivities || activity.type !== require_activity_type.ActivityType.Rewards));
 	if (!top) return void 0;
 	const cardano = top.blockchainSpecific?.Cardano;
 	return {
@@ -151,12 +121,6 @@ Object.defineProperty(exports, "UtxoCacheKey", {
 		return UtxoCacheKey;
 	}
 });
-Object.defineProperty(exports, "autoDismissFailureOnSuccess", {
-	enumerable: true,
-	get: function() {
-		return autoDismissFailureOnSuccess;
-	}
-});
 Object.defineProperty(exports, "extractUniqueStakeKeys", {
 	enumerable: true,
 	get: function() {

package/dist/{group-cardano-addresses-by-account-p4dXmCoj.js → group-cardano-addresses-by-account-TqvESg9x.js}

@@ -1,41 +1,10 @@
-import "./chunk-D6g4UhsZ.js";
-import { Ft as PolicyId, ut as NativeScript } from "./Address-_VPkf7Xh.js";
-import { _ as CardanoRewardAccount, s as isCardanoAddressOfSupportedNetwork } from "./util-CQSJU0wT.js";
-import { t as failuresActions } from "./slice-B6vPum19.js";
-import { t as ActivityType } from "./activity-type.stable-Ml0SOYv9.js";
-import { filter, map, withLatestFrom } from "rxjs";
-import groupBy$1 from "lodash/groupBy.js";
+import { Vt as PolicyId, mt as NativeScript } from "./Address-_c_-9hLC.js";
+import { _ as CardanoRewardAccount, s as isCardanoAddressOfSupportedNetwork } from "./util-DHxtzUzY.js";
+import { t as ActivityType } from "./activity-type-C1geyPsH.js";
+import groupBy from "lodash/groupBy.js";
 //#region ../../node_modules/@cardano-sdk/core/dist/esm/util/nativeScript.js
 const nativeScriptPolicyId = (script) => PolicyId(NativeScript.fromCore(script).hash());
 //#endregion
-//#region ../../packages/contract/failures/src/utils/auto-dismiss-failure-on-success.ts
-/**
-* RxJS operator that auto-dismisses a failure when an operation succeeds.
-*
-* This operator:
-* 1. Takes a failureId observable
-* 2. Checks if the failure exists in the store
-* 3. Only emits dismissFailure action if the failure actually exists
-*
-* This prevents unnecessary action dispatches when a failure has already been dismissed.
-*
-* @param selectFailureById$ - Observable of the selector function to check failure existence
-* @returns RxJS operator that emits dismissFailure actions only when failures exist
-*
-* @example
-* ```typescript
-* // In a side effect:
-* return operation$.pipe(
-*   // ... operation logic ...
-*   map(() => CardanoSyncFailureId('account-123')),
-*   autoDismissFailureOnSuccess(selectFailureById$),
-* );
-* ```
-*/
-const autoDismissFailureOnSuccess = (selectFailureById$) => (source) => source.pipe(withLatestFrom(selectFailureById$), filter(([failureId, selectFailureById]) => {
-	return selectFailureById(failureId) !== void 0;
-}), map(([failureId]) => failuresActions.failures.dismissFailure(failureId)));
-//#endregion
 //#region ../../packages/contract/cardano-context/src/value-objects/utxo-cache-key.vo.ts
 const compareRewardAccounts = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 const UtxoCacheKey = (params) => `${params.topOnChainActivityId}:${[...params.stakeKeys].sort(compareRewardAccounts).join(",")}:n${params.accountAddressCount}`;
@@ -141,7 +110,7 @@ const getAccountAddresses = (addresses, accountId, chainId) => filterCardanoAddr
 *          associated with those accounts.
 */
 const groupCardanoAddressesByAccount = (addresses, chainId) => {
-	return groupBy$1(filterCardanoAddressesForNetwork(addresses, chainId), (addr) => addr.accountId);
+	return groupBy(filterCardanoAddressesForNetwork(addresses, chainId), (addr) => addr.accountId);
 };
 //#endregion
-export { extractUniqueStakeKeys as a, nativeScriptPolicyId as c, getTopOnChainActivity as i, getAccountAddresses as n, UtxoCacheKey as o, groupCardanoAddressesByAccount as r, autoDismissFailureOnSuccess as s, filterCardanoAddressesForNetwork as t };
+export { extractUniqueStakeKeys as a, getTopOnChainActivity as i, getAccountAddresses as n, UtxoCacheKey as o, groupCardanoAddressesByAccount as r, nativeScriptPolicyId as s, filterCardanoAddressesForNetwork as t };

package/dist/{guarded-transaction-signer-DZSGHp1K.js → guarded-transaction-signer-BbVDE9Nn.js}

@@ -1,13 +1,16 @@
 import "./chunk-D6g4UhsZ.js";
 import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-JcrfT1gU.js";
-import { Ot as CborWriter, f as Transaction, n as AddressType, p as TxCBOR, qt as HexBlob, r as CredentialType, t as Address } from "./Address-_VPkf7Xh.js";
-import { t as Ed25519PublicKey } from "./Ed25519PublicKey-CjnuAYRR.js";
-import { t as SodiumBip32Ed25519 } from "./SodiumBip32Ed25519-BEfo1Q9m.js";
-import { a as isRewardAccount } from "./PaymentAddress-xSmGUQ-8.js";
-import { a as KeyRole, i as KeyPurpose } from "./types-B61DQoFW.js";
-import { a as HexBytes, i as ByteArray, n as createTxInKeyPathMap, o as SecretBox, t as InMemoryKeyAgent } from "./InMemoryKeyAgent-D-3HejxN.js";
-import { i as getPaymentCredential, l as outpointKey, t as createInputResolver } from "./util-CQSJU0wT.js";
-import { t as applyVkeyWitnesses } from "./apply-vkey-witnesses-Dfo7XfhL.js";
+import { Mt as CborWriter, m as TxCBOR, n as AddressType, p as Transaction, r as CredentialType, t as Address, tn as HexBlob } from "./Address-_c_-9hLC.js";
+import { t as SodiumBip32Ed25519 } from "./SodiumBip32Ed25519-DCikAMsl.js";
+import { t as Ed25519PublicKey } from "./Ed25519PublicKey-DIE19xHg.js";
+import { a as isRewardAccount } from "./PaymentAddress-Cml3EA1n.js";
+import { a as KeyRole, i as KeyPurpose } from "./types-By-XeXWg.js";
+import { n as createTxInKeyPathMap, t as InMemoryKeyAgent } from "./InMemoryKeyAgent-D8T3vtXy.js";
+import { t as SecretBox } from "./secret-box-CSmRp6Tt.js";
+import { i as getPaymentCredential, l as outpointKey, t as createInputResolver } from "./util-DHxtzUzY.js";
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-CziaOsba.js";
+import { t as applyVkeyWitnesses } from "./apply-vkey-witnesses-Byb40-yJ.js";
+import { t as AuthenticationCancelledError } from "./types-DTE1ctDB.js";
 import { catchError, from, switchMap, throwError } from "rxjs";
 import { dummyLogger } from "ts-log";
 //#region ../../packages/lib/core/src/key-hash.ts
@@ -64,15 +67,6 @@ var CollateralOwnershipError = class extends Error {
 	}
 };
 //#endregion
-//#region ../../packages/contract/signer/src/types.ts
-/** Thrown when the user cancels the authentication prompt during signing. */
-var AuthenticationCancelledError = class extends Error {
-	constructor() {
-		super("Authentication cancelled by user");
-		this.name = "AuthenticationCancelledError";
-	}
-};
-//#endregion
 //#region ../../packages/contract/cardano-context/src/signing/cip8-sign-data.ts
 init__polyfill_buffer_patch();
 /**
@@ -431,4 +425,4 @@ const withCollateralOwnershipGuard = (signer, context) => ({ sign: (request) =>
 	})()).pipe(catchError(() => throwError(() => new CollateralOwnershipError(REFUSE_ON_FAILURE)))).pipe(switchMap((refusal) => refusal ? throwError(() => new CollateralOwnershipError(refusal)) : signer.sign(request)));
 } });
 //#endregion
-export { CardanoInMemoryTransactionSigner as a, deriveDRepKeyHash as i, createCardanoKeyAgentFromEncryptedRoot as n, CardanoInMemoryDataSigner as o, createCardanoKeyAgentFromMnemonic as r, withCollateralOwnershipGuard as t };
+export { CardanoInMemoryTransactionSigner as a, deriveDRepKeyHash as i, createCardanoKeyAgentFromEncryptedRoot as n, CardanoInMemoryDataSigner as o, createCardanoKeyAgentFromMnemonic as r, hashEd25519PublicKey as s, withCollateralOwnershipGuard as t };