@version 1

####################################
# EVM => Archethic : Request funds #
####################################

condition triggered_by: transaction, on: request_funds(end_time, amount, user_address, secret_hash), as: [
  type: "contract",
  code: valid_chargeable_code?(end_time, amount, user_address, secret_hash),
  timestamp:
    (
      # End time cannot be less than now or more than 1 day
      now = Time.now()
      end_time > now && end_time <= now + 86400
    ),
  # Here ensure Ethereum contract exists and check rules
  # How to ensure Ethereum contract is a valid one ?
  # Maybe get the ABI of HTLC on github and compare it to the one on Ethereum
  # Then control rules
  address: true
]

actions triggered_by: transaction, on: request_funds(_end_time, amount, _user_address, _secret_hash) do
  args = [
    0x0000288bf6f0e12457b125dc54d2dfa4eb010be3073cf02e10fb79b696180f55b827,
    amount,
    transaction.address
  ]

  token_definition =
    Contract.call_function(0x0000795bfd6ca2f5ea9f378c20775caf798e9bfbff6aec94bf87ad8d59233b4fa299, "get_token_resupply_definition", args)

  Contract.set_type("token")
  Contract.set_content(token_definition)
end

##########################################
# Archethic => EVM : Request secret hash #
##########################################

condition triggered_by: transaction, on: request_secret_hash(htlc_genesis_address, amount, user_address, chain_id), as: [
  type: "transfer",
  code: valid_signed_code?(htlc_genesis_address, amount, user_address),
  previous_public_key:
    (
      # Ensure contract has enough fund to withdraw
      previous_address = Chain.get_previous_address()
      balance = Chain.get_token_balance(previous_address, 0x0000288bf6f0e12457b125dc54d2dfa4eb010be3073cf02e10fb79b696180f55b827)
      balance >= amount
    ),
  content: List.in?([97], chain_id),
  token_transfers:
    (
      valid? = false

      htlc_genesis_address = String.to_hex(htlc_genesis_address)
      transfers = Map.get(transaction.token_transfers, htlc_genesis_address, [])

      for transfer in transfers do
        if transfer.token_address == 0x0000288bf6f0e12457b125dc54d2dfa4eb010be3073cf02e10fb79b696180f55b827 &&
             transfer.token_id == 0 &&
             transfer.amount == amount do
          valid? = true
        end
      end

      valid?
    )
]

actions triggered_by: transaction, on: request_secret_hash(htlc_genesis_address, _amount, _user_address, chain_id) do
  # Here delete old secret that hasn't been used before endTime
  contract_content = Contract.call_function(0x0000b236fa339efb99fe46dd9f3479bf3b305f288475645af919c7c613caee14d71b, "get_state", [])

  for key in Map.keys(contract_content) do
    htlc_map = Map.get(contract_content, key)

    if htlc_map.end_time > Time.now() do
      contract_content = Map.delete(contract_content, key)
    end
  end

  secret = Crypto.hmac(transaction.address)
  secret_hash = Crypto.hash(secret, "sha256")

  # Build signature for EVM decryption
  signature = sign_for_evm(secret_hash, chain_id)

  # Calculate endtime now + 2 hours
  now = Time.now()
  end_time = now - Math.rem(now, 60) + 7200

  # Add secret and signature in content
  htlc_map = [
    hmac_address: transaction.address,
    end_time: end_time,
    chain_id: chain_id
  ]

  htlc_genesis_address = String.to_hex(htlc_genesis_address)
  contract_content = Map.set(contract_content, htlc_genesis_address, htlc_map)

  Contract.add_recipient(
    address: 0x0000b236fa339efb99fe46dd9f3479bf3b305f288475645af919c7c613caee14d71b,
    action: "update_state",
    args: [contract_content]
  )

  Contract.add_recipient(
    address: htlc_genesis_address,
    action: "set_secret_hash",
    args: [secret_hash, signature, end_time]
  )
end

####################################
# Archethic => EVM : Reveal secret #
####################################

condition triggered_by: transaction, on: reveal_secret(htlc_genesis_address), as: [
  type: "transfer",
  content:
    (
      # Ensure htlc_genesis_address exists in pool state
      # and end_time has not been reached
      contract_content = Contract.call_function(0x0000b236fa339efb99fe46dd9f3479bf3b305f288475645af919c7c613caee14d71b, "get_state", [])

      valid? = false

      htlc_genesis_address = String.to_hex(htlc_genesis_address)
      htlc_map = Map.get(contract_content, htlc_genesis_address)

      if htlc_map != nil do
        valid? = htlc_map.end_time > Time.now()
      end

      valid?
    ),
  # Here ensure Ethereum contract exists and check rules
  # How to ensure Ethereum contract is a valid one ?
  # Maybe get the ABI of HTLC on github and compare it to the one on Ethereum
  # Then control rules
  address: true
]

