@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/grant-spend-B3Md9L0n.js

@@ -0,0 +1,215 @@
+import "./_polyfill-buffer-patch-yNxN4d5E.js";
+import "./codecs-Dc1Krpbt.js";
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-BB7_4JK6.js";
+import { L as sha256, w as GrantSpendRefusedError } from "./errors-DSq5wUwt.js";
+import { W as GrantSlot, a as zero32, i as granteePoint, t as RECIPIENT_KINDS } from "./grant-rules-By07_eDi.js";
+import { a as grantWithdrawalCircuit } from "./grant-circuits-Jxb5y1HW.js";
+import { a as pureCircuits } from "./acc-module-Cmj8EsIb.js";
+import { a as originHash, n as deriveGrantId, t as K256_GRANT_ENVELOPE } from "./grants-CtofFu-e.js";
+//#region ../../packages/module/passport-account/src/acc/grant-spend-challenges.ts
+/** The grantee's secp256k1 point, read from the key its policy carries. */
+const k256Point = (publicKey) => {
+	return granteePoint({
+		scheme: "secp256k1-ecdsa",
+		publicKey
+	}).point;
+};
+/** The grantee's jubjub point, read from the key its policy carries. */
+const jubjubPoint = (publicKey) => {
+	return granteePoint({
+		scheme: "jubjub-schnorr",
+		publicKey
+	}).point;
+};
+const address = (context) => ({ bytes: context.contractAddress });
+const coinOf = ({ coin }) => ({
+	nonce: coin.nonce,
+	color: coin.color,
+	value: coin.value,
+	mt_index: coin.mtIndex
+});
+/**
+* The challenge builders of the grant withdrawals, for both grantee
+* schemes. The preimage layout is the contract's own: each builder calls
+* the pure circuit the withdrawal recomputes its challenge with, over the
+* account address, the grantee key, the grant id and issue time, the
+* withdrawal's arguments in declaration order and the record's nonce,
+* with the announcement and grind nonce first and last on the jubjub arm.
+* A shielded challenge also binds the change entry, the encryption key
+* and the held coin the withdrawal spends.
+*/
+const grantSpendChallenges = {
+	"secp256k1-ecdsa": {
+		"withdraw-unshielded": (context, withdrawal) => pureCircuits.challenge_withdraw_unshielded_with_grant_k256(address(context), k256Point(context.granteePublicKey), context.grantId, context.issuedAt, withdrawal.color, withdrawal.amount, { bytes: withdrawal.recipient }, context.nonce),
+		"withdraw-shielded": (context, withdrawal) => pureCircuits.challenge_withdraw_shielded_with_grant_k256(address(context), k256Point(context.granteePublicKey), context.grantId, context.issuedAt, { bytes: withdrawal.recipient }, withdrawal.color, withdrawal.amount, withdrawal.changeEntry, withdrawal.encPublicKey, coinOf(withdrawal), context.nonce),
+		"withdraw-shielded-to-contract": (context, withdrawal) => pureCircuits.challenge_withdraw_shielded_to_contract_with_grant_k256(address(context), k256Point(context.granteePublicKey), context.grantId, context.issuedAt, { bytes: withdrawal.recipient }, withdrawal.color, withdrawal.amount, withdrawal.changeEntry, withdrawal.encPublicKey, coinOf(withdrawal), context.nonce)
+	},
+	"jubjub-schnorr": {
+		"withdraw-unshielded": (context, withdrawal) => {
+			const pk = jubjubPoint(context.granteePublicKey);
+			return (sigR, grindNonce) => pureCircuits.challenge_withdraw_unshielded_with_grant_jubjub(address(context), sigR, pk, context.grantId, context.issuedAt, withdrawal.color, withdrawal.amount, { bytes: withdrawal.recipient }, context.nonce, grindNonce);
+		},
+		"withdraw-shielded": (context, withdrawal) => {
+			const pk = jubjubPoint(context.granteePublicKey);
+			return (sigR, grindNonce) => pureCircuits.challenge_withdraw_shielded_with_grant_jubjub(address(context), sigR, pk, context.grantId, context.issuedAt, { bytes: withdrawal.recipient }, withdrawal.color, withdrawal.amount, withdrawal.changeEntry, withdrawal.encPublicKey, coinOf(withdrawal), context.nonce, grindNonce);
+		},
+		"withdraw-shielded-to-contract": (context, withdrawal) => {
+			const pk = jubjubPoint(context.granteePublicKey);
+			return (sigR, grindNonce) => pureCircuits.challenge_withdraw_shielded_to_contract_with_grant_jubjub(address(context), sigR, pk, context.grantId, context.issuedAt, { bytes: withdrawal.recipient }, withdrawal.color, withdrawal.amount, withdrawal.changeEntry, withdrawal.encPublicKey, coinOf(withdrawal), context.nonce, grindNonce);
+		}
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/grant-spend.ts
+/** The recipient kind each withdrawal pays, which a pinned grant must name. */
+const PAID_RECIPIENT_KINDS = {
+	"withdraw-unshielded": "user-address",
+	"withdraw-shielded": "coin-public-key",
+	"withdraw-shielded-to-contract": "contract-address"
+};
+const refuse = (reason) => {
+	throw new GrantSpendRefusedError(`The grant does not allow this spend: ${reason}.`);
+};
+const bytesOf = (hex) => ByteArray.fromHex(HexBytes(hex));
+/**
+* Checks a spend against the grant's scope as its policy states it, in
+* the contract's order, so a spend the contract would refuse is caught
+* before it is signed and proved. Expiry is checked against this
+* machine's clock, which the contract checks again against the block's.
+*/
+const assertSpendAllowed = (policy, spend) => {
+	const { expiresAt } = policy;
+	if (expiresAt !== null && Math.floor(Date.now() / 1e3) >= expiresAt) refuse(`it expired at ${expiresAt}`);
+	if (!policy.operations.includes(spend.operation)) refuse(`${spend.operation} is not in its scope`);
+	if (spend.amount > BigInt(policy.perCallCap)) refuse(`${spend.amount} is above the per-call cap ${policy.perCallCap}`);
+	if (spend.spent + spend.amount > BigInt(policy.cap)) refuse(`${spend.amount} after ${spend.spent} spent exceeds the cap ${policy.cap}`);
+	const { recipient } = policy;
+	if (recipient.kind !== "any") {
+		if (recipient.kind !== PAID_RECIPIENT_KINDS[spend.operation]) refuse(`it pins a ${recipient.kind} recipient, which ${spend.operation} does not pay`);
+		if (HexBytes.fromByteArray(spend.recipient) !== recipient.value) refuse("the recipient is not the one it pins");
+	}
+	if (spend.operation !== "withdraw-unshielded") {
+		if (HexBytes.fromByteArray(spend.coin.color) !== policy.color) refuse("the coin is not of its colour");
+		if (spend.coin.value > BigInt(policy.maxCoinValue)) refuse(`the coin of ${spend.coin.value} is above its coin bound ${policy.maxCoinValue}`);
+		if (spend.coin.value < spend.amount) refuse(`the coin of ${spend.coin.value} cannot pay the amount ${spend.amount}`);
+	}
+};
+/** The withdrawal's own arguments, in the circuit's declaration order. */
+const withdrawalArgs = (spend, color) => spend.operation === "withdraw-unshielded" ? [
+	color,
+	spend.amount,
+	{ bytes: spend.recipient }
+] : [
+	{ bytes: spend.recipient },
+	color,
+	spend.amount,
+	spend.changeEntry,
+	spend.encPublicKey
+];
+const k256Challenge = (context, spend, color) => {
+	const builders = grantSpendChallenges["secp256k1-ecdsa"];
+	switch (spend.operation) {
+		case "withdraw-unshielded": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+		case "withdraw-shielded": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+		case "withdraw-shielded-to-contract": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+	}
+};
+const jubjubChallenge = (context, spend, color) => {
+	const builders = grantSpendChallenges["jubjub-schnorr"];
+	switch (spend.operation) {
+		case "withdraw-unshielded": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+		case "withdraw-shielded": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+		case "withdraw-shielded-to-contract": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+	}
+};
+/**
+* Prepares a spend under the grant a policy describes: checks it against
+* the grant's scope, checks that the policy's grant id derives from its
+* account, grantee key, origin and slot, and returns the withdrawal
+* circuit, its arguments up to the signature and the challenge to sign.
+* The arguments carry the grantee key, the origin hash, the slot, the
+* scope salt and the object fields the contract opens its commitments
+* with, and on the secp256k1 arm the plain ECDSA envelope.
+*
+* @throws {@link GrantSpendRefusedError} when the grant does not allow
+* the spend, or the policy's grant id is not its own.
+*/
+const prepareGrantSpend = async (policy, spend) => {
+	assertSpendAllowed(policy, spend);
+	const contractAddress = bytesOf(policy.account);
+	const grantee = granteePoint({
+		scheme: policy.granteeScheme,
+		publicKey: policy.granteePublicKey
+	});
+	const origin = await originHash(policy.origin);
+	const grantId = deriveGrantId({
+		contractAddress,
+		granteePublicKey: grantee,
+		originHash: origin,
+		slot: GrantSlot(policy.slot)
+	});
+	if (grantId !== policy.grantId) refuse(`its id ${policy.grantId} does not derive from the policy's account, grantee, origin and slot`);
+	const color = bytesOf(policy.color);
+	const context = {
+		contractAddress,
+		granteePublicKey: policy.granteePublicKey,
+		grantId: bytesOf(grantId),
+		issuedAt: spend.issuedAt,
+		nonce: spend.nonce
+	};
+	const scopeArgs = [
+		origin,
+		BigInt(policy.slot),
+		bytesOf(policy.scopeSalt),
+		RECIPIENT_KINDS[policy.recipient.kind],
+		policy.recipient.kind === "any" ? zero32() : bytesOf(policy.recipient.value),
+		BigInt(policy.maxCoinValue),
+		spend.spent
+	];
+	const circuit = grantWithdrawalCircuit(policy.granteeScheme, spend.operation);
+	if (grantee.scheme === "secp256k1-ecdsa") {
+		const challenge = k256Challenge(context, spend, color);
+		return {
+			scheme: grantee.scheme,
+			circuit,
+			args: [
+				...withdrawalArgs(spend, color),
+				grantee.point,
+				K256_GRANT_ENVELOPE,
+				...scopeArgs
+			],
+			challenge,
+			digest: sha256(challenge)
+		};
+	}
+	return {
+		scheme: grantee.scheme,
+		circuit,
+		args: [
+			...withdrawalArgs(spend, color),
+			grantee.point,
+			...scopeArgs
+		],
+		challenge: jubjubChallenge(context, spend, color)
+	};
+};
+//#endregion
+export { grantSpendChallenges, prepareGrantSpend };

package/dist/grant-spend-oWmzRsjH.cjs

@@ -0,0 +1,217 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+require("./codecs-Cswkg7Tm.cjs");
+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");
+const require_grants = require("./grants-BoI5uwSF.cjs");
+//#region ../../packages/module/passport-account/src/acc/grant-spend-challenges.ts
+/** The grantee's secp256k1 point, read from the key its policy carries. */
+const k256Point = (publicKey) => {
+	return require_grant_rules.granteePoint({
+		scheme: "secp256k1-ecdsa",
+		publicKey
+	}).point;
+};
+/** The grantee's jubjub point, read from the key its policy carries. */
+const jubjubPoint = (publicKey) => {
+	return require_grant_rules.granteePoint({
+		scheme: "jubjub-schnorr",
+		publicKey
+	}).point;
+};
+const address = (context) => ({ bytes: context.contractAddress });
+const coinOf = ({ coin }) => ({
+	nonce: coin.nonce,
+	color: coin.color,
+	value: coin.value,
+	mt_index: coin.mtIndex
+});
+/**
+* The challenge builders of the grant withdrawals, for both grantee
+* schemes. The preimage layout is the contract's own: each builder calls
+* the pure circuit the withdrawal recomputes its challenge with, over the
+* account address, the grantee key, the grant id and issue time, the
+* withdrawal's arguments in declaration order and the record's nonce,
+* with the announcement and grind nonce first and last on the jubjub arm.
+* A shielded challenge also binds the change entry, the encryption key
+* and the held coin the withdrawal spends.
+*/
+const grantSpendChallenges = {
+	"secp256k1-ecdsa": {
+		"withdraw-unshielded": (context, withdrawal) => require_acc_module.pureCircuits.challenge_withdraw_unshielded_with_grant_k256(address(context), k256Point(context.granteePublicKey), context.grantId, context.issuedAt, withdrawal.color, withdrawal.amount, { bytes: withdrawal.recipient }, context.nonce),
+		"withdraw-shielded": (context, withdrawal) => require_acc_module.pureCircuits.challenge_withdraw_shielded_with_grant_k256(address(context), k256Point(context.granteePublicKey), context.grantId, context.issuedAt, { bytes: withdrawal.recipient }, withdrawal.color, withdrawal.amount, withdrawal.changeEntry, withdrawal.encPublicKey, coinOf(withdrawal), context.nonce),
+		"withdraw-shielded-to-contract": (context, withdrawal) => require_acc_module.pureCircuits.challenge_withdraw_shielded_to_contract_with_grant_k256(address(context), k256Point(context.granteePublicKey), context.grantId, context.issuedAt, { bytes: withdrawal.recipient }, withdrawal.color, withdrawal.amount, withdrawal.changeEntry, withdrawal.encPublicKey, coinOf(withdrawal), context.nonce)
+	},
+	"jubjub-schnorr": {
+		"withdraw-unshielded": (context, withdrawal) => {
+			const pk = jubjubPoint(context.granteePublicKey);
+			return (sigR, grindNonce) => require_acc_module.pureCircuits.challenge_withdraw_unshielded_with_grant_jubjub(address(context), sigR, pk, context.grantId, context.issuedAt, withdrawal.color, withdrawal.amount, { bytes: withdrawal.recipient }, context.nonce, grindNonce);
+		},
+		"withdraw-shielded": (context, withdrawal) => {
+			const pk = jubjubPoint(context.granteePublicKey);
+			return (sigR, grindNonce) => require_acc_module.pureCircuits.challenge_withdraw_shielded_with_grant_jubjub(address(context), sigR, pk, context.grantId, context.issuedAt, { bytes: withdrawal.recipient }, withdrawal.color, withdrawal.amount, withdrawal.changeEntry, withdrawal.encPublicKey, coinOf(withdrawal), context.nonce, grindNonce);
+		},
+		"withdraw-shielded-to-contract": (context, withdrawal) => {
+			const pk = jubjubPoint(context.granteePublicKey);
+			return (sigR, grindNonce) => require_acc_module.pureCircuits.challenge_withdraw_shielded_to_contract_with_grant_jubjub(address(context), sigR, pk, context.grantId, context.issuedAt, { bytes: withdrawal.recipient }, withdrawal.color, withdrawal.amount, withdrawal.changeEntry, withdrawal.encPublicKey, coinOf(withdrawal), context.nonce, grindNonce);
+		}
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/grant-spend.ts
+/** The recipient kind each withdrawal pays, which a pinned grant must name. */
+const PAID_RECIPIENT_KINDS = {
+	"withdraw-unshielded": "user-address",
+	"withdraw-shielded": "coin-public-key",
+	"withdraw-shielded-to-contract": "contract-address"
+};
+const refuse = (reason) => {
+	throw new require_errors.GrantSpendRefusedError(`The grant does not allow this spend: ${reason}.`);
+};
+const bytesOf = (hex) => require_bytes_vo.ByteArray.fromHex(require_bytes_vo.HexBytes(hex));
+/**
+* Checks a spend against the grant's scope as its policy states it, in
+* the contract's order, so a spend the contract would refuse is caught
+* before it is signed and proved. Expiry is checked against this
+* machine's clock, which the contract checks again against the block's.
+*/
+const assertSpendAllowed = (policy, spend) => {
+	const { expiresAt } = policy;
+	if (expiresAt !== null && Math.floor(Date.now() / 1e3) >= expiresAt) refuse(`it expired at ${expiresAt}`);
+	if (!policy.operations.includes(spend.operation)) refuse(`${spend.operation} is not in its scope`);
+	if (spend.amount > BigInt(policy.perCallCap)) refuse(`${spend.amount} is above the per-call cap ${policy.perCallCap}`);
+	if (spend.spent + spend.amount > BigInt(policy.cap)) refuse(`${spend.amount} after ${spend.spent} spent exceeds the cap ${policy.cap}`);
+	const { recipient } = policy;
+	if (recipient.kind !== "any") {
+		if (recipient.kind !== PAID_RECIPIENT_KINDS[spend.operation]) refuse(`it pins a ${recipient.kind} recipient, which ${spend.operation} does not pay`);
+		if (require_bytes_vo.HexBytes.fromByteArray(spend.recipient) !== recipient.value) refuse("the recipient is not the one it pins");
+	}
+	if (spend.operation !== "withdraw-unshielded") {
+		if (require_bytes_vo.HexBytes.fromByteArray(spend.coin.color) !== policy.color) refuse("the coin is not of its colour");
+		if (spend.coin.value > BigInt(policy.maxCoinValue)) refuse(`the coin of ${spend.coin.value} is above its coin bound ${policy.maxCoinValue}`);
+		if (spend.coin.value < spend.amount) refuse(`the coin of ${spend.coin.value} cannot pay the amount ${spend.amount}`);
+	}
+};
+/** The withdrawal's own arguments, in the circuit's declaration order. */
+const withdrawalArgs = (spend, color) => spend.operation === "withdraw-unshielded" ? [
+	color,
+	spend.amount,
+	{ bytes: spend.recipient }
+] : [
+	{ bytes: spend.recipient },
+	color,
+	spend.amount,
+	spend.changeEntry,
+	spend.encPublicKey
+];
+const k256Challenge = (context, spend, color) => {
+	const builders = grantSpendChallenges["secp256k1-ecdsa"];
+	switch (spend.operation) {
+		case "withdraw-unshielded": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+		case "withdraw-shielded": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+		case "withdraw-shielded-to-contract": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+	}
+};
+const jubjubChallenge = (context, spend, color) => {
+	const builders = grantSpendChallenges["jubjub-schnorr"];
+	switch (spend.operation) {
+		case "withdraw-unshielded": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+		case "withdraw-shielded": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+		case "withdraw-shielded-to-contract": return builders[spend.operation](context, {
+			...spend,
+			color
+		});
+	}
+};
+/**
+* Prepares a spend under the grant a policy describes: checks it against
+* the grant's scope, checks that the policy's grant id derives from its
+* account, grantee key, origin and slot, and returns the withdrawal
+* circuit, its arguments up to the signature and the challenge to sign.
+* The arguments carry the grantee key, the origin hash, the slot, the
+* scope salt and the object fields the contract opens its commitments
+* with, and on the secp256k1 arm the plain ECDSA envelope.
+*
+* @throws {@link GrantSpendRefusedError} when the grant does not allow
+* the spend, or the policy's grant id is not its own.
+*/
+const prepareGrantSpend = async (policy, spend) => {
+	assertSpendAllowed(policy, spend);
+	const contractAddress = bytesOf(policy.account);
+	const grantee = require_grant_rules.granteePoint({
+		scheme: policy.granteeScheme,
+		publicKey: policy.granteePublicKey
+	});
+	const origin = await require_grants.originHash(policy.origin);
+	const grantId = require_grants.deriveGrantId({
+		contractAddress,
+		granteePublicKey: grantee,
+		originHash: origin,
+		slot: require_grant_rules.GrantSlot(policy.slot)
+	});
+	if (grantId !== policy.grantId) refuse(`its id ${policy.grantId} does not derive from the policy's account, grantee, origin and slot`);
+	const color = bytesOf(policy.color);
+	const context = {
+		contractAddress,
+		granteePublicKey: policy.granteePublicKey,
+		grantId: bytesOf(grantId),
+		issuedAt: spend.issuedAt,
+		nonce: spend.nonce
+	};
+	const scopeArgs = [
+		origin,
+		BigInt(policy.slot),
+		bytesOf(policy.scopeSalt),
+		require_grant_rules.RECIPIENT_KINDS[policy.recipient.kind],
+		policy.recipient.kind === "any" ? require_grant_rules.zero32() : bytesOf(policy.recipient.value),
+		BigInt(policy.maxCoinValue),
+		spend.spent
+	];
+	const circuit = require_grant_circuits.grantWithdrawalCircuit(policy.granteeScheme, spend.operation);
+	if (grantee.scheme === "secp256k1-ecdsa") {
+		const challenge = k256Challenge(context, spend, color);
+		return {
+			scheme: grantee.scheme,
+			circuit,
+			args: [
+				...withdrawalArgs(spend, color),
+				grantee.point,
+				require_grants.K256_GRANT_ENVELOPE,
+				...scopeArgs
+			],
+			challenge,
+			digest: require_errors.sha256(challenge)
+		};
+	}
+	return {
+		scheme: grantee.scheme,
+		circuit,
+		args: [
+			...withdrawalArgs(spend, color),
+			grantee.point,
+			...scopeArgs
+		],
+		challenge: jubjubChallenge(context, spend, color)
+	};
+};
+//#endregion
+exports.grantSpendChallenges = grantSpendChallenges;
+exports.prepareGrantSpend = prepareGrantSpend;