timelock.cell

module cellscript::timelock

use cellscript::fungible_token::Token

const U64_MAX: u64 = 18446744073709551615

const MIN_LOCK_PERIOD: u64 = 10

const MAX_LOCK_PERIOD: u64 = 2628000

const EMERGENCY_APPROVALS: u8 = 2

enum LockType {
    Absolute,
    Relative,
}

resource TimeLock has store, create, consume, replace, burn, read_ref {
    lock_id: Hash,
    owner: Address,
    lock_type: LockType,
    unlock_height: u64,
    created_at: u64,
}

resource LockedAsset has store, create, consume, burn {
    token_symbol: [u8; 8],
    amount: u64,
    lock_id: Hash,
}

receipt ReleaseRequest has create, consume, burn {
    lock_id: Hash,
    requester: Address,
    requested_at: u64,
    state: u8,
}

receipt ReleaseRecord has create {
    lock_id: Hash,
    released_at: u64,
    released_by: Address,
}

receipt EmergencyRelease has create, consume, replace, burn {
    lock_id: Hash,
    requester: Address,
    reason: String,
    requested_at: u64,
    approvers: Vec<Address>,
    state: u8,
}

action create_absolute_lock(lock_id: Hash, owner: Address, unlock_height: u64) -> created_lock: TimeLock {
    verification
        let current_height = ckb::epoch_number_to_u64(ckb::header_dep(0).epoch_number)
        require current_height <= U64_MAX - MAX_LOCK_PERIOD, "Lock range overflow"
        require unlock_height > current_height + MIN_LOCK_PERIOD, "Unlock height too close"
        require unlock_height <= current_height + MAX_LOCK_PERIOD, "Unlock height too far"
        create created_lock = TimeLock { lock_id, owner, lock_type: LockType::Absolute, unlock_height, created_at: current_height }

}
action create_relative_lock(lock_id: Hash, owner: Address, lock_period: u64) -> created_lock: TimeLock {
    verification
        let current_height = ckb::epoch_number_to_u64(ckb::header_dep(0).epoch_number)
        require lock_period >= MIN_LOCK_PERIOD, "Lock period too short"
        require lock_period <= MAX_LOCK_PERIOD, "Lock period too long"
        require lock_period <= U64_MAX - current_height, "Unlock height overflow"
        create created_lock = TimeLock { lock_id, owner, lock_type: LockType::Relative, unlock_height: current_height + lock_period, created_at: current_height }

}
action lock_asset(read time_lock: TimeLock, asset: Token) -> locked: LockedAsset {
    verification
        require asset.amount > 0, "Amount must be positive"
        consume asset
        create locked = LockedAsset { token_symbol: asset.symbol, amount: asset.amount, lock_id: time_lock.lock_id } with_lock(time_lock.owner)

}
action request_release(read time_lock: TimeLock, requester: Address) -> request: ReleaseRequest {
    verification
        let current_height = ckb::epoch_number_to_u64(ckb::header_dep(0).epoch_number)
        require requester == time_lock.owner, "Not the owner"
        require can_unlock(time_lock, current_height), "Cannot unlock yet"
        require input_since_satisfies(time_lock), "Input since does not satisfy lock"
        create request = ReleaseRequest { lock_id: time_lock.lock_id, requester, requested_at: current_height, state: 0 } with_lock(requester)

}
action execute_release(time_lock: TimeLock, locked_asset: LockedAsset, request: ReleaseRequest, executor: Address) -> (released_asset: Token, record: ReleaseRecord) {
    verification
        let current_height = ckb::epoch_number_to_u64(ckb::header_dep(0).epoch_number)
        require time_lock.owner == executor, "Not the owner"
        require can_unlock(&time_lock, current_height), "Cannot unlock yet"
        require input_since_satisfies(&time_lock), "Input since does not satisfy lock"
        require locked_asset.lock_id == time_lock.lock_id, "Asset does not match lock"
        require request.lock_id == time_lock.lock_id, "Request does not match lock"
        require request.requester == time_lock.owner, "Request owner mismatch"
        destroy time_lock
        destroy locked_asset
        destroy request
        create released_asset = Token { amount: locked_asset.amount, symbol: locked_asset.token_symbol } with_lock(time_lock.owner)
        create record = ReleaseRecord { lock_id: request.lock_id, released_at: current_height, released_by: executor }

}
action request_emergency_release(read time_lock: TimeLock, requester: Address, reason: String) -> emergency: EmergencyRelease {
    verification
        let current_height = ckb::epoch_number_to_u64(ckb::header_dep(0).epoch_number)
        require time_lock.owner == requester, "Not the owner"
        require !can_unlock(time_lock, current_height), "Already unlockable"
        create emergency = EmergencyRelease { lock_id: time_lock.lock_id, requester, reason, requested_at: current_height, approvers: [], state: 0 } with_lock(requester)

}
action approve_emergency_release(emergency_before: EmergencyRelease, claimed_approver: Address) -> emergency_after: EmergencyRelease {
    verification
        require claimed_approver != emergency_before.requester, "Requester cannot self-approve"
        for existing in &emergency_before.approvers {
            require *existing != claimed_approver, "Already approved"
        }
        preserve emergency_after from emergency_before {
            lock_id
            requester
            reason
            requested_at
            state
        }
        require emergency_after.approvers.len() == emergency_before.approvers.len() + 1
        for i in 0..emergency_before.approvers.len() {
            require emergency_after.approvers[i] == emergency_before.approvers[i], "Existing approvals changed"
        }
        require emergency_after.approvers[emergency_before.approvers.len()] == claimed_approver

}
action execute_emergency_release(time_lock: TimeLock, locked_asset: LockedAsset, emergency: EmergencyRelease, executor: Address) -> (released_asset: Token, record: ReleaseRecord) {
    verification
        let current_height = ckb::epoch_number_to_u64(ckb::header_dep(0).epoch_number)
        require time_lock.owner == executor, "Not the owner"
        require emergency.requester == time_lock.owner, "Emergency requester mismatch"
        require emergency.approvers.len() >= EMERGENCY_APPROVALS as usize, "Not enough approvals"
        require emergency.lock_id == time_lock.lock_id, "Emergency request does not match"
        require locked_asset.lock_id == time_lock.lock_id, "Asset does not match"
        destroy time_lock
        destroy locked_asset
        destroy emergency
        create released_asset = Token { amount: locked_asset.amount, symbol: locked_asset.token_symbol } with_lock(time_lock.owner)
        create record = ReleaseRecord { lock_id: time_lock.lock_id, released_at: current_height, released_by: executor }

}
action extend_lock(time_lock_before: TimeLock, additional_period: u64, owner: Address) -> time_lock_after: TimeLock {
    verification
        let current_height = ckb::epoch_number_to_u64(ckb::header_dep(0).epoch_number)
        require time_lock_before.owner == owner, "Not the owner"
        require !can_unlock(&time_lock_before, current_height), "Already unlocked"
        require additional_period <= U64_MAX - time_lock_before.unlock_height, "Unlock height overflow"
        let new_unlock_height = time_lock_before.unlock_height + additional_period
        require current_height <= U64_MAX - MAX_LOCK_PERIOD, "Lock range overflow"
        require new_unlock_height <= current_height + MAX_LOCK_PERIOD, "New unlock height too far"
        preserve time_lock_after from time_lock_before {
            lock_id
            owner
            lock_type
            created_at
        }
        require time_lock_after.unlock_height == new_unlock_height

}
action batch_create_locks(lock_ids: [Hash; 4], owners: [Address; 4], unlock_heights: [u64; 4]) -> (lock0: TimeLock, lock1: TimeLock, lock2: TimeLock, lock3: TimeLock) {
    verification
        let current_height = ckb::epoch_number_to_u64(ckb::header_dep(0).epoch_number)
        require current_height <= U64_MAX - MAX_LOCK_PERIOD, "Lock range overflow"
        require unlock_heights[0] > current_height + MIN_LOCK_PERIOD, "Unlock height too close"
        require unlock_heights[1] > current_height + MIN_LOCK_PERIOD, "Unlock height too close"
        require unlock_heights[2] > current_height + MIN_LOCK_PERIOD, "Unlock height too close"
        require unlock_heights[3] > current_height + MIN_LOCK_PERIOD, "Unlock height too close"
        require unlock_heights[0] <= current_height + MAX_LOCK_PERIOD, "Unlock height too far"
        require unlock_heights[1] <= current_height + MAX_LOCK_PERIOD, "Unlock height too far"
        require unlock_heights[2] <= current_height + MAX_LOCK_PERIOD, "Unlock height too far"
        require unlock_heights[3] <= current_height + MAX_LOCK_PERIOD, "Unlock height too far"
        create lock0 = TimeLock { lock_id: lock_ids[0], owner: owners[0], lock_type: LockType::Absolute, unlock_height: unlock_heights[0], created_at: current_height }
        create lock1 = TimeLock { lock_id: lock_ids[1], owner: owners[1], lock_type: LockType::Absolute, unlock_height: unlock_heights[1], created_at: current_height }
        create lock2 = TimeLock { lock_id: lock_ids[2], owner: owners[2], lock_type: LockType::Absolute, unlock_height: unlock_heights[2], created_at: current_height }
        create lock3 = TimeLock { lock_id: lock_ids[3], owner: owners[3], lock_type: LockType::Absolute, unlock_height: unlock_heights[3], created_at: current_height }

}
fn can_unlock(time_lock: &TimeLock, current_height: u64) -> bool {
    current_height >= time_lock.unlock_height
}

