@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/grants-2BZ-qEVQ.js

@@ -0,0 +1,5 @@
+import "./_polyfill-buffer-patch-yNxN4d5E.js";
+import "./codecs-Dc1Krpbt.js";
+import { i as granteePoint, n as assertIssueRules, r as circuitScope } from "./grant-rules-By07_eDi.js";
+import { a as originHash, c as prepareRevokeGrant, i as issueGrantBinding, l as scopeArgs, n as deriveGrantId, o as prepareIssueGrant, r as grantObjectCommit, s as prepareRevokeAllGrants, t as K256_GRANT_ENVELOPE, u as scopeDigest } from "./grants-CtofFu-e.js";
+export { K256_GRANT_ENVELOPE, assertIssueRules, circuitScope, deriveGrantId, grantObjectCommit, granteePoint, issueGrantBinding, originHash, prepareIssueGrant, prepareRevokeAllGrants, prepareRevokeGrant, scopeArgs, scopeDigest };

package/dist/grants-BPoLSiMt.cjs

@@ -0,0 +1,18 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+require("./codecs-Cswkg7Tm.cjs");
+const require_grant_rules = require("./grant-rules-BzVTWXS7.cjs");
+const require_grants = require("./grants-BoI5uwSF.cjs");
+exports.K256_GRANT_ENVELOPE = require_grants.K256_GRANT_ENVELOPE;
+exports.assertIssueRules = require_grant_rules.assertIssueRules;
+exports.circuitScope = require_grant_rules.circuitScope;
+exports.deriveGrantId = require_grants.deriveGrantId;
+exports.grantObjectCommit = require_grants.grantObjectCommit;
+exports.granteePoint = require_grant_rules.granteePoint;
+exports.issueGrantBinding = require_grants.issueGrantBinding;
+exports.originHash = require_grants.originHash;
+exports.prepareIssueGrant = require_grants.prepareIssueGrant;
+exports.prepareRevokeAllGrants = require_grants.prepareRevokeAllGrants;
+exports.prepareRevokeGrant = require_grants.prepareRevokeGrant;
+exports.scopeArgs = require_grants.scopeArgs;
+exports.scopeDigest = require_grants.scopeDigest;

package/dist/grants-BoI5uwSF.cjs

