@ocap/tx-protocols 1.28.9 → 1.29.1

package/esm/protocols/rollup/claim-reward.d.mts

@@ -0,0 +1,11 @@
+//#region src/protocols/rollup/claim-reward.d.ts
+/** Token change for updates */
+interface TokenChange {
+  address: string;
+  token: string;
+  delta: string;
+  action: string;
+}
+declare const runner: any;
+//#endregion
+export { TokenChange, runner as default };

package/esm/protocols/rollup/claim-reward.mjs

@@ -0,0 +1,322 @@
+import { RATE_BASE, applyTokenChange, getBNSum, getRewardLocker, splitTxFee } from "../../util.mjs";
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import ensure_validator_default from "./pipes/ensure-validator.mjs";
+import verify_signers_default from "./pipes/verify-signers.mjs";
+import verify_status_default from "./pipes/verify-status.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { toStakeAddress } from "@arcblock/did-util";
+import { account, evidence, rollupBlock, stake } from "@ocap/state";
+import { BN } from "@ocap/util";
+import Debug from "debug";
+import cloneDeep from "lodash/cloneDeep.js";
+import groupBy from "lodash/groupBy.js";
+import { Joi, patterns } from "@arcblock/validator";
+import uniqBy from "lodash/uniqBy.js";
+
+//#region src/protocols/rollup/claim-reward.ts
+const debug = Debug("@ocap/tx-protocols:claim-block-reward");
+const runner = new Runner("claim_block_reward");
+const schema = Joi.object({
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	blockHeight: Joi.number().integer().greater(0).required(),
+	blockHash: Joi.string().regex(patterns.txHash).required(),
+	evidence: Joi.object({ hash: Joi.string().regex(patterns.txHash).required() }).required(),
+	publisher: Joi.DID().prefix().wallet("ethereum").required(),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use((context, next) => {
+	const { tx: tx$1, itx } = context;
+	const { error } = schema.validate(itx);
+	if (error) return next(new CustomError("INVALID_TX", error.message));
+	if (tx$1.from !== itx.publisher) return next(new CustomError("INVALID_TX", "itx.publisher must be same with tx.from"));
+	context.lockerAddress = getRewardLocker(itx.rollup);
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "itx.evidence.hash",
+	to: "evidenceSeen",
+	status: "OK",
+	table: "evidence"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.blockHash",
+	to: "blockClaimed",
+	status: "OK",
+	table: "evidence"
+}));
+runner.use(({ evidenceSeen, blockClaimed }, next) => {
+	if (evidenceSeen) return next(new CustomError("INVALID_TX", "Claim evidence already seen on this chain"));
+	if (blockClaimed) return next(new CustomError("INVALID_TX", "Block reward already claimed before this tx"));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "itx.rollup",
+	to: "rollupState",
+	status: "INVALID_ROLLUP",
+	table: "rollup"
+}));
+runner.use(ensure_validator_default(false));
+runner.use(verify_status_default({ closed: false }));
+runner.use(pipes.ExtractState({
+	from: "itx.blockHash",
+	to: "blockState",
+	status: "INVALID_ROLLUP_BLOCK",
+	table: "rollupBlock"
+}));
+runner.use((context, next) => {
+	const { blockState, rollupState, itx } = context;
+	if (blockState.rollup !== rollupState.address) return next(new CustomError("INVALID_TX", "Rollup block belonging does not match"));
+	if (blockState.height !== itx.blockHeight) return next(new CustomError("INVALID_TX", "Rollup block height does not match"));
+	if (blockState.proposer !== itx.publisher) {
+		const proposedAt = +new Date(blockState.context.genesisTime);
+		const publishedAt = +new Date(context.txTime);
+		if (proposedAt + rollupState.publishWaitingPeriod * 1e3 > publishedAt) return next(new CustomError("INVALID_TX", "Rollup block can only be published by producer during waiting period"));
+	}
+	context.producerStakeAddress = toStakeAddress(blockState.proposer, itx.rollup);
+	return next();
+});
+runner.use(verify_signers_default({
+	signersKey: "tx.signaturesList",
+	allowSender: true
+}));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use(pipes.ExtractState({
+	from: "lockerAddress",
+	to: "lockerState",
+	status: "INVALID_LOCKER_STATE",
+	table: "stake"
+}));
+runner.use(pipes.ExtractState({
+	from: "producerStakeAddress",
+	to: "stakeState",
+	status: "INVALID_STAKE_STATE",
+	table: "stake"
+}));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "signers",
+	to: "signerStates",
+	status: "INVALID_SIGNER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(pipes.ExtractState({
+	from: "rollupState.tokenAddress",
+	to: "tokenState",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(pipes.ExtractState({
+	from: "blockState.txs",
+	to: "txs",
+	status: "INVALID_TX",
+	table: "tx"
+}));
+runner.use((context, next) => {
+	const { itx, txs, rollupState, blockState, lockerState, tokenState, stakeState } = context;
+	const { proposerFeeShare, publisherFeeShare } = rollupState;
+	const shares = {
+		publisher: publisherFeeShare,
+		proposer: proposerFeeShare,
+		validator: 1e4 - publisherFeeShare - proposerFeeShare
+	};
+	const changes = {
+		account: [],
+		stake: []
+	};
+	if (blockState.proposer !== itx.publisher) {
+		const slashAmount = new BN(rollupState.minStakeAmount).mul(new BN(rollupState.publishSlashRate)).div(RATE_BASE);
+		const slashShare = slashAmount.div(new BN(2));
+		changes.stake.push({
+			address: stakeState.address,
+			delta: `-${slashAmount.toString(10)}`,
+			action: "slash"
+		});
+		changes.stake.push({
+			address: lockerState.address,
+			delta: slashShare.toString(10),
+			action: "slash"
+		});
+		changes.account.push({
+			address: itx.publisher,
+			delta: slashShare.toString(10),
+			action: "reward"
+		});
+	}
+	(txs || []).forEach((x) => {
+		const txData = x.tx;
+		const { actualFee } = txData.itxJson;
+		const { publisher, proposer, validator } = splitTxFee({
+			total: actualFee,
+			shares,
+			stringify: false
+		});
+		changes.stake.push({
+			address: lockerState.address,
+			delta: `-${actualFee}`,
+			action: "claim"
+		});
+		changes.account.push({
+			address: itx.publisher,
+			delta: publisher.toString(10),
+			action: "fee"
+		});
+		if (x.type === "deposit_token_v2") {
+			const txItxJson = txData.itxJson;
+			changes.account.push({
+				address: txItxJson.proposer,
+				delta: proposer.toString(10),
+				action: "fee"
+			});
+			const txSignatures = txData.signatures;
+			const blockSignatures = blockState.signatures;
+			const validators = txSignatures.map((s) => s.signer).concat(blockSignatures.map((s) => s.signer));
+			const validatorShare = validator.div(new BN(validators.length));
+			validators.forEach((v) => changes.account.push({
+				address: v,
+				delta: validatorShare.toString(10),
+				action: "fee"
+			}));
+		} else if (x.type === "withdraw_token_v2") {
+			changes.account.push({
+				address: blockState.proposer,
+				delta: proposer.toString(10),
+				action: "fee"
+			});
+			const validators = blockState.signatures.map((s) => s.signer);
+			const validatorShares = splitTxFee({
+				total: validator.toString(10),
+				shares: validators.reduce((acc, signer) => {
+					acc[signer] = 1;
+					return acc;
+				}, {}),
+				rateBase: new BN(validators.length)
+			});
+			Object.keys(validatorShares).forEach((v) => changes.account.push({
+				address: v,
+				delta: validatorShares[v],
+				action: "fee"
+			}));
+		}
+	});
+	const grouped = {
+		account: groupBy(changes.account, "address"),
+		stake: groupBy(changes.stake, "address")
+	};
+	const updates = {
+		stake: Object.keys(grouped.stake).reduce((acc, x) => {
+			acc[x] = {
+				address: x,
+				token: tokenState.address,
+				delta: getBNSum(...grouped.stake[x].map((c) => c.delta)),
+				action: grouped.stake[x][grouped.stake[x].length - 1].action
+			};
+			return acc;
+		}, {}),
+		account: Object.keys(grouped.account).reduce((acc, x) => {
+			acc[x] = {
+				address: x,
+				token: tokenState.address,
+				delta: getBNSum(...grouped.account[x].map((c) => c.delta)),
+				action: grouped.account[x][grouped.account[x].length - 1].action
+			};
+			return acc;
+		}, {})
+	};
+	context.changes = changes;
+	context.updates = updates;
+	return next();
+});
+runner.use((context, next) => {
+	const { updates, senderState, signerStates } = context;
+	const requiredAccounts = Object.keys(updates.account);
+	const knownAccounts = { [senderState.address]: senderState };
+	(signerStates || []).forEach((x) => knownAccounts[x.address] = x);
+	context.missingAccounts = requiredAccounts.filter((x) => !knownAccounts[x]);
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "missingAccounts",
+	to: "missingAccountStates",
+	status: "INVALID_SIGNER_STATE",
+	table: "account"
+}));
+runner.use((context, next) => {
+	const { senderState, signerStates, missingAccountStates } = context;
+	context.accountStates = uniqBy([
+		senderState,
+		...signerStates || [],
+		...missingAccountStates || []
+	], "address");
+	return next();
+});
+runner.use(ensure_gas_default((context) => {
+	const result = {
+		create: 2,
+		update: 1,
+		payment: 0
+	};
+	result.update += context.accountStates?.length || 0;
+	if (context.updates?.stake[context.lockerState.address]) result.update += 1;
+	if (context.updates?.stake[context.stakeState.address]) result.update += 1;
+	return result;
+}));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, itx, updates, statedb, senderState, blockState, lockerState, stakeState, accountStates, senderChange, updateVaults } = context;
+	const stakeUpdates = updates.stake;
+	const accountUpdates = updates.account;
+	const [newStakeStates, newAccountStates, newBlockState] = await Promise.all([
+		Promise.all([lockerState, stakeState].map((x) => stakeUpdates[x.address] ? statedb.stake.update(x.address, stake.update(x, applyTokenChange(x, stakeUpdates[x.address]), context), context) : x)),
+		Promise.all((accountStates || []).map((x) => {
+			if (accountUpdates[x.address]) {
+				let updateSet = applyTokenChange(x, accountUpdates[x.address]);
+				if (x.address === senderState.address) {
+					updateSet.nonce = tx$1.nonce;
+					updateSet = Object.assign(updateSet, senderChange ? applyTokenChange(updateSet, senderChange) : {});
+				}
+				return statedb.account.update(x.address, account.update(x, updateSet, context), context);
+			}
+			return x;
+		})),
+		statedb.rollupBlock.update(blockState.hash, rollupBlock.update(blockState, context), context),
+		statedb.evidence.create(itx.evidence.hash, evidence.create({
+			hash: itx.evidence.hash,
+			data: "rollup-claim-block-reward"
+		}, context), context),
+		statedb.evidence.create(itx.blockHash, evidence.create({
+			hash: itx.blockHash,
+			data: "rollup-claim-block-reward"
+		}, context), context)
+	]);
+	if (updateVaults) await updateVaults();
+	delete context.stakeState;
+	context.stakeStates = newStakeStates.filter((x) => stakeUpdates[x.address]);
+	context.accountStates = newAccountStates;
+	context.blockState = newBlockState;
+	context.updatedAccounts = context.updatedAccounts || [];
+	context.updatedAccounts.push(...cloneDeep(Object.values(accountUpdates)));
+	context.updatedAccounts.push(...cloneDeep(Object.values(stakeUpdates)));
+	debug("claim-block-reward", itx);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var claim_reward_default = runner;
+
+//#endregion
+export { claim_reward_default as default };

