@ocap/state 1.28.9 → 1.29.1

package/lib/states/chain.d.cts

@@ -0,0 +1,30 @@
+import { StateContext } from "../contexts/state.cjs";
+
+//#region src/states/chain.d.ts
+declare namespace chain_d_exports {
+  export { ChainState, create, update };
+}
+interface ChainState {
+  address?: string;
+  chainId?: string;
+  version?: string;
+  transaction?: unknown;
+  moderator?: unknown;
+  accounts?: unknown;
+  token?: {
+    symbol?: string;
+    decimal?: number;
+    name?: string;
+    description?: string;
+    unit?: string;
+    totalSupply?: string;
+    initialSupply?: string;
+    foreignToken?: unknown;
+  };
+  vaults?: unknown;
+  context: StateContext;
+}
+declare const create: (attrs: Partial<ChainState>) => ChainState;
+declare const update: (state: ChainState, updates: Partial<ChainState>) => ChainState;
+//#endregion
+export { ChainState, chain_d_exports, create, update };

package/lib/states/delegation.cjs

@@ -0,0 +1,50 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_contexts_state = require('../contexts/state.cjs');
+const require_util = require('../util.cjs');
+let _ocap_util = require("@ocap/util");
+let lodash_pick = require("lodash/pick");
+lodash_pick = require_rolldown_runtime.__toESM(lodash_pick);
+
+//#region src/states/delegation.ts
+var delegation_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	create: () => create,
+	update: () => update
+});
+const create = (attrs, context) => {
+	const delegation = {
+		context: require_contexts_state.create(context),
+		...(0, lodash_pick.default)(attrs, [
+			"address",
+			"to",
+			"from",
+			"ops",
+			"data"
+		])
+	};
+	if (!delegation.data) delegation.data = null;
+	delegation.address = (0, _ocap_util.toAddress)(delegation.address);
+	delegation.ops = require_util.nullify(delegation.ops);
+	return delegation;
+};
+const update = (state, attrs, context) => {
+	const delegation = {
+		...state,
+		...(0, lodash_pick.default)(attrs, ["ops", "data"]),
+		context: require_contexts_state.update(state.context, context)
+	};
+	if (!delegation.data) delegation.data = null;
+	if (!state.to && attrs.to) delegation.to = (0, _ocap_util.toAddress)(attrs.to);
+	if (!state.from && attrs.from) delegation.from = (0, _ocap_util.toAddress)(attrs.from);
+	delegation.ops = require_util.nullify(delegation.ops);
+	return delegation;
+};
+
+//#endregion
+exports.create = create;
+Object.defineProperty(exports, 'delegation_exports', {
+  enumerable: true,
+  get: function () {
+    return delegation_exports;
+  }
+});
+exports.update = update;

package/lib/states/delegation.d.cts

@@ -0,0 +1,11 @@
+import { StateContextInput } from "../contexts/state.cjs";
+import { IDelegateState } from "@ocap/types";
+
+//#region src/states/delegation.d.ts
+declare namespace delegation_d_exports {
+  export { create, update };
+}
+declare const create: (attrs: Partial<IDelegateState>, context: StateContextInput) => IDelegateState;
+declare const update: (state: IDelegateState, attrs: Partial<IDelegateState>, context: StateContextInput) => IDelegateState;
+//#endregion
+export { create, delegation_d_exports, update };

package/lib/states/evidence.cjs