@@ -0,0 +1,272 @@
+const require_bytes_vo = require("./bytes.vo-BNRquqaO.cjs");
+const require_errors = require("./errors-BIftM8ZN.cjs");
+const require_grant_rules = require("./grant-rules-BzVTWXS7.cjs");
+const require_grant_circuits = require("./grant-circuits-DswmW3nI.cjs");
+const require_acc_module = require("./acc-module-4iIUv6My.cjs");
+//#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;
+/**
+* The signature envelope a secp256k1 grant is bound to: plain ECDSA over
+* the SHA-256 digest of the challenge, the only envelope the contract
+* admits for a spend grant.
+*/
+const K256_GRANT_ENVELOPE = 0n;
+/** 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));
+};
+/** A grant id from the bytes a derivation circuit returns. */
+const grantIdOf = (id) => require_grant_rules.GrantId(require_bytes_vo.HexBytes.fromByteArray(id));
+/**
+* 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. Each grantee scheme has its own derivation, and a
+* secp256k1 grant also binds its signature envelope, so the same key
+* bytes never name the same grant under two schemes or two envelopes.
+*/
+const deriveGrantId = ({ contractAddress, granteePublicKey, originHash: origin, slot }) => {
+	const self = { bytes: contractAddress };
+	switch (granteePublicKey.scheme) {
+		case "jubjub-schnorr": return grantIdOf(require_acc_module.pureCircuits.derive_grant_id_with_jubjub(self, granteePublicKey.point, origin, BigInt(slot)));
+		case "secp256k1-ecdsa": return grantIdOf(require_acc_module.pureCircuits.derive_grant_id_with_k256(self, granteePublicKey.point, K256_GRANT_ENVELOPE, origin, BigInt(slot)));
+		default: {
+			const unhandled = granteePublicKey;
+			throw new require_errors.GrantScopeInvalidError(`unsupported grantee scheme "${String(unhandled.scheme)}"`);
+		}
+	}
+};
+/**
+* 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: require_grant_circuits.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: require_grant_circuits.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: require_grant_circuits.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 ${require_grant_circuits.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, "K256_GRANT_ENVELOPE", {
+	enumerable: true,
+	get: function() {
+		return K256_GRANT_ENVELOPE;
+	}
+});
+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-CtofFu-e.js

@@ -0,0 +1,213 @@
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-BB7_4JK6.js";
+import { C as GrantScopeInvalidError, g as GrantLimitReachedError } from "./errors-DSq5wUwt.js";
+import { G as GrantScopeSalt, K as GrantId, W as GrantSlot, a as zero32, i as granteePoint, n as assertIssueRules, r as circuitScope } from "./grant-rules-By07_eDi.js";
+import { i as REVOKE_GRANT_CIRCUIT, n as ISSUE_GRANT_CIRCUIT, r as REVOKE_ALL_GRANTS_CIRCUIT } from "./grant-circuits-Jxb5y1HW.js";
+import { a as pureCircuits } from "./acc-module-Cmj8EsIb.js";
+//#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;
+/**
+* The signature envelope a secp256k1 grant is bound to: plain ECDSA over
+* the SHA-256 digest of the challenge, the only envelope the contract
+* admits for a spend grant.
+*/
+const K256_GRANT_ENVELOPE = 0n;
+/** 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));
+};
+/** A grant id from the bytes a derivation circuit returns. */
+const grantIdOf = (id) => GrantId(HexBytes.fromByteArray(id));
+/**
+* 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. Each grantee scheme has its own derivation, and a
+* secp256k1 grant also binds its signature envelope, so the same key
+* bytes never name the same grant under two schemes or two envelopes.
+*/
+const deriveGrantId = ({ contractAddress, granteePublicKey, originHash: origin, slot }) => {
+	const self = { bytes: contractAddress };
+	switch (granteePublicKey.scheme) {
+		case "jubjub-schnorr": return grantIdOf(pureCircuits.derive_grant_id_with_jubjub(self, granteePublicKey.point, origin, BigInt(slot)));
+		case "secp256k1-ecdsa": return grantIdOf(pureCircuits.derive_grant_id_with_k256(self, granteePublicKey.point, K256_GRANT_ENVELOPE, origin, BigInt(slot)));
+		default: {
+			const unhandled = granteePublicKey;
+			throw new GrantScopeInvalidError(`unsupported grantee scheme "${String(unhandled.scheme)}"`);
+		}
+	}
+};
+/**
+* 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 { originHash as a, prepareRevokeGrant as c, issueGrantBinding as i, scopeArgs as l, deriveGrantId as n, prepareIssueGrant as o, grantObjectCommit as r, prepareRevokeAllGrants as s, K256_GRANT_ENVELOPE as t, scopeDigest as u };

package/dist/{group-cardano-addresses-by-account-B533oVXR.cjs → group-cardano-addresses-by-account-Bp0g4wEY.cjs}

@@ -1,38 +1,8 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_util = require("./util-CGzqQ8IV.cjs");
-const require_slice = require("./slice-DZmQJNV8.cjs");
-const require_activity_type_stable = require("./activity-type.stable-BJEfeLxL.cjs");
-let rxjs = require("rxjs");
+const require_util = require("./util-Bu4W5lF4.cjs");
+const require_activity_type = require("./activity-type-Ch6ljxBy.cjs");
 let lodash_groupBy = require("lodash/groupBy.js");
 lodash_groupBy = require_rolldown_runtime.__toESM(lodash_groupBy);
-//#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}`;
@@ -79,7 +49,7 @@ UtxoCacheKey.topOnChainActivityId = (key) => key?.split(":")[0];
 * 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 {
@@ -133,12 +103,6 @@ Object.defineProperty(exports, "UtxoCacheKey", {
 		return UtxoCacheKey;
 	}
 });
-Object.defineProperty(exports, "autoDismissFailureOnSuccess", {
-	enumerable: true,
-	get: function() {
-		return autoDismissFailureOnSuccess;
-	}
-});
 Object.defineProperty(exports, "filterCardanoAddressesForNetwork", {
 	enumerable: true,
 	get: function() {

package/dist/{group-cardano-addresses-by-account-RHKoEskR.js → group-cardano-addresses-by-account-SR8MMrZf.js}

@@ -1,36 +1,6 @@
-import { s as isCardanoAddressOfSupportedNetwork } from "./util-BaLzwa32.js";
-import { t as failuresActions } from "./slice-CobanYgn.js";
-import { t as ActivityType } from "./activity-type.stable-C76_hWd7.js";
-import { filter, map, withLatestFrom } from "rxjs";
-import groupBy$1 from "lodash/groupBy.js";
-//#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
+import { s as isCardanoAddressOfSupportedNetwork } from "./util-Cp5cZkfK.js";
+import { t as ActivityType } from "./activity-type-GsJGWs-3.js";
+import groupBy from "lodash/groupBy.js";
 //#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}`;
@@ -122,7 +92,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 { UtxoCacheKey as a, getTopOnChainActivity as i, getAccountAddresses as n, autoDismissFailureOnSuccess as o, groupCardanoAddressesByAccount as r, filterCardanoAddressesForNetwork as t };
+export { UtxoCacheKey as a, getTopOnChainActivity as i, getAccountAddresses as n, groupCardanoAddressesByAccount as r, filterCardanoAddressesForNetwork as t };