fn input_since_satisfies(time_lock: &TimeLock) -> bool {
    let observed = ckb::since_decode(ckb::input<TimeLock>(0).since)
    let absolute_minimum = ckb::since_absolute_epoch(time_lock.unlock_height, 0, 1)
    let lock_period = time_lock.unlock_height - time_lock.created_at
    let relative_minimum = ckb::since_relative_epoch(lock_period, 0, 1)
    if (time_lock.lock_type == LockType::Absolute) {
        return ckb::since_as_absolute_epoch(observed) >= absolute_minimum
    }
    return ckb::since_as_relative_epoch(observed) >= relative_minimum
}

fn remaining_blocks(time_lock: &TimeLock, current_height: u64) -> u64 {
    if current_height >= time_lock.unlock_height {
        0
    } else if current_height <= time_lock.created_at {
        0
    } else {
        time_lock.unlock_height - current_height
    }
}

fn lock_progress(time_lock: &TimeLock, current_height: u64) -> u8 {
    if current_height >= time_lock.unlock_height {
        100
    } else {
        let elapsed = current_height - time_lock.created_at
        let total = time_lock.unlock_height - time_lock.created_at
        if total == 0 {
            100
        } else {
            let progress = elapsed * 100 / total
            if progress > 100 {
                100
            } else {
                progress as u8
            }
        }
    }
}

lock can_unlock_lock(protected time_lock: TimeLock) -> bool {
    verification
        let current_height = ckb::epoch_number_to_u64(ckb::header_dep(0).epoch_number)
        require can_unlock(time_lock, current_height)
        require input_since_satisfies(time_lock)

}
lock is_owner(protected time_lock: TimeLock, witness addr: Address) -> bool {
    verification
        require time_lock.owner == addr

}
lock lock_id_commitment(protected time_lock: TimeLock, witness lock_seed: Hash) -> bool {
    verification
        let expected_lock_id = hash_blake2b(lock_seed)
        require time_lock.lock_id == expected_lock_id

}
lock asset_matches(protected locked_asset: LockedAsset, read time_lock: TimeLock) -> bool {
    verification
        require locked_asset.lock_id == time_lock.lock_id

}
lock emergency_approved(protected emergency: EmergencyRelease) -> bool {
    verification
        require emergency.approvers.len() >= EMERGENCY_APPROVALS as usize

}
lock not_expired(protected time_lock: TimeLock) -> bool {
    verification
        let current_height = ckb::epoch_number_to_u64(ckb::header_dep(0).epoch_number)
        require current_height < time_lock.unlock_height
}