@@ -0,0 +1,44 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_contexts_state = require('../contexts/state.cjs');
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let lodash_pick = require("lodash/pick");
+lodash_pick = require_rolldown_runtime.__toESM(lodash_pick);
+let _arcblock_validator = require("@arcblock/validator");
+
+//#region src/states/evidence.ts
+var evidence_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	create: () => create,
+	schema: () => schema,
+	validate: () => validate
+});
+const schema = _arcblock_validator.Joi.object({
+	hash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
+	context: _arcblock_validator.schemas.context,
+	data: _arcblock_validator.Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const create = (attrs, context) => {
+	return validate({
+		context: require_contexts_state.create(context),
+		...(0, lodash_pick.default)(attrs, ["hash", "data"])
+	});
+};
+const validate = (state) => {
+	const { value, error } = schema.validate(state);
+	if (error) throw new _ocap_util_lib_error.CustomError("INVALID_EVIDENCE", `Invalid evidence state: ${error.details.map((x) => x.message).join(", ")}`);
+	if (!value.data) value.data = null;
+	return value;
+};
+
+//#endregion
+exports.create = create;
+Object.defineProperty(exports, 'evidence_exports', {
+  enumerable: true,
+  get: function () {
+    return evidence_exports;
+  }
+});
+exports.schema = schema;
+exports.validate = validate;

package/lib/states/evidence.d.cts

@@ -0,0 +1,12 @@
+import { StateContextInput } from "../contexts/state.cjs";
+import { IEvidenceState } from "@ocap/types";
+
+//#region src/states/evidence.d.ts
+declare namespace evidence_d_exports {
+  export { create, schema, validate };
+}
+declare const schema: any;
+declare const create: (attrs: Partial<IEvidenceState>, context: StateContextInput) => IEvidenceState;
+declare const validate: (state: IEvidenceState) => IEvidenceState;
+//#endregion
+export { create, evidence_d_exports, schema, validate };

package/lib/states/factory.cjs

@@ -0,0 +1,85 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_contexts_state = require('../contexts/state.cjs');
+let _ocap_util = require("@ocap/util");
+let lodash_pick = require("lodash/pick");
+lodash_pick = require_rolldown_runtime.__toESM(lodash_pick);
+let _arcblock_validator = require("@arcblock/validator");
+let _ocap_contract = require("@ocap/contract");
+
+//#region src/states/factory.ts
+var factory_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	create: () => create,
+	update: () => update,
+	validate: () => validate
+});
+const stateSchema = _arcblock_validator.Joi.object({
+	..._arcblock_validator.schemas.factoryProps,
+	owner: _arcblock_validator.Joi.DID().prefix().required(),
+	numMinted: _arcblock_validator.Joi.number().min(0).default(0),
+	lastSettlement: _arcblock_validator.Joi.date().iso().raw().allow(""),
+	tokens: _arcblock_validator.Joi.object().pattern(_arcblock_validator.Joi.DID().prefix().role("ROLE_TOKEN"), _arcblock_validator.Joi.BN().min(0)).default({}),
+	context: _arcblock_validator.schemas.context
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const compileHook = (hook) => {
+	if (hook.type === "contract") hook.compiled = (0, _ocap_contract.merge)((0, _ocap_contract.compile)(hook.hook));
+	return hook;
+};
+const create = (attrs, context) => {
+	const factory = {
+		numMinted: 0,
+		lastSettlement: "",
+		tokens: {},
+		context: require_contexts_state.create(context),
+		...(0, lodash_pick.default)(attrs, [
+			"address",
+			"owner",
+			"name",
+			"description",
+			"settlement",
+			"limit",
+			"tokens",
+			"trustedIssuers",
+			"input",
+			"output",
+			"display",
+			"hooks",
+			"data"
+		])
+	};
+	if (!factory.data) factory.data = null;
+	(0, _ocap_contract.getQuota)(factory.input);
+	factory.hooks = (factory.hooks || []).map((x) => compileHook(x));
+	factory.address = (0, _ocap_util.toAddress)(factory.address);
+	return validate(factory);
+};
+const update = (state, attrs, context) => {
+	const factory = {
+		...state,
+		...(0, lodash_pick.default)(attrs, ["numMinted", "tokens"]),
+		context: require_contexts_state.update(state.context, context)
+	};
+	if (factory.output?.tags === null) factory.output.tags = [];
+	return validate(factory);
+};
+const validate = (state) => {
+	const { value, error } = stateSchema.validate(state);
+	if (error) throw new Error(`Invalid factory: ${error.details.map((x) => x.message).join(", ")}`);
+	["display"].forEach((key) => {
+		if (!value[key]) delete value[key];
+	});
+	return value;
+};
+
+//#endregion
+exports.create = create;
+Object.defineProperty(exports, 'factory_exports', {
+  enumerable: true,
+  get: function () {
+    return factory_exports;
+  }
+});
+exports.update = update;
+exports.validate = validate;

package/lib/states/factory.d.cts

@@ -0,0 +1,12 @@
+import { StateContextInput } from "../contexts/state.cjs";
+import { IAssetFactoryState } from "@ocap/types";
+
+//#region src/states/factory.d.ts
+declare namespace factory_d_exports {
+  export { create, update, validate };
+}
+declare const create: (attrs: Partial<IAssetFactoryState>, context: StateContextInput) => IAssetFactoryState;
+declare const update: (state: IAssetFactoryState, attrs: Partial<IAssetFactoryState>, context: StateContextInput) => IAssetFactoryState;
+declare const validate: (state: IAssetFactoryState) => IAssetFactoryState;
+//#endregion
+export { create, factory_d_exports, update, validate };

package/lib/states/rollup-block.cjs

@@ -0,0 +1,85 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_contexts_state = require('../contexts/state.cjs');
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let lodash_pick = require("lodash/pick");
+lodash_pick = require_rolldown_runtime.__toESM(lodash_pick);
+let _arcblock_validator = require("@arcblock/validator");
+
+//#region src/states/rollup-block.ts
+var rollup_block_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	create: () => create,
+	schema: () => schema,
+	update: () => update,
+	validate: () => validate
+});
+const schema = _arcblock_validator.Joi.object({
+	hash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
+	height: _arcblock_validator.Joi.number().integer().greater(0).required(),
+	merkleRoot: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
+	previousHash: _arcblock_validator.Joi.string().when("height", {
+		is: 1,
+		then: _arcblock_validator.Joi.string().optional().allow(null).allow(""),
+		otherwise: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required()
+	}),
+	txsHash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
+	txs: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required()).min(1).unique().required(),
+	proposer: _arcblock_validator.Joi.DID().prefix().wallet("ethereum").required(),
+	signatures: _arcblock_validator.schemas.multiSig.min(1).required(),
+	rollup: _arcblock_validator.Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	mintedAmount: _arcblock_validator.Joi.BN().min(0).optional().allow(null).default("0"),
+	burnedAmount: _arcblock_validator.Joi.BN().min(0).optional().allow(null).default("0"),
+	rewardAmount: _arcblock_validator.Joi.BN().min(0).optional().allow(null).default("0"),
+	minReward: _arcblock_validator.Joi.BN().min(0).required(),
+	governance: _arcblock_validator.Joi.boolean().default(false),
+	context: _arcblock_validator.schemas.context,
+	data: _arcblock_validator.Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const create = (attrs, context) => {
+	return validate({
+		context: require_contexts_state.create(context),
+		...(0, lodash_pick.default)(attrs, [
+			"hash",
+			"height",
+			"merkleRoot",
+			"previousHash",
+			"txsHash",
+			"txs",
+			"proposer",
+			"signatures",
+			"rollup",
+			"mintedAmount",
+			"burnedAmount",
+			"rewardAmount",
+			"minReward",
+			"governance",
+			"data"
+		])
+	});
+};
+const update = (state, context) => {
+	return validate({
+		...state,
+		context: require_contexts_state.update(state.context, context)
+	});
+};
+const validate = (state) => {
+	const { value, error } = schema.validate(state);
+	if (error) throw new _ocap_util_lib_error.CustomError("INVALID_ROLLUP_BLOCK", `Invalid rollup block: ${error.details.map((x) => x.message).join(", ")}`);
+	if (!value.data) value.data = null;
+	return value;
+};
+
+//#endregion
+exports.create = create;
+Object.defineProperty(exports, 'rollup_block_exports', {
+  enumerable: true,
+  get: function () {
+    return rollup_block_exports;
+  }
+});
+exports.schema = schema;
+exports.update = update;
+exports.validate = validate;

package/lib/states/rollup-block.d.cts

@@ -0,0 +1,13 @@
+import { StateContextInput } from "../contexts/state.cjs";
+import { IRollupBlock } from "@ocap/types";
+
+//#region src/states/rollup-block.d.ts
+declare namespace rollup_block_d_exports {
+  export { create, schema, update, validate };
+}
+declare const schema: any;
+declare const create: (attrs: Partial<IRollupBlock>, context: StateContextInput) => IRollupBlock;
+declare const update: (state: IRollupBlock, context: StateContextInput) => IRollupBlock;
+declare const validate: (state: IRollupBlock) => IRollupBlock;
+//#endregion
+export { create, rollup_block_d_exports, schema, update, validate };

package/lib/states/rollup.cjs

@@ -0,0 +1,230 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_contexts_state = require('../contexts/state.cjs');
+let _ocap_util = require("@ocap/util");
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let lodash_pick = require("lodash/pick");
+lodash_pick = require_rolldown_runtime.__toESM(lodash_pick);
+let _arcblock_validator = require("@arcblock/validator");
+
+//#region src/states/rollup.ts
+var rollup_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	close: () => close,
+	create: () => create,
+	migrateContract: () => migrateContract,
+	migrateVault: () => migrateVault,
+	pause: () => pause,
+	resume: () => resume,
+	schema: () => schema,
+	update: () => update,
+	validate: () => validate
+});
+const validator = _arcblock_validator.Joi.object({
+	pk: _arcblock_validator.Joi.string().required(),
+	address: _arcblock_validator.Joi.DID().prefix().required(),
+	endpoint: _arcblock_validator.Joi.string().uri({ scheme: [/https?/] }).required()
+});
+const schema = _arcblock_validator.Joi.object({
+	address: _arcblock_validator.Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	tokenAddress: _arcblock_validator.Joi.DID().prefix().role("ROLE_TOKEN").required(),
+	contractAddress: _arcblock_validator.Joi.DID().prefix().wallet("ethereum").required(),
+	vaultAddress: _arcblock_validator.Joi.DID().wallet("ethereum").optional().allow(null).allow(""),
+	migrateHistory: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.DID().prefix().wallet("ethereum")).default([]),
+	vaultHistory: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.DID().prefix().wallet("ethereum")).default([]),
+	paused: _arcblock_validator.Joi.boolean().default(false),
+	closed: _arcblock_validator.Joi.boolean().default(false),
+	seedValidators: _arcblock_validator.Joi.array().items(validator).min(1).required(),
+	validators: _arcblock_validator.Joi.array().items(validator).max(24).default([]),
+	minStakeAmount: _arcblock_validator.Joi.BN().positive().required(),
+	maxStakeAmount: _arcblock_validator.Joi.BN().min(_arcblock_validator.Joi.ref("minStakeAmount")).required(),
+	minSignerCount: _arcblock_validator.Joi.number().integer().min(_arcblock_validator.Joi.ref("seedValidators", { adjust: (v) => v.length })).required(),
+	maxSignerCount: _arcblock_validator.Joi.number().integer().min(1).max(8).min(_arcblock_validator.Joi.ref("minSignerCount")).required(),
+	minBlockSize: _arcblock_validator.Joi.number().integer().min(1).required(),
+	maxBlockSize: _arcblock_validator.Joi.number().integer().min(1).max(15).min(_arcblock_validator.Joi.ref("minBlockSize")).required(),
+	minBlockInterval: _arcblock_validator.Joi.number().integer().min(1).max(3600).required(),
+	minBlockConfirmation: _arcblock_validator.Joi.number().integer().min(1).max(100).required(),
+	minDepositAmount: _arcblock_validator.Joi.BN().positive().less(_arcblock_validator.Joi.ref("minStakeAmount")).required(),
+	maxDepositAmount: _arcblock_validator.Joi.BN().greater(_arcblock_validator.Joi.ref("minDepositAmount")).less(_arcblock_validator.Joi.ref("minStakeAmount")).required(),
+	minWithdrawAmount: _arcblock_validator.Joi.BN().positive().required(),
+	maxWithdrawAmount: _arcblock_validator.Joi.BN().greater(_arcblock_validator.Joi.ref("minWithdrawAmount")).required(),
+	depositFeeRate: _arcblock_validator.Joi.number().integer().min(0).max(1e4).required(),
+	withdrawFeeRate: _arcblock_validator.Joi.number().integer().min(0).max(1e4).required(),
+	proposerFeeShare: _arcblock_validator.Joi.number().integer().min(1).max(1e4).required(),
+	publisherFeeShare: _arcblock_validator.Joi.number().integer().min(1).max(1e4).required(),
+	minDepositFee: _arcblock_validator.Joi.BN().positive().required(),
+	maxDepositFee: _arcblock_validator.Joi.BN().min(_arcblock_validator.Joi.ref("minDepositFee")).required(),
+	minWithdrawFee: _arcblock_validator.Joi.BN().positive().required(),
+	maxWithdrawFee: _arcblock_validator.Joi.BN().min(_arcblock_validator.Joi.ref("minWithdrawFee")).required(),
+	blockHeight: _arcblock_validator.Joi.number().integer().min(0).required(),
+	blockHash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).optional().allow(null).allow(""),
+	issuer: _arcblock_validator.Joi.DID().prefix().optional().allow(null),
+	leaveWaitingPeriod: _arcblock_validator.Joi.number().integer().min(_arcblock_validator.Joi.ref("minBlockInterval")).default(0),
+	publishWaitingPeriod: _arcblock_validator.Joi.number().integer().min(_arcblock_validator.Joi.ref("minBlockInterval")).default(0),
+	publishSlashRate: _arcblock_validator.Joi.number().integer().min(1).max(1e4).required(),
+	context: _arcblock_validator.schemas.context,
+	data: _arcblock_validator.Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const create = (attrs, context) => {
+	const rollup = {
+		context: require_contexts_state.create(context),
+		paused: false,
+		closed: false,
+		migrateHistory: [],
+		vaultHistory: [],
+		blockHeight: 0,
+		blockHash: "",
+		...(0, lodash_pick.default)(attrs, [
+			"address",
+			"tokenAddress",
+			"vaultAddress",
+			"contractAddress",
+			"seedValidators",
+			"validators",
+			"minStakeAmount",
+			"maxStakeAmount",
+			"minSignerCount",
+			"maxSignerCount",
+			"minBlockSize",
+			"maxBlockSize",
+			"minBlockInterval",
+			"minBlockConfirmation",
+			"minDepositAmount",
+			"maxDepositAmount",
+			"minWithdrawAmount",
+			"maxWithdrawAmount",
+			"depositFeeRate",
+			"withdrawFeeRate",
+			"proposerFeeShare",
+			"publisherFeeShare",
+			"minDepositFee",
+			"maxDepositFee",
+			"minWithdrawFee",
+			"maxWithdrawFee",
+			"leaveWaitingPeriod",
+			"publishWaitingPeriod",
+			"publishSlashRate",
+			"issuer",
+			"data"
+		])
+	};
+	rollup.address = (0, _ocap_util.toAddress)(rollup.address);
+	return validate(rollup);
+};
+const update = (state, updates, context) => {
+	if (updates.blockHeight && !updates.blockHash) throw new _ocap_util_lib_error.CustomError("INVALID_ROLLUP_UPDATE", "blockHash must be updated together with blockHeight");
+	if (updates.blockHash && !updates.blockHeight) throw new _ocap_util_lib_error.CustomError("INVALID_ROLLUP_UPDATE", "blockHeight must be updated together with blockHash");
+	if (updates.blockHeight && updates.blockHash) {
+		if (updates.blockHeight !== state.blockHeight + 1) throw new _ocap_util_lib_error.CustomError("INVALID_ROLLUP_UPDATE", "blockHeight must be incremented");
+		if (updates.blockHash === state.blockHash) throw new _ocap_util_lib_error.CustomError("INVALID_ROLLUP_UPDATE", "blockHash can not remain unchanged between blocks");
+	}
+	if (typeof updates.blockHeight !== "undefined" && !updates.blockHeight) throw new _ocap_util_lib_error.CustomError("INVALID_ROLLUP_UPDATE", "blockHeight can not be unset");
+	if (typeof updates.blockHash !== "undefined" && !updates.blockHash) throw new _ocap_util_lib_error.CustomError("INVALID_ROLLUP_UPDATE", "blockHash can not be unset");
+	return validate({
+		...state,
+		...(0, lodash_pick.default)(updates, [
+			"validators",
+			"minStakeAmount",
+			"maxStakeAmount",
+			"minSignerCount",
+			"maxSignerCount",
+			"minBlockSize",
+			"maxBlockSize",
+			"minBlockInterval",
+			"minBlockConfirmation",
+			"minDepositAmount",
+			"maxDepositAmount",
+			"minWithdrawAmount",
+			"maxWithdrawAmount",
+			"depositFeeRate",
+			"withdrawFeeRate",
+			"publisherFeeShare",
+			"minDepositFee",
+			"maxDepositFee",
+			"minWithdrawFee",
+			"maxWithdrawFee",
+			"blockHeight",
+			"blockHash",
+			"leaveWaitingPeriod",
+			"publishWaitingPeriod",
+			"publishSlashRate",
+			"data"
+		]),
+		context: require_contexts_state.update(state.context, context)
+	});
+};
+const pause = (state, context) => {
+	if (state.closed) throw new _ocap_util_lib_error.CustomError("INVALID_PAUSE_ATTEMPT", "rollup already closed");
+	if (state.paused) throw new _ocap_util_lib_error.CustomError("INVALID_PAUSE_ATTEMPT", "rollup already paused");
+	return validate({
+		...state,
+		paused: true,
+		context: require_contexts_state.update(state.context, context)
+	});
+};
+const close = (state, context) => {
+	if (state.closed) throw new _ocap_util_lib_error.CustomError("INVALID_CLOSE_ATTEMPT", "rollup already closed");
+	if (!state.paused) throw new _ocap_util_lib_error.CustomError("INVALID_CLOSE_ATTEMPT", "rollup must be paused");
+	return validate({
+		...state,
+		closed: true,
+		context: require_contexts_state.update(state.context, context)
+	});
+};
+const resume = (state, context) => {
+	if (state.closed) throw new _ocap_util_lib_error.CustomError("INVALID_RESUME_ATTEMPT", "rollup is closed");
+	if (state.paused === false) throw new _ocap_util_lib_error.CustomError("INVALID_RESUME_ATTEMPT", "rollup not paused");
+	return validate({
+		...state,
+		paused: false,
+		context: require_contexts_state.update(state.context, context)
+	});
+};
+const migrateContract = (state, to, context) => {
+	if (state.closed) throw new _ocap_util_lib_error.CustomError("INVALID_MIGRATE_ATTEMPT", "rollup is closed");
+	if (state.paused === false) throw new _ocap_util_lib_error.CustomError("INVALID_MIGRATE_ATTEMPT", "rollup not paused");
+	if (state.contractAddress === to) throw new _ocap_util_lib_error.CustomError("INVALID_MIGRATE_ATTEMPT", "can not migrate contract to self");
+	if (state.migrateHistory.includes(to)) throw new _ocap_util_lib_error.CustomError("INVALID_MIGRATE_ATTEMPT", "can not migrate contract to history contracts");
+	return validate({
+		...state,
+		contractAddress: to,
+		migrateHistory: [...state.migrateHistory, state.contractAddress],
+		context: require_contexts_state.update(state.context, context)
+	});
+};
+const migrateVault = (state, to, context) => {
+	if (state.closed) throw new _ocap_util_lib_error.CustomError("INVALID_MIGRATE_ATTEMPT", "rollup is closed");
+	if (state.paused === false) throw new _ocap_util_lib_error.CustomError("INVALID_MIGRATE_ATTEMPT", "rollup not paused");
+	if (state.vaultAddress === to) throw new _ocap_util_lib_error.CustomError("INVALID_MIGRATE_ATTEMPT", "can not migrate vault to self");
+	if (state.vaultHistory.includes(to)) throw new _ocap_util_lib_error.CustomError("INVALID_MIGRATE_ATTEMPT", "can not migrate vault to history vaults");
+	return validate({
+		...state,
+		vaultAddress: to,
+		vaultHistory: [...state.vaultHistory, state.vaultAddress],
+		context: require_contexts_state.update(state.context, context)
+	});
+};
+const validate = (state) => {
+	const { value, error } = schema.validate(state);
+	if (error) throw new _ocap_util_lib_error.CustomError("INVALID_ROLLUP_PROPS", error.details.map((x) => x.message).join(", "));
+	if (!value.data) value.data = null;
+	return value;
+};
+
+//#endregion
+exports.close = close;
+exports.create = create;
+exports.migrateContract = migrateContract;
+exports.migrateVault = migrateVault;
+exports.pause = pause;
+exports.resume = resume;
+Object.defineProperty(exports, 'rollup_exports', {
+  enumerable: true,
+  get: function () {
+    return rollup_exports;
+  }
+});
+exports.schema = schema;
+exports.update = update;
+exports.validate = validate;

package/lib/states/rollup.d.cts

@@ -0,0 +1,18 @@
+import { StateContextInput } from "../contexts/state.cjs";
+import { IRollupState } from "@ocap/types";
+
+//#region src/states/rollup.d.ts
+declare namespace rollup_d_exports {
+  export { close, create, migrateContract, migrateVault, pause, resume, schema, update, validate };
+}
+declare const schema: any;
+declare const create: (attrs: Partial<IRollupState>, context: StateContextInput) => IRollupState;
+declare const update: (state: IRollupState, updates: Partial<IRollupState>, context: StateContextInput) => IRollupState;
+declare const pause: (state: IRollupState, context: StateContextInput) => IRollupState;
+declare const close: (state: IRollupState, context: StateContextInput) => IRollupState;
+declare const resume: (state: IRollupState, context: StateContextInput) => IRollupState;
+declare const migrateContract: (state: IRollupState, to: string, context: StateContextInput) => IRollupState;
+declare const migrateVault: (state: IRollupState, to: string, context: StateContextInput) => IRollupState;
+declare const validate: (state: IRollupState) => IRollupState;
+//#endregion
+export { close, create, migrateContract, migrateVault, pause, resume, rollup_d_exports, schema, update, validate };