Tokenization & Blockchain

UNSTAKE_COOLDOWN = 86400  # 24 hours in seconds

def stake(token):
    """Lock a token for staking yield."""
    if token.state != TokenState.ACTIVE:
        raise InvalidState(token.state, "stake")
    if token.policy.accrual_rate == 0:
        raise NoAccrualRate(token.token_type)

    token.state = TokenState.LOCKED
    token.staked_at = time.time()
    token.transferable = False
    emit_event("token.staked", token.id)
    return token

def unstake(token):
    """Unstake with cooldown enforcement."""
    if token.state != TokenState.LOCKED:
        raise InvalidState(token.state, "unstake")

    elapsed = time.time() - token.staked_at
    if elapsed < UNSTAKE_COOLDOWN:
        remaining = UNSTAKE_COOLDOWN - elapsed
        raise CooldownNotElapsed(
            f"{remaining:.0f}s remaining"
        )

    # Calculate and apply accrued yield
    days_staked = elapsed / 86400
    accrued = token.amount * (
        (1 + token.policy.accrual_rate) ** days_staked
        - 1
    )

    token.amount += accrued
    token.state = TokenState.ACTIVE
    token.transferable = token.policy.transferable
    token.staked_at = None

    emit_event("token.unstaked", token.id, {
        "accrued": str(accrued),
        "days_staked": f"{days_staked:.2f}",
    })
    return token

import hashlib

def derive_escrow_address(chain: str, contract_id: str):
    """CREATE2-style deterministic escrow address.
    No deployment needed — address is derived from
    the contract parameters alone."""
    preimage = f"AEOS/escrow/v1/{chain}/{contract_id}"
    digest = hashlib.sha256(preimage.encode()).hexdigest()
    return "0x" + digest[-40:]  # last 20 bytes

def usdc_to_atomic(amount: float) -> int:
    """Convert human-readable USDC to 6-decimal
    atomic units for on-chain transactions."""
    return int(amount * 1_000_000)

# Examples:
# derive_escrow_address("base", "ctr_abc123")
#   → 0x7a3f...e91c (deterministic)
# usdc_to_atomic(100.50) → 100_500_000

import stripe

async def create_escrow_intent(
    amount: Decimal,
    currency: str = "usd",
    metadata: dict = None,
):
    """Create a PaymentIntent with manual capture
    for escrow-style fund reservation."""
    intent = stripe.PaymentIntent.create(
        amount=int(amount * 100),  # cents
        currency=currency,
        capture_method="manual",
        metadata={
            "aeos_contract_id": metadata["contract_id"],
            "aeos_escrow_id": metadata["escrow_id"],
            **(metadata or {}),
        },
    )
    return intent

async def capture_milestone(
    payment_intent_id: str,
    amount: Decimal | None = None,
):
    """Capture full or partial payment on
    milestone completion."""
    params = {}
    if amount is not None:
        params["amount_to_capture"] = int(amount * 100)

    return stripe.PaymentIntent.capture(
        payment_intent_id, **params
    )

async def refund_on_dispute(
    payment_intent_id: str,
    amount: Decimal | None = None,
):
    """Issue full or partial refund when a
    dispute resolves against the payee."""
    params = {"payment_intent": payment_intent_id}
    if amount is not None:
        params["amount"] = int(amount * 100)

    return stripe.Refund.create(**params)

def verify_webhook(payload: bytes, sig: str, secret: str):
    """Verify Stripe webhook signature."""
    return stripe.Webhook.construct_event(
        payload, sig, secret
    )

@dataclass
class ChannelState:
    channel_id: str
    balance_a: Decimal
    balance_b: Decimal
    nonce: int
    sig_a: bytes | None = None
    sig_b: bytes | None = None

CHALLENGE_PERIOD = 3600  # 1 hour

class StateChannel:
    def open(self, agent_a, agent_b, deposit_a, deposit_b):
        """Open a bilateral channel with dual deposits."""
        channel_id = sha256(
            f"AEOS/channel/{agent_a}/{agent_b}/{time.time()}"
            .encode()
        ).hexdigest()[:16]

        self.state = ChannelState(
            channel_id=channel_id,
            balance_a=deposit_a,
            balance_b=deposit_b,
            nonce=0,
        )
        lock_on_chain(agent_a, deposit_a)
        lock_on_chain(agent_b, deposit_b)
        return self.state

    def transact(self, amount, direction, sk_a, sk_b):
        """Off-chain balance update with dual sigs."""
        if direction == "a_to_b":
            self.state.balance_a -= amount
            self.state.balance_b += amount
        else:
            self.state.balance_b -= amount
            self.state.balance_a += amount

        self.state.nonce += 1
        state_bytes = self._serialize(self.state)
        self.state.sig_a = ed25519_sign(sk_a, state_bytes)
        self.state.sig_b = ed25519_sign(sk_b, state_bytes)
        return self.state

    def cooperative_close(self):
        """Both parties agree on final state."""
        if not self.state.sig_a or not self.state.sig_b:
            raise MissingSignatures()
        settle_on_chain(
            self.state.balance_a,
            self.state.balance_b,
        )
        return "settled"

    def force_close(self, submitter_sig):
        """Unilateral close with challenge period."""
        submit_state_on_chain(self.state)
        # Counterparty has CHALLENGE_PERIOD seconds
        # to submit a higher-nonce state
        schedule_finalization(
            self.state.channel_id,
            delay=CHALLENGE_PERIOD,
        )
        return "challenge_period_started"