TX_DOMAIN_TAG || serde_json::to_vec(&transaction)

pub const TX_DOMAIN_TAG: &[u8];

pub const SPONSORED_SETUP_SUBJECT_DOMAIN_TAG: &[u8];

pub const DEFAULT_SIGNATURE_BATCH_SIZE: usize;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SignedTransaction {
/// The transaction payload.

pub tx: Transaction,
/// Ed25519 signature over the domain-separated transaction transcript.

pub signature: Vec<u8>,
/// Compressed Ed25519 public key of the signer (32 bytes).

pub signer_public_key: Vec<u8>
}

pub fn tx_hash(&self) -> Result<SigilHash, CoreError>;

pub fn canonical_signing_bytes(tx: &Transaction) -> Result<Vec<u8>, CoreError>;

pub fn sign(tx: Transaction, signing_key: &SigningKey) -> Result<Self, CoreError>;

pub fn verify(&self) -> Result<(), CoreError>;

pub fn verify_batch(txs: &[SignedTransaction], batch_size: usize) -> Result<(), CoreError>;

pub fn verify_batch_report_first_failure(
        txs: &[SignedTransaction],
        batch_size: usize,
    ) -> Result<(), (usize, CoreError)>;

pub fn batch_signature_hardware_hint() -> &'static str;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Transaction {
/// Chain ID to prevent replay across networks.

pub chain_id: String,
/// Sender's OAS DID.

pub sender_did: String,
/// Monotonically increasing nonce (per sender).

pub nonce: u64,
/// Gas limit for this transaction.

pub gas_limit: u64,
/// Gas price in SIGIL (smallest unit).

pub gas_price: u64,
/// Transaction payload.

pub tx_type: TransactionType,
/// Timestamp (ISO 8601).

pub timestamp: chrono::DateTime<chrono::Utc>
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SponsoredSetupScope {
    HmrAnchor,
    EnrAnchor,
    MhrAnchor,
    LineageAnchor,
    RecoveryRegistration,
    InitialDeviceAnchor,
}

pub fn as_str(self) -> &'static str;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SponsoredSetupData {
pub sponsor_did: String,
pub subject_did: String,
pub setup_scope: SponsoredSetupScope,
pub idempotency_key: String,
pub setup_tx_type: Box<TransactionType>,
pub subject_public_key: Vec<u8>,
pub subject_signature: Vec<u8>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct InitialDeviceAnchorData {
pub subject_did: String,
pub device_id: String,
pub device_public_key: Vec<u8>,
pub device_commitment: String,
pub attestation_commitment: Option<String>,
pub display_name_commitment: Option<String>,
pub sequence: u64,
pub anchored_at_block: u64
}

pub fn subject_signing_bytes(&self, chain_id: &str) -> Result<Vec<u8>, CoreError>;

pub fn subject_signing_digest(&self, chain_id: &str) -> Result<[u8; 32], CoreError>;

pub fn hash(&self) -> Result<SigilHash, CoreError>;

pub fn category(&self) -> TransactionCategory;