package/esm/protocols/rollup/close.d.mts

@@ -0,0 +1,4 @@
+//#region src/protocols/rollup/close.d.ts
+declare const runner: any;
+//#endregion
+export { runner as default };

package/esm/protocols/rollup/close.mjs

@@ -0,0 +1,105 @@
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import ensure_validator_default from "./pipes/ensure-validator.mjs";
+import verify_signers_default from "./pipes/verify-signers.mjs";
+import verify_status_default from "./pipes/verify-status.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { toStakeAddress } from "@arcblock/did-util";
+import { account, rollup, stake } from "@ocap/state";
+import { Joi } from "@arcblock/validator";
+
+//#region src/protocols/rollup/close.ts
+const runner = new Runner("close_rollup");
+const schema = Joi.object({
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	message: Joi.string().trim().min(1).max(512).required(),
+	token: Joi.object({
+		address: Joi.DID().prefix().wallet("ethereum").required(),
+		value: Joi.BN().positive().required()
+	}),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use(({ itx }, next) => {
+	const { error } = schema.validate(itx);
+	return next(error ? new CustomError("INVALID_TX", `Invalid itx: ${error.message}`) : void 0);
+});
+runner.use(pipes.ExtractState({
+	from: "itx.rollup",
+	to: "rollupState",
+	status: "INVALID_ROLLUP",
+	table: "rollup"
+}));
+runner.use(ensure_validator_default(true));
+runner.use(verify_status_default({
+	paused: true,
+	closed: false
+}));
+runner.use(verify_signers_default({
+	signersKey: "tx.signaturesList",
+	allowSender: true
+}));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "signers",
+	to: "signerStates",
+	status: "INVALID_SIGNER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use((context, next) => {
+	const { validators, address } = context.rollupState;
+	context.stakeAddresses = validators.map((x) => toStakeAddress(x.address, address));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "stakeAddresses",
+	to: "stakeStates",
+	status: "INVALID_STAKE_STATE",
+	table: "stake"
+}));
+runner.use(ensure_gas_default((context) => ({
+	create: 0,
+	update: (context.stakeStates || []).length + 2,
+	payment: 0
+})));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, itx, statedb, senderUpdates, updateVaults, rollupState, senderState } = context;
+	const stakeStates = context.stakeStates || [];
+	const [newSenderState, newRollupState, newStakeStates] = await Promise.all([
+		statedb.account.update(senderState.address, account.update(senderState, {
+			nonce: tx$1.nonce,
+			...senderUpdates
+		}, context), context),
+		statedb.rollup.update(itx.rollup, rollup.close(rollupState, context), context),
+		Promise.all(stakeStates.map((x) => statedb.stake.update(x.address, stake.update(x, {
+			revocable: true,
+			revokeWaitingPeriod: rollupState.leaveWaitingPeriod
+		}, context), context)))
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.rollupState = newRollupState;
+	context.stakeStates = newStakeStates;
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var close_default = runner;
+
+//#endregion
+export { close_default as default };

package/esm/protocols/rollup/create-block.d.mts

@@ -0,0 +1,11 @@
+//#region src/protocols/rollup/create-block.d.ts
+/** Token change for updates */
+interface TokenChange {
+  address: string;
+  token: string;
+  delta: string;
+  action?: string;
+}
+declare const runner: any;
+//#endregion
+export { TokenChange, runner as default };