actions triggered_by: transaction, on: reveal_secret(htlc_genesis_address) do
  contract_content = Contract.call_function(0x0000b236fa339efb99fe46dd9f3479bf3b305f288475645af919c7c613caee14d71b, "get_state", [])

  htlc_genesis_address = String.to_hex(htlc_genesis_address)
  htlc_map = Map.get(contract_content, htlc_genesis_address)

  contract_content = Map.delete(contract_content, htlc_genesis_address)

  secret = Crypto.hmac(htlc_map.hmac_address)
  # Do not use chain ID in signature for the secret reveal
  signature = sign_for_evm(secret, nil)

  Contract.add_recipient(
    address: 0x0000b236fa339efb99fe46dd9f3479bf3b305f288475645af919c7c613caee14d71b,
    action: "update_state",
    args: [contract_content]
  )

  Contract.add_recipient(
    address: htlc_genesis_address,
    action: "reveal_secret",
    args: [secret, signature]
  )
end

condition triggered_by: transaction, on: update_code(new_code), as: [
  previous_public_key:
    (
      # Pool code can only be updated from the master chain if the bridge

      # Transaction is not yet validated so we need to use previous address
      # to get the genesis address
      previous_address = Chain.get_previous_address()
      Chain.get_genesis_address(previous_address) == 0x000020a6911478356ca264174e35d26021fb4cbe870703bb7c3859e01cdb34bcd823
    ),
  code: Code.is_valid?(new_code)
]

actions triggered_by: transaction, on: update_code(new_code) do
  Contract.set_type("contract")
  # Keep contract state
  Contract.set_content(contract.content)
  Contract.set_code(new_code)
end

####################
# Public functions #
####################

export fun(get_token_address()) do
  0x0000288bf6f0e12457b125dc54d2dfa4eb010be3073cf02e10fb79b696180f55b827
end

#####################
# Private functions #
#####################

fun valid_chargeable_code?(end_time, amount, user_address, secret_hash) do
  args = [
    end_time,
    user_address,
    0x00008dd22e7496e86901e9b276a1be6f9512eb09980cc04c7b76495ef37d5666a709,
    secret_hash,
    0x0000288bf6f0e12457b125dc54d2dfa4eb010be3073cf02e10fb79b696180f55b827,
    amount
  ]

  expected_code = Contract.call_function(0x0000795bfd6ca2f5ea9f378c20775caf798e9bfbff6aec94bf87ad8d59233b4fa299, "get_chargeable_htlc", args)

  Code.is_same?(expected_code, transaction.code)
end

fun valid_signed_code?(htlc_address, amount, user_address) do
  valid? = false

  htlc_address = String.to_hex(htlc_address)
  last_htlc_transaction = Chain.get_last_transaction(htlc_address)

  if last_htlc_transaction != nil do
    args = [
      user_address,
      0x00008dd22e7496e86901e9b276a1be6f9512eb09980cc04c7b76495ef37d5666a709,
      0x0000288bf6f0e12457b125dc54d2dfa4eb010be3073cf02e10fb79b696180f55b827,
      amount
    ]

    expected_code = Contract.call_function(0x0000795bfd6ca2f5ea9f378c20775caf798e9bfbff6aec94bf87ad8d59233b4fa299, "get_signed_htlc", args)

    valid? = Code.is_same?(expected_code, last_htlc_transaction.code)
  end

  valid?
end

fun sign_for_evm(data, chain_id) do
  hash = data

  if chain_id != nil do
    # Perform a first hash to combine data and chain_id
    abi_data = Evm.abi_encode("(bytes32,uint)", [data, chain_id])
    hash = Crypto.hash(abi_data, "keccak256")
  end

  prefix = String.to_hex("\x19Ethereum Signed Message:\n32")
  signature_payload = Crypto.hash("#{prefix}#{hash}", "keccak256")

  sig = Crypto.sign_with_recovery(signature_payload)

  if sig.v == 0 do
    sig = Map.set(sig, "v", 27)
  else
    sig = Map.set(sig, "v", 28)
  end

  sig
end

{
  "aeip": [
    2,
    8,
    18,
    19
  ],
  "supply": 1,
  "type": "fungible",
  "symbol": "aeBNB",
  "name": "aeBNB",
  "allow_mint": true,
  "properties": {},
  "recipients": [
    {
      "to": "00000000000000000000000000000000000000000000000000000000000000000000",
      "amount": 1
    }
  ]
}