pub fn declared_access_set(&self) -> TransactionAccessSet;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TransactionCategory {
    Identity,
    Custody,
    Mars,
    Economics,
    Tokens,
    Contracts,
    Apps,
    Governance,
    Execution,
    Compute,
    /// Autonomous Organization / DAO transactions.
    Dao,
    /// Bidirectional Labor Market transactions (jobs, bids, contracts,
    /// milestones, attestations, reviews, disputes, reputation, revenue
    /// shares, royalties).
    Labor,
    /// Sigil Mail transactions: mailbox capability records, aliases, receive
    /// policy, public keys, delivery commitments, abuse, and delegations.
    Mail,
    /// Sigil Name System transactions extending the username registry into
    /// `.sigil` resolver records for mail, websites, wallets, and services.
    Sns,
    /// L1-coordinated distributed training commitments and reward pools.
    Crucible,
    /// Tower validator coordination chain transactions.
    #[cfg(feature = "tower")]
    Tower,
    /// Cross-Zone Agent Communication protocol transactions.
    #[cfg(feature = "czac")]
    Czac,
    /// Global Anchor Layer (MARS-S sharding) transactions.
    #[cfg(feature = "tower")]
    Gal,
    /// Nova metaverse world state transactions.
    #[cfg(feature = "nova")]
    Nova,
    /// Native non-fungible token (NFT) transactions.
    Nft,
    /// On-chain `@username` registry: register, transfer, release, metadata,
    /// reverse-lookup. See `docs/specs/USERNAMES.md`.
    Username,
    /// Event-driven autonomous contract subscriptions and deliveries.
    Vigils,
    /// First-class Weave/Weft storage pinning marketplace contracts,
    /// receipts, challenges, slashing, and rewards.
    Storage,
    /// Native constant-product DEX pools, swaps, and LP positions.
    Dex,
    /// Evidence anchoring: content-addressed digest commitments (harness
    /// archives, audit evidence). Hash-commitment anchoring, not ZK.
    Evidence,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub struct StateAccess {
pub partition: String,
pub key: String
}

pub fn new(partition: impl Into<String>, key: impl Into<String>) -> Self;

pub fn account_balance(did: impl Into<String>) -> Self;

pub fn account_nonce(did: impl Into<String>) -> Self;

pub fn fee_market_account(did: impl Into<String>) -> Self;

pub fn identity(did: impl Into<String>) -> Self;

pub fn validator(did: impl Into<String>) -> Self;

pub fn delegation(delegator: impl AsRef<str>, validator: impl AsRef<str>) -> Self;

pub fn proposal(id: impl ToString) -> Self;

pub fn vote(proposal_id: impl ToString, voter: impl AsRef<str>) -> Self;

pub fn contract(did: impl Into<String>) -> Self;

pub fn contract_code(hash: impl ToString) -> Self;

pub fn contract_state(contract_did: impl AsRef<str>, key: impl AsRef<str>) -> Self;

pub fn contract_state_prefix(contract_did: impl AsRef<str>) -> Self;

pub fn zone(id: impl Into<String>) -> Self;

pub fn zone_queue(id: impl Into<String>) -> Self;

pub fn nft_collection(id: impl Into<String>) -> Self;

pub fn nft_token(collection_id: impl AsRef<str>, token_id: u128) -> Self;

pub fn dex_pool(pool_id: impl Into<String>) -> Self;

pub fn dex_position(pool_id: impl AsRef<str>, owner_did: impl AsRef<str>) -> Self;

pub fn dex_asset_balance(asset_id: impl AsRef<str>, owner_did: impl AsRef<str>) -> Self;

pub fn dex_asset_balance_owner_prefix(owner_did: impl AsRef<str>) -> Self;

pub fn dao(id: impl Into<String>) -> Self;

pub fn mandate(id: impl Into<String>) -> Self;

pub fn labor_job(id: impl Into<String>) -> Self;

pub fn labor_bid(id: impl Into<String>) -> Self;

pub fn labor_contract(id: impl Into<String>) -> Self;

pub fn labor_offer(id: impl Into<String>) -> Self;

pub fn labor_claim(id: impl Into<String>) -> Self;

pub fn training_run(id: impl Into<String>) -> Self;

pub fn training_reward_pool(id: impl Into<String>) -> Self;

pub fn training_rollout_batch(run_id: impl AsRef<str>, batch_id: impl AsRef<str>) -> Self;

pub fn training_weights(run_id: impl AsRef<str>, model_root: impl ToString) -> Self;

pub fn training_reward_attestation(
        run_id: impl AsRef<str>,
        attestation_id: impl AsRef<str>,
    ) -> Self;

pub fn training_slash(run_id: impl AsRef<str>, slash_id: impl AsRef<str>) -> Self;

#[cfg(feature = "compute")]
pub fn compute_provider(id: impl Into<String>) -> Self;

#[cfg(feature = "compute")]
pub fn compute_escrow(id: impl Into<String>) -> Self;

#[cfg(feature = "compute")]
pub fn compute_receipt(id: impl Into<String>) -> Self;

#[cfg(feature = "compute")]
pub fn compute_challenge(id: impl Into<String>) -> Self;

pub fn storage_provider(id: impl Into<String>) -> Self;

pub fn storage_request(id: impl Into<String>) -> Self;

pub fn storage_contract(id: impl Into<String>) -> Self;

pub fn storage_receipt(id: impl Into<String>) -> Self;

pub fn storage_challenge(id: impl Into<String>) -> Self;

pub fn global(key: impl Into<String>) -> Self;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct TransactionAccessSet {
pub reads: BTreeSet<StateAccess>,
pub writes: BTreeSet<StateAccess>
}

pub fn new() -> Self;

pub fn for_sender(sender_did: &str) -> Self;

pub fn read(&mut self, key: StateAccess);

pub fn write(&mut self, key: StateAccess);

pub fn read_write(&mut self, key: StateAccess);

pub fn conflicts_with(&self, other: &Self) -> bool;

pub fn local_fee_accounts(&self) -> BTreeSet<String>;

#[allow(clippy::large_enum_variant)]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", content = "data")]
pub enum TransactionType {
    // ---- Identity (5) ----
    /// Register a new OAS identity on-chain.
    IdentityRegister(IdentityRegisterData),
    /// Update an existing OAS identity document.
    IdentityUpdate(IdentityUpdateData),
    /// Revoke an OAS identity (irreversible).
    IdentityRevoke(IdentityRevokeData),
    /// Delegate control of an identity to another DID.
    IdentityDelegate(IdentityDelegateData),
    /// Recover an identity via recovery key or social recovery.
    /// Deprecated single-step placeholder — use the `*Recovery` flow below
    /// for production. Retained for backward compatibility with pre-launch
    /// SDKs; the executor still treats it as fee-only fallthrough.
    IdentityRecover(IdentityRecoverData),
    /// Register or replace a recovery group (guardians + threshold +
    /// timelock + panic-abort key) for the sender DID.
    RegisterRecovery(RegisterRecoveryData),
    /// Initiate a recovery ceremony for `subject_did`. Permissionless
    /// (the gas payer need not be the subject).
    InitiateRecovery(InitiateRecoveryData),
    /// Add one guardian's authorization to an open recovery ceremony.
    AddRecoveryAuthorization(AddRecoveryAuthorizationData),
    /// Abort an open recovery ceremony with the panic-abort key or the
    /// subject's current pre-rotation key.
    AbortRecovery(AbortRecoveryData),
    /// Finalize a Ready recovery ceremony — rotates the on-chain pubkey.
    FinalizeRecovery(FinalizeRecoveryData),
    /// Setup-only sponsored onboarding envelope. The outer sender pays fees;
    /// the embedded action is allowlisted at executor time.
    SponsoredSetup(SponsoredSetupData),
    /// Setup-only initial device anchor for a subject DID.
    InitialDeviceAnchor(InitialDeviceAnchorData),

    // ---- Agent-native custody ----
    /// Register a first-class root identity.
    RegisterRoot(RegisterRootData),
    /// Rotate active keys for a root identity.
    RotateRootKey(RotateRootKeyData),
    /// Revoke a root identity.
    RevokeRoot(RevokeRootData),
    /// Create an HMR/MHR/ENR-backed root group.
    CreateRootGroup(CreateRootGroupData),
    /// Update a root group policy.
    UpdateRootGroupPolicy(UpdateRootGroupPolicyData),
    /// Issue an agent under a root or root group.
    IssueAgent(IssueAgentData),
    /// Rotate an agent signing key.
    RotateAgentKey(RotateAgentKeyData),
    /// Revoke an agent.
    RevokeAgent(RevokeAgentData),
    /// Delegate permissions from a controller to an agent/app.
    DelegatePermission(DelegatePermissionData),
    /// Revoke delegated permissions.
    RevokePermission(RevokePermissionData),

    // ---- MARS (5) ----
    /// Anchor a new MARS registry entry on-chain.
    MarsAnchorRegister(MarsAnchorData),
    /// Anchor a MARS entry update on-chain.
    MarsAnchorUpdate(MarsAnchorData),
    /// Anchor a MARS entry revocation on-chain.
    MarsAnchorRevoke(MarsAnchorRevokeData),
    /// Anchor a MARS entry transfer on-chain.
    MarsAnchorTransfer(MarsAnchorTransferData),
    /// Anchor a MARS attestation on-chain.
    MarsAnchorAttest(MarsAnchorAttestData),

    // ---- Economics (4) ----
    /// Stake MINT to become a validator.
    Stake(StakeData),
    /// Unstake MINT (begins unbonding period).
    Unstake(UnstakeData),
    /// Delegate stake to another validator.
    DelegateStake(DelegateStakeData),
    /// Redeem delegation pool shares from another validator.
    UndelegateStake(UndelegateStakeData),
    /// Claim accumulated rewards.
    ClaimRewards(ClaimRewardsData),
    /// Transfer MINT to another account.
    Transfer(TransferData),

    // ---- Agent-native treasuries ----
    /// Create a policy-controlled treasury.
    CreateTreasury(CreateTreasuryData),
    /// Deposit native MINT/SIGIL into a treasury.
    DepositTreasury(DepositTreasuryData),
    /// Withdraw from a policy-controlled treasury.
    WithdrawTreasury(WithdrawTreasuryData),
    /// Set treasury revenue distribution policy.
    SetDistributionPolicy(SetDistributionPolicyData),
    /// Distribute treasury revenue according to policy.
    DistributeRevenue(DistributeRevenueData),

    // ---- Agent-native tokens ----
    /// Create a custom token class.
    CreateTokenClass(CreateTokenClassData),
    /// Mint a custom token.
    MintToken(MintTokenData),
    /// Burn a custom token.
    BurnToken(BurnTokenData),
    /// Transfer a custom token.
    TransferToken(TransferTokenData),
    /// Update token policy.
    SetTokenPolicy(SetTokenPolicyData),

    // ---- Agent-native contracts ----
    /// Register content-addressed smart-contract bytecode for later deploy.
    RegisterContractCode(RegisterContractCodeData),
    /// Deploy a smart contract account.
    DeployContract(DeployContractData),
    /// Call a smart contract.
    CallContract(CallContractData),
    /// Upgrade contract code.
    UpgradeContract(UpgradeContractData),
    /// Update contract policy.
    SetContractPolicy(SetContractPolicyData),

    // ---- Agent-native apps ----
    /// Register an app agent.
    RegisterAppAgent(RegisterAppAgentData),
    /// Grant app permissions.
    GrantAppPermission(GrantAppPermissionData),
    /// Revoke app permissions.
    RevokeAppPermission(RevokeAppPermissionData),
    /// Upgrade app metadata or policy.
    UpgradeAppAgent(UpgradeAppAgentData),

    // ---- Agent-native DAO / Autonomous Organization ----
    /// Register a DAO / Autonomous Organization on-chain.
    RegisterDao(RegisterDaoData),
    /// Update controller / governance / hiring policy on a DAO.
    UpdateDaoPolicy(UpdateDaoPolicyData),

    // ---- Mandates ----
    /// Issue a mandate authorizing an actor to spend or hire under bounds.
    IssueMandate(IssueMandateData),
    /// Update budget, scope, or status of a mandate.
    UpdateMandate(UpdateMandateData),
    /// Revoke a mandate.
    RevokeMandate(RevokeMandateData),
    /// Record a spend against a mandate (emitted alongside the actual
    /// payment transaction so spend accounting stays atomic).
    RecordMandateSpend(RecordMandateSpendData),

    // ---- Labor market ----
    /// Post a labor job advertisement.
    PostLaborJob(PostLaborJobData),
    /// Cancel a labor job.
    CancelLaborJob(CancelLaborJobData),
    /// Submit a bid for a labor job.
    SubmitLaborBid(SubmitLaborBidData),
    /// Withdraw a previously submitted bid.
    WithdrawLaborBid(WithdrawLaborBidData),
    /// Accept a bid (selects the worker).
    AcceptLaborBid(AcceptLaborBidData),
    /// Create a labor contract from an accepted bid.
    CreateLaborContract(CreateLaborContractData),
    /// Fund a contract escrow.
    FundLaborEscrow(FundLaborEscrowData),
    /// Open and fund an open bounty offer.
    LaborOpenOffer(LaborOpenOfferData),
    /// Submit a claim against an open bounty offer.
    LaborSubmitClaim(LaborSubmitClaimData),
    /// Attest an open bounty claim.
    LaborAttestClaim(LaborAttestClaimData),
    /// Cancel or close an open bounty offer and refund available escrow.
    LaborCancelOffer(LaborCancelOfferData),
    /// Submit a deliverable for a contract milestone.
    SubmitDeliverable(SubmitDeliverableData),
    /// Attest milestone completion.
    AttestMilestone(AttestMilestoneData),
    /// Release escrowed payment for an attested milestone.
    ReleaseMilestonePayment(ReleaseMilestonePaymentData),
    /// Raise a dispute against a labor contract.
    RaiseLaborDispute(RaiseLaborDisputeData),
    /// Resolve an open dispute.
    ResolveLaborDispute(ResolveLaborDisputeData),
    /// Submit a post-completion review.
    SubmitLaborReview(SubmitLaborReviewData),

    // ---- Crucible training coordination ----
    /// Open an L1-coordinated training run and reserve its reward pool.
    TrainOpen(TrainOpenData),
    /// Commit a batch of off-chain rollouts by artifact/root commitment.
    TrainRolloutBatchCommit(TrainRolloutBatchCommitData),
    /// Attest reward distribution for a committed rollout batch.
    TrainRewardBatchAttest(TrainRewardBatchAttestData),
    /// Publish a model checkpoint root and artifact commitment.
    TrainWeightsPublish(TrainWeightsPublishData),
    /// Slash a verifier, coordinator, or publisher with off-chain evidence.
    TrainSlash(TrainSlashData),
    /// Close or cancel a training run.
    TrainClose(TrainCloseData),

    // ---- Governance (5) ----
    /// Submit a governance proposal.
    GovernancePropose(GovernanceProposeData),
    /// Vote on a governance proposal.
    GovernanceVote(GovernanceVoteData),
    /// Execute an approved proposal after timelock.
    GovernanceExecute(GovernanceExecuteData),
    /// Cancel a pending proposal (proposer only).
    GovernanceCancel(GovernanceCancelData),
    /// Emergency action (requires supermajority).
    #[cfg(feature = "governance")]
    GovernanceEmergency(GovernanceEmergencyData),

    // ---- Execution (7) ----
    /// Deploy a new Organization Zone.
    DeployZone(DeployZoneData),
    /// Invoke a function in an Organization Zone.
    InvokeZone(InvokeZoneData),
    /// Commit state changes from zone execution.
    CommitState(CommitStateData),
    /// Send a cross-zone message.
    CrossZoneMessage(CrossZoneMessageData),
    /// Upgrade a WASI module in a zone.
    UpgradeModule(UpgradeModuleData),
    /// Register a semantic validation WASI module.
    RegisterWasiValidator(RegisterWasiValidatorData),
    /// Remove a semantic validation WASI module.
    RemoveWasiValidator(RemoveWasiValidatorData),

    // ---- Compute (8) ----
    /// Register as a compute provider.
    #[cfg(feature = "compute")]
    ComputeProviderRegister(ComputeProviderRegisterData),
    /// Update compute provider metadata.
    #[cfg(feature = "compute")]
    ComputeProviderUpdate(ComputeProviderUpdateData),
    /// Authorize a relayer DID to submit compute receipts for a provider.
    #[cfg(feature = "compute")]
    ComputeProviderRelayerRegister(ComputeProviderRelayerData),
    /// Revoke a relayer DID from a compute provider.
    #[cfg(feature = "compute")]
    ComputeProviderRelayerRevoke(ComputeProviderRelayerData),
    /// Exit as a compute provider (begins cooldown).
    #[cfg(feature = "compute")]
    ComputeProviderExit(ComputeProviderExitData),
    /// Fund a compute escrow account.
    #[cfg(feature = "compute")]
    ComputeEscrowFund(ComputeEscrowFundData),
    /// Withdraw from compute escrow.
    #[cfg(feature = "compute")]
    ComputeEscrowWithdraw(ComputeEscrowWithdrawData),
    /// Settle a compute receipt (pay provider).
    #[cfg(feature = "compute")]
    ComputeReceiptSettle(ComputeReceiptSettleData),
    /// Challenge a compute receipt.
    #[cfg(feature = "compute")]
    ComputeChallenge(ComputeChallengeData),
    /// Resolve a compute challenge.
    #[cfg(feature = "compute")]
    ComputeChallengeResolve(ComputeChallengeResolveData),

    // ---- MACA epoch / quorum (5, Phase 12) ----
    /// Register an agent that participates in MACA consensus
    /// (Validator / Auditor / Sentinel / Proposer / Beacon).
    #[cfg(feature = "compute")]
    MacaRegisterValidatorAgent(MacaRegisterValidatorAgentData),
    /// Beacon agent publishes randomness for an epoch.
    #[cfg(feature = "compute")]
    MacaPublishBeacon(MacaPublishBeaconData),
    /// Proposer rolls open work claims into a new epoch.
    #[cfg(feature = "compute")]
    MacaProposeEpoch(MacaProposeEpochData),
    /// Validator/auditor submits an attestation against a work claim
    /// included in an open MACA epoch.
    #[cfg(feature = "compute")]
    MacaSubmitAttestation(MacaSubmitAttestationData),
    /// Finalize an open MACA epoch: aggregate validator attestations
    /// into per-work `MacaQuorumProof`s.
    #[cfg(feature = "compute")]
    MacaFinalizeEpoch(MacaFinalizeEpochData),

    // ---- Tower (7) ----
    /// Register a new validator on the Tower coordination chain.
    #[cfg(feature = "tower")]
    TowerRegisterValidator(TowerRegisterValidatorData),
    /// Update an existing Tower validator's metadata.
    #[cfg(feature = "tower")]
    TowerUpdateValidator(TowerUpdateValidatorData),
    /// Exit as a Tower validator (begins cooldown).
    #[cfg(feature = "tower")]
    TowerExitValidator(TowerExitValidatorData),
    /// Submit slashing evidence to the Tower Committee.
    #[cfg(feature = "tower")]
    TowerSubmitEvidence(TowerSubmitEvidenceData),
    /// Cast a Casper FFG finality vote.
    #[cfg(feature = "tower")]
    TowerFinalityVote(TowerFinalityVoteData),
    /// Delegate stake via the Tower coordination chain.
    #[cfg(feature = "tower")]
    TowerDelegateStake(TowerDelegateStakeData),
    /// Claim Tower validator rewards.
    #[cfg(feature = "tower")]
    TowerClaimRewards(TowerClaimRewardsData),

    // ---- CZAC (4) ----
    /// Open a CZAC cross-zone communication channel.
    #[cfg(feature = "czac")]
    CzacChannelOpen(CzacChannelOpenData),
    /// Close a CZAC channel cooperatively.
    #[cfg(feature = "czac")]
    CzacChannelClose(CzacChannelCloseData),
    /// Settle a closed CZAC channel on-consensus.
    #[cfg(feature = "czac")]
    CzacChannelSettle(CzacChannelSettleData),
    /// Dispute a CZAC payment channel with a newer balance proof.
    #[cfg(feature = "czac")]
    CzacPaymentChannelDispute(CzacPaymentChannelDisputeData),

    // ---- GAL — Global Anchor Layer (5 generic, deprecated) ----
    /// Anchor a new entry in the Global Anchor Layer (MARS-S).
    ///
    /// Deprecated in favor of the typed `GalAnchorHmr` / `GalAnchorMhr` /
    /// `GalAnchorEnr` variants below. Retained for backward compatibility.
    #[cfg(feature = "tower")]
    GalAnchorEntry(GalAnchorEntryData),
    /// Update an existing GAL entry. Deprecated: use the typed update
    /// variants for HMR / MHR / ENR / org lineage roots instead.
    #[cfg(feature = "tower")]
    GalUpdateEntry(GalUpdateEntryData),
    /// Revoke a GAL entry. Deprecated: use `GalRecordRevocation` instead.
    #[cfg(feature = "tower")]
    GalRevokeEntry(GalRevokeEntryData),
    /// Assign an entry to a specific shard. Deprecated: use
    /// `GalAssignShardTyped` instead.
    #[cfg(feature = "tower")]
    GalAssignShard(GalAssignShardData),
    /// Update the shard topology map. Deprecated: use `GalApplyTopology`
    /// instead.
    #[cfg(feature = "tower")]
    GalUpdateTopology(GalUpdateTopologyData),

    // ---- GAL — Global Anchor Layer (typed) ----
    /// Anchor an HMR (single-human root) on the GAL.
    #[cfg(feature = "tower")]
    GalAnchorHmr(crate::gal::HmrAnchor),
    /// Anchor an MHR (threshold-controlled multi-party root) on the GAL.
    #[cfg(feature = "tower")]
    GalAnchorMhr(crate::gal::MhrAnchor),
    /// Anchor an ENR (enterprise root) on the GAL.
    #[cfg(feature = "tower")]
    GalAnchorEnr(crate::gal::EnrAnchor),
    /// Update an org lineage Merkle root.
    #[cfg(feature = "tower")]
    GalUpdateOrgLineageRoot(crate::gal::OrgLineageRoot),
    /// Assign a single subject to a shard (typed counterpart of
    /// `GalAssignShard`).
    #[cfg(feature = "tower")]
    GalAssignShardTyped(crate::gal::ShardAssignment),
    /// Record a revocation. Cascade kinds (`CascadeRoot`, `CascadeOrg`)
    /// require `parent_root_did` to be set so cascade chains are
    /// reconstructible from on-chain state.
    #[cfg(feature = "tower")]
    GalRecordRevocation(crate::gal::RevocationRecord),
    /// Apply a shard-topology change.
    #[cfg(feature = "tower")]
    GalApplyTopology(crate::gal::ShardTopologyEntry),

    // ---- Nova (10) ----
    /// Claim a land parcel in the Nova metaverse.
    #[cfg(feature = "nova")]
    NovaClaimParcel(NovaClaimParcelData),
    /// Transfer a land parcel to another owner.
    #[cfg(feature = "nova")]
    NovaTransferParcel(NovaTransferParcelData),
    /// Deploy a building on a Nova parcel.
    #[cfg(feature = "nova")]
    NovaDeployBuilding(NovaDeployBuildingData),
    /// Remove a building from a Nova parcel.
    #[cfg(feature = "nova")]
    NovaRemoveBuilding(NovaRemoveBuildingData),
    /// Update avatar state (position, animation, presence).
    #[cfg(feature = "nova")]
    NovaUpdateAvatar(NovaUpdateAvatarData),
    /// Create a new Nova world instance.
    #[cfg(feature = "nova")]
    NovaCreateWorld(NovaCreateWorldData),
    /// Open a seller-owned parcel auction.
    #[cfg(feature = "nova")]
    NovaCreateAuction(NovaCreateAuctionData),
    /// Place a bid on a Nova land auction.
    #[cfg(feature = "nova")]
    NovaAuctionBid(NovaAuctionBidData),
    /// Settle a closed Nova land auction.
    #[cfg(feature = "nova")]
    NovaSettleAuction(NovaSettleAuctionData),
    /// Set permissions on a Nova spatial zone.
    #[cfg(feature = "nova")]
    NovaSetZonePermissions(NovaSetZonePermissionsData),

    // ---- Native NFT (6) ----
    /// Create a new NFT collection (standard or identity).
    CreateNftCollection(CreateNftCollectionData),
    /// Mint a new NFT into an existing collection.
    MintNft(MintNftData),
    /// Transfer an NFT from one owner to another.
    TransferNft(TransferNftData),
    /// Burn (destroy) an NFT.
    BurnNft(BurnNftData),
    /// Update the metadata URI and/or hash of an NFT (ERC-4906).
    SetNftMetadata(SetNftMetadataData),
    /// Advance the verification level on an identity NFT.
    VerifyIdentityNft(VerifyIdentityNftData),

    // ---- Username (5) ----
    /// Register an `@username` and bind it to a DID for `years` years.
    RegisterUsername(RegisterUsernameData),
    /// Transfer ownership of a username to a new DID.
    TransferUsername(TransferUsernameData),
    /// Release a username (current owner gives it up; or anyone after expiry).
    ReleaseUsername(ReleaseUsernameData),
    /// Set or clear the off-chain metadata content hash for a username.
    SetUsernameMetadata(SetUsernameMetadataData),
    /// Designate the primary `@username` for reverse lookups on a DID.
    SetReverseUsername(SetReverseUsernameData),
    /// Submit a bid against an open premium-name auction.
    SubmitUsernameAuctionBid(UsernameAuctionBidData),
    /// Finalize a premium-name auction whose anti-snipe window has elapsed.
    FinalizeUsernameAuction(UsernameAuctionFinalizeData),
    /// File a UDRP-equivalent dispute against a registered username.
    RaiseUsernameDispute(RaiseUsernameDisputeData),
    /// Resolve a previously-filed dispute (carries multisig signatures over
    /// the resolution payload).
    ResolveUsernameDispute(ResolveUsernameDisputeData),

    // ---- Sigil Mail (19) ----
    MailCreateMailbox(MailCreateMailboxData),
    MailAddAlias(MailAddAliasData),
    MailRemoveAlias(MailRemoveAliasData),
    MailSetPrimaryAlias(MailSetPrimaryAliasData),
    MailLockMailbox(MailLockMailboxData),
    MailUnlockMailbox(MailUnlockMailboxData),
    MailDeactivateMailbox(MailDeactivateMailboxData),
    MailRecoverMailbox(MailRecoverMailboxData),
    MailUpdateReceivePolicy(MailUpdateReceivePolicyData),
    MailRevokeReceivePolicy(MailRevokeReceivePolicyData),
    MailPublishKey(MailPublishKeyData),
    MailRotateKey(MailRotateKeyData),
    MailRevokeKey(MailRevokeKeyData),
    MailExpireKeys(MailExpireKeysData),
    MailPublishDeliveryCommitment(MailPublishDeliveryCommitmentData),
    MailReportAbuse(MailReportAbuseData),
    MailResolveAbuse(MailResolveAbuseData),
    MailGrantPermission(MailGrantPermissionData),
    MailRevokePermission(MailRevokePermissionData),

    // ---- Sigil Name System (10) ----
    RegisterName(RegisterNameData),
    RenewName(RenewNameData),
    SetNameRecords(SetNameRecordsData),
    DeleteNameRecords(DeleteNameRecordsData),
    DelegateSubdomain(DelegateSubdomainData),
    RevokeDelegation(RevokeDelegationData),
    SetPrimaryName(SetPrimaryNameData),
    CommitNameRegistration(CommitNameRegistrationData),
    CommitSealedNameBid(CommitSealedNameBidData),
    RevealSealedNameBid(RevealSealedNameBidData),
    FinalizeSealedNameAuction(FinalizeSealedNameAuctionData),

    // ---- Vigils (10) ----
    /// Register a Vigil subscription for a contract callback.
    RegisterVigilSubscription(crate::vigil::RegisterVigilSubscriptionData),
    /// Update mutable controls on an existing Vigil subscription.
    UpdateVigilSubscription(crate::vigil::UpdateVigilSubscriptionData),
    /// Cancel a Vigil subscription.
    CancelVigilSubscription(crate::vigil::CancelVigilSubscriptionData),
    /// Deposit autonomous-callback gas into a subscription gas tank.
    DepositVigilGas(crate::vigil::DepositVigilGasData),
    /// Withdraw unused autonomous-callback gas from a subscription gas tank.
    WithdrawVigilGas(crate::vigil::WithdrawVigilGasData),
    /// Deliver a verified event for deterministic callback scheduling.
    EventDelivery(crate::vigil::EventDeliveryData),
    /// Slash an ingestor for proven false delivery.
    SlashIngestor(crate::vigil::SlashIngestorData),
    /// Register an OAS-rooted ingestor.
    RegisterIngestor(crate::vigil::RegisterIngestorData),
    /// Update ingestor bond or supported source set.
    UpdateIngestorStake(crate::vigil::UpdateIngestorStakeData),
    /// Deregister an ingestor.
    DeregisterIngestor(crate::vigil::DeregisterIngestorData),

    // ---- Storage Pinning Marketplace (8) ----
    /// Register a Weave/Weft storage provider with capacity, pricing, and bond.
    StorageProviderRegister(StorageProviderRegisterData),
    /// Update provider capacity, regions, pricing, or signing key.
    StorageProviderUpdate(StorageProviderUpdateData),
    /// Begin provider exit from the storage marketplace.
    StorageProviderExit(StorageProviderExitData),
    /// Request replicated pinning for an artifact/Weft root commitment.
    StoragePinRequest(StoragePinRequestData),
    /// Accept a pin request as a provider.
    StoragePinAccept(StoragePinAcceptData),
    /// Settle a provider's signed pin receipt after deterministic proof checks.
    StorageReceiptSettle(StorageReceiptSettleData),
    /// Open a deterministic proof-of-possession challenge against a pin contract.
    StorageChallenge(StorageChallengeData),
    /// Resolve a storage challenge by proving or failing sampled Weft chunks.
    StorageChallengeResolve(StorageChallengeResolveData),

    // ---- DEX (5) ----
    /// Create a deterministic constant-product pool with initial liquidity.
    DexCreatePool(DexCreatePoolData),
    /// Add proportional liquidity to an existing pool.
    DexAddLiquidity(DexAddLiquidityData),
    /// Remove liquidity by burning LP shares.
    DexRemoveLiquidity(DexRemoveLiquidityData),
    /// Swap an exact input amount with minimum-output protection.
    DexSwapExactIn(DexSwapExactInData),
    /// Swap for an exact output amount with maximum-input protection.
    DexSwapExactOut(DexSwapExactOutData),

    // ---- Evidence anchoring (1) ----
    /// Anchor a content digest (e.g. a ONE harness archive BLAKE3 digest)
    /// on-chain with bounded metadata. Hash-commitment anchoring — not ZK.
    EvidenceAnchor(EvidenceAnchorData),
}

pub fn category(&self) -> TransactionCategory;

pub fn declared_access_set(&self, sender_did: &str) -> TransactionAccessSet;

pub fn name(&self) -> &'static str;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IdentityRegisterData {
/// The OAS DID to register.

pub did: String,
/// The full OAS document (serialized JSON).

pub document: serde_json::Value,
/// Initial conformance level.

pub conformance_level: String
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IdentityUpdateData {
pub did: String,
pub document: serde_json::Value,
pub sequence: u64
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct IdentityRevokeData {
pub did: String,
pub reason: String
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct IdentityDelegateData {
pub did: String,
pub delegate_did: String,
pub scopes: Vec<String>,
pub expires_at: Option<String>
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IdentityRecoverData {
pub did: String,
pub recovery_proof: serde_json::Value,
pub new_document: serde_json::Value
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RegisterRootData {
pub root_did: String,
pub kind: RootKind,
pub public_keys: Vec<String>,
pub recovery_policy: Option<ControlPolicy>,
pub metadata_commitment: Option<String>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RotateRootKeyData {
pub root_did: String,
pub new_public_keys: Vec<String>,
pub effective_epoch: Option<u64>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RevokeRootData {
pub root_did: String,
pub reason: String
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateRootGroupData {
pub group_did: String,
pub kind: RootKind,
pub policy: ThresholdPolicy,
pub profit_shares: Vec<crate::authority::ProfitShare>,
pub metadata_commitment: Option<String>
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UpdateRootGroupPolicyData {
pub group_did: String,
pub new_policy: ThresholdPolicy,
pub reason: Option<String>
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IssueAgentData {
pub agent_did: String,
pub controller_did: String,
pub agent_kind: AgentKind,
pub public_keys: Vec<String>,
pub permissions: Vec<Permission>,
pub revenue_account: Option<String>,
pub metadata_commitment: Option<String>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RotateAgentKeyData {
pub agent_did: String,
pub new_public_keys: Vec<String>,
pub effective_epoch: Option<u64>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RevokeAgentData {
pub agent_did: String,
pub reason: String
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DelegatePermissionData {
pub controller_did: String,
pub delegate_did: String,
pub permissions: Vec<Permission>,
pub expires_at_epoch: Option<u64>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RevokePermissionData {
pub controller_did: String,
pub delegate_did: String,
pub permissions: Vec<Permission>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MarsAnchorData {
pub entry_did: String,
pub item_data_hash: String,
pub publisher_did: String,
pub version: String,
pub bond_id: Option<String>
}

pub fn to_mars_anchor_data(
        &self,
        entry_did: impl Into<String>,
        publisher_did: impl Into<String>,
        version: impl Into<String>,
        bond_id: Option<String>,
    ) -> MarsAnchorData;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MarsAnchorRevokeData {
pub entry_did: String,
pub reason: String
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MarsAnchorTransferData {
pub entry_did: String,
pub from_publisher_did: String,
pub to_publisher_did: String
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MarsAnchorAttestData {
pub entry_did: String,
pub attestation_hash: String,
pub attester_did: String
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct StakeData {
/// Amount to stake in smallest SIGIL unit.

pub amount: u64,
/// Validator mode: "producer" (10K min) or "validator" (1K min).

pub mode: ValidatorMode
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ValidatorMode {
    /// Block Producer — executes + proves. Min 10,000 MINT.
    BlockProducer,
    /// Block Validator — verifies proofs only. Min 1,000 MINT.
    BlockValidator,
}

pub fn min_stake(&self) -> u64;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct UnstakeData {
/// Amount to unstake. Subject to 14-day unbonding period.

pub amount: u64
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DelegateStakeData {
pub validator_did: String,
pub amount: u64
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct UndelegateStakeData {
pub validator_did: String,
pub shares: u64
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ClaimRewardsData {
/// Optional: claim from a specific epoch range.

pub from_epoch: Option<u64>,
pub to_epoch: Option<u64>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct TransferData {
/// Recipient's OAS DID.

pub recipient_did: String,
/// Amount in micro-MINT.

pub amount: u64,
/// Optional memo/reference.

pub memo: Option<String>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DexCreatePoolData {
pub asset_a: DexPoolAsset,
pub asset_b: DexPoolAsset,
pub amount_a_desired: u64,
pub amount_b_desired: u64,
pub fee_bps: u16,
pub min_lp_shares: u64,
pub expiration_height: Option<u64>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DexAddLiquidityData {
pub pool_id: String,
pub amount_a_desired: u64,
pub amount_b_desired: u64,
pub amount_a_min: u64,
pub amount_b_min: u64,
pub min_lp_shares: u64,
pub expiration_height: Option<u64>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DexRemoveLiquidityData {
pub pool_id: String,
pub lp_shares: u64,
pub amount_a_min: u64,
pub amount_b_min: u64,
pub recipient_did: String,
pub expiration_height: Option<u64>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DexSwapExactInData {
pub pool_id: String,
pub asset_in: DexPoolAsset,
pub amount_in: u64,
pub min_amount_out: u64,
pub recipient_did: String,
pub expiration_height: Option<u64>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DexSwapExactOutData {
pub pool_id: String,
pub asset_out: DexPoolAsset,
pub amount_out: u64,
pub max_amount_in: u64,
pub recipient_did: String,
pub expiration_height: Option<u64>
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateTreasuryData {
pub treasury_did: String,
pub controller_did: String,
pub accepted_token_ids: Vec<String>,
pub withdrawal_policy: ControlPolicy,
pub distribution_policy: Option<DistributionPolicy>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DepositTreasuryData {
pub treasury_did: String,
pub token_id: Option<String>,
pub amount: u128
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct WithdrawTreasuryData {
pub treasury_did: String,
pub token_id: Option<String>,
pub recipient_did: String,
pub amount: u128,
pub memo: Option<String>
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetDistributionPolicyData {
pub treasury_did: String,
pub distribution_policy: DistributionPolicy
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DistributeRevenueData {
pub treasury_did: String,
pub token_id: Option<String>,
pub amount: Option<u128>
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateTokenClassData {
pub token_id: String,
pub ticker: String,
pub decimals: u8,
pub issuer_did: String,
pub controller_did: String,
pub supply_policy: SupplyPolicy,
pub transfer_policy: Option<ControlPolicy>,
pub metadata_uri: Option<String>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MintTokenData {
pub token_id: String,
pub recipient_did: String,
pub amount: u128
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BurnTokenData {
pub token_id: String,
pub owner_did: String,
pub amount: u128
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct TransferTokenData {
pub token_id: String,
pub recipient_did: String,
pub amount: u128,
pub memo: Option<String>
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetTokenPolicyData {
pub token_id: String,
pub supply_policy: Option<SupplyPolicy>,
pub transfer_policy: Option<ControlPolicy>
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateNftCollectionData {
/// Unique identifier for the new collection.

pub collection_id: String,
/// Human-readable collection name.

pub name: String,
/// Short symbol (ticker) for the collection (e.g. "BADGE").

pub symbol: String,
/// Whether this collection holds standard or identity NFTs.

pub kind: crate::nft::NftKind,
/// DID of the issuing party.

pub issuer_did: String,
/// DID of the controlling party (may update policy).

pub controller_did: String,
/// Governance policy for this collection.

pub policy: crate::nft::CollectionPolicy,
/// Optional collection-level metadata URI.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata_uri: Option<String>
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MintNftData {
/// Target collection identifier.

pub collection_id: String,
/// Token ID to assign (must be unique within the collection).

///

/// Serialized as a decimal string on the JSON wire for cross-language

/// safety (JavaScript's Number type cannot represent u128 exactly).

#[serde(with = "serde_helpers::string_u128")]
pub token_id: u128,
/// DID of the initial token owner.

pub recipient_did: String,
/// Optional per-token metadata URI.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata_uri: Option<String>,
/// Optional BLAKE3 hash of the canonical metadata document.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata_hash: Option<crate::hash::SigilHash>,
/// Override the collection's `default_locked` setting for this token.

/// `None` inherits the collection default.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub locked: Option<bool>,
/// Override the collection's `default_burn_auth` for this token.

/// `None` inherits the collection default.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub burn_auth: Option<crate::nft::BurnAuth>,
/// Identity binding — required when minting into an identity collection.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub identity: Option<crate::nft::IdentityBinding>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct TransferNftData {
/// Collection containing the token.

pub collection_id: String,
/// Token to transfer.

///

/// Serialized as a decimal string on the JSON wire for cross-language

/// safety (JavaScript's Number type cannot represent u128 exactly).

#[serde(with = "serde_helpers::string_u128")]
pub token_id: u128,
/// DID of the current owner (sender).

pub from_did: String,
/// DID of the new owner (recipient).

pub to_did: String
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BurnNftData {
/// Collection containing the token.

pub collection_id: String,
/// Token to burn.

///

/// Serialized as a decimal string on the JSON wire for cross-language

/// safety (JavaScript's Number type cannot represent u128 exactly).

#[serde(with = "serde_helpers::string_u128")]
pub token_id: u128,
/// DID of the party authorizing the burn (must satisfy `burn_auth`).

pub authorized_by: String
}