aptos: initial commit

Author: evan-gray

.github/workflows/aptos.yml

@@ -0,0 +1,18 @@
+name: aptos
+
+on:
+  pull_request:
+
+jobs:
+  test:
+    name: Aptos Test
+    runs-on: ubuntu-latest
+    # https://github.com/aptos-labs/aptos-core/releases/tag/aptos-cli-v7.2.0
+    # https://github.com/aptos-labs/aptos-core/commit/35102f5f33c69b8e48e030243a09edad80cbd946
+    container: aptoslabs/tools:devnet_35102f5f33c69b8e48e030243a09edad80cbd946@sha256:06503b21b53ad904c7d689c47a78259b4891fa0d1c6932550c784bddc0d3cda0
+    defaults:
+      run:
+        working-directory: aptos
+    steps:
+      - uses: actions/checkout@v4
+      - run: sh ci.sh

aptos/.gitignore

@@ -0,0 +1,4 @@
+*/.aptos
+*/.coverage_map.mvcov
+*/.trace
+*/build

aptos/ci.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+for dir in */     # list directories in the form "/tmp/dirname/"
+do
+    dir=${dir%*/}      # remove the trailing "/"
+    cd ${dir}
+    aptos init --skip-faucet
+    sh -c "aptos move test --coverage --named-addresses ${dir}=default"
+    sh -c "aptos move coverage summary --named-addresses ${dir}=default | grep \"Move Coverage: 100.00\""
+    cd ..
+done

aptos/executor/Move.toml

@@ -0,0 +1,17 @@
+[package]
+name = "executor"
+version = "1.0.0"
+license = "Apache 2.0"
+authors = ["Wormhole Labs"]
+
+[addresses]
+executor = "_"
+
+[dev-addresses]
+
+[dependencies.AptosFramework]
+git = "https://github.com/aptos-labs/aptos-framework.git"
+rev = "mainnet"
+subdir = "aptos-framework"
+
+[dev-dependencies]

aptos/executor/sources/executor.move

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+
+module executor::executor {
+    use aptos_framework::aptos_coin::{AptosCoin};
+    use aptos_framework::coin::{Self, Coin};
+    use aptos_framework::event;
+    use aptos_std::from_bcs;
+    use executor::bytes;
+    use executor::cursor;
+
+    const CHAIN_ID: u16 = 22;
+
+    const E_QUOTE_SRC_CHAIN_MISMATCH: u64 = 0;
+    const E_QUOTE_DST_CHAIN_MISMATCH: u64 = 1;
+    const E_QUOTE_EXPIRED: u64 = 2;
+
+    #[event]
+    struct RequestForExecution has drop, store {
+        quoter_address: vector<u8>,
+        amt_paid: u64,
+        dst_chain: u16,
+        dst_addr: address,
+        refund_addr: address,
+        signed_quote: vector<u8>,
+        request_bytes: vector<u8>,
+        relay_instructions: vector<u8>,
+    }
+
+    public fun request_execution(
+        amount: Coin<AptosCoin>,
+        dst_chain: u16, 
+        dst_addr: address, // akin to bytes32 
+        refund_addr: address, 
+        signed_quote_bytes: vector<u8>, 
+        request_bytes: vector<u8>, 
+        relay_instructions: vector<u8>
+    ) {
+        let cursor = cursor::new(signed_quote_bytes);
+        bytes::take_bytes(&mut cursor, 4); // prefix
+        let quoter_address = bytes::take_bytes(&mut cursor, 20);
+        let payee_address = from_bcs::to_address(bytes::take_bytes(&mut cursor, 32));
+        let quote_src_chain = bytes::take_u16_be(&mut cursor);
+        assert!(quote_src_chain == CHAIN_ID, E_QUOTE_SRC_CHAIN_MISMATCH);
+        let quote_dst_chain = bytes::take_u16_be(&mut cursor);
+        assert!(quote_dst_chain == dst_chain, E_QUOTE_DST_CHAIN_MISMATCH);
+        let expiry_time = bytes::take_u64_be(&mut cursor);
+        assert!(expiry_time > aptos_framework::timestamp::now_seconds(), E_QUOTE_EXPIRED);
+        cursor::take_rest(cursor);
+        let amt_paid = coin::value<AptosCoin>(&amount);
+        coin::deposit(payee_address, amount);
+        event::emit(RequestForExecution {
+            quoter_address,
+            amt_paid,
+            dst_chain,
+            dst_addr,
+            refund_addr,
+            signed_quote: signed_quote_bytes,
+            request_bytes,
+            relay_instructions
+        });
+    }
+}

aptos/executor/sources/utils/bytes.move

@@ -0,0 +1,233 @@
+// SPDX-License-Identifier: Apache-2.0
+// Adapted from https://github.com/wormhole-foundation/wormhole/blob/cc9d8222858827afa9f4780164fcce32ba0dfb3a/sui/wormhole/sources/utils/bytes.move
+
+/// This module implements a library that serializes and deserializes specific
+/// types into a buffer (i.e. `vector<u8>`). For serialization, the first
+/// argument will be of `&mut vector<u8>`. For deserialization, the first
+/// argument will be of `&mut Cursor<u8>` (see `executor::cursor` for more
+/// details).
+module executor::bytes {
+    use std::bcs::{Self};
+    use std::vector;
+    use executor::cursor::{Self, Cursor};
+
+    public fun push_u8(buf: &mut vector<u8>, v: u8) {
+        vector::push_back<u8>(buf, v);
+    }
+
+    public fun push_u16_be(buf: &mut vector<u8>, value: u16) {
+        push_reverse(buf, value);
+    }
+
+    public fun push_u32_be(buf: &mut vector<u8>, value: u32) {
+        push_reverse(buf, value);
+    }
+
+    public fun push_u64_be(buf: &mut vector<u8>, value: u64) {
+        push_reverse(buf, value);
+    }
+
+    public fun push_u128_be(buf: &mut vector<u8>, value: u128) {
+        push_reverse(buf, value);
+    }
+
+    public fun push_u256_be(buf: &mut vector<u8>, value: u256) {
+        push_reverse(buf, value);
+    }
+
+    public fun take_u8(cur: &mut Cursor<u8>): u8 {
+        cursor::poke(cur)
+    }
+
+    public fun take_u16_be(cur: &mut Cursor<u8>): u16 {
+        let out = 0;
+        let i = 0;
+        while (i < 2) {
+            out = (out << 8) + (cursor::poke(cur) as u16);
+            i = i + 1;
+        };
+        out
+    }
+
+    public fun take_u32_be(cur: &mut Cursor<u8>): u32 {
+        let out = 0;
+        let i = 0;
+        while (i < 4) {
+            out = (out << 8) + (cursor::poke(cur) as u32);
+            i = i + 1;
+        };
+        out
+    }
+
+    public fun take_u64_be(cur: &mut Cursor<u8>): u64 {
+        let out = 0;
+        let i =0;
+        while (i < 8) {
+            out = (out << 8) + (cursor::poke(cur) as u64);
+            i = i + 1;
+        };
+        out
+    }
+
+    public fun take_u128_be(cur: &mut Cursor<u8>): u128 {
+        let out = 0;
+        let i = 0;
+        while (i < 16) {
+            out = (out << 8) + (cursor::poke(cur) as u128);
+            i = i + 1;
+        };
+        out
+    }
+
+    public fun take_u256_be(cur: &mut Cursor<u8>): u256 {
+        let out = 0;
+        let i = 0;
+        while (i < 32) {
+            out = (out << 8) + (cursor::poke(cur) as u256);
+            i = i + 1;
+        };
+        out
+    }
+
+    public fun take_bytes(cur: &mut Cursor<u8>, num_bytes: u64): vector<u8> {
+        let out = vector::empty();
+        let i = 0;
+        while (i < num_bytes) {
+            vector::push_back(&mut out, cursor::poke(cur));
+            i = i + 1;
+        };
+        out
+    }
+
+    fun push_reverse<T: drop>(buf: &mut vector<u8>, v: T) {
+        let data = bcs::to_bytes(&v);
+        vector::reverse(&mut data);
+        vector::append(buf, data);
+    }
+}
+
+#[test_only]
+module executor::bytes_tests {
+    use std::vector;
+    use executor::bytes::{Self};
+    use executor::cursor::{Self};
+
+    #[test]
+    fun test_push_u8(){
+        let u = 0x12;
+        let s = vector::empty();
+        bytes::push_u8(&mut s, u);
+        let cur = cursor::new(s);
+        let p = bytes::take_u8(&mut cur);
+        cursor::destroy_empty(cur);
+        assert!(p==u, 0);
+    }
+
+    #[test]
+    fun test_push_u16_be(){
+        let u = 0x1234;
+        let s = vector::empty();
+        bytes::push_u16_be(&mut s, u);
+        let cur = cursor::new(s);
+        let p = bytes::take_u16_be(&mut cur);
+        cursor::destroy_empty(cur);
+        assert!(p==u, 0);
+    }
+
+    #[test]
+    fun test_push_u32_be(){
+        let u = 0x12345678;
+        let s = vector::empty();
+        bytes::push_u32_be(&mut s, u);
+        let cur = cursor::new(s);
+        let p = bytes::take_u32_be(&mut cur);
+        cursor::destroy_empty(cur);
+        assert!(p==u, 0);
+    }
+
+    #[test]
+    fun test_push_u64_be(){
+        let u = 0x1234567812345678;
+        let s = vector::empty();
+        bytes::push_u64_be(&mut s, u);
+        let cur = cursor::new(s);
+        let p = bytes::take_u64_be(&mut cur);
+        cursor::destroy_empty(cur);
+        assert!(p==u, 0);
+    }
+
+     #[test]
+    fun test_push_u128_be(){
+        let u = 0x12345678123456781234567812345678;
+        let s = vector::empty();
+        bytes::push_u128_be(&mut s, u);
+        let cur = cursor::new(s);
+        let p = bytes::take_u128_be(&mut cur);
+        cursor::destroy_empty(cur);
+        assert!(p==u, 0);
+    }
+
+    #[test]
+    fun test_push_u256_be(){
+        let u =
+            0x4738691759099793746170047375612500000000000000000000000000009876;
+        let s = vector::empty();
+        bytes::push_u256_be(&mut s, u);
+        assert!(
+            s == x"4738691759099793746170047375612500000000000000000000000000009876",
+            0
+        );
+    }
+
+    #[test]
+    fun test_take_u8() {
+        let cursor = cursor::new(x"99");
+        let byte = bytes::take_u8(&mut cursor);
+        assert!(byte==0x99, 0);
+        cursor::destroy_empty(cursor);
+    }
+
+    #[test]
+    fun test_take_u16_be() {
+        let cursor = cursor::new(x"9987");
+        let u = bytes::take_u16_be(&mut cursor);
+        assert!(u == 0x9987, 0);
+        cursor::destroy_empty(cursor);
+    }
+
+    #[test]
+    fun test_take_u32_be() {
+        let cursor = cursor::new(x"99876543");
+        let u = bytes::take_u32_be(&mut cursor);
+        assert!(u == 0x99876543, 0);
+        cursor::destroy_empty(cursor);
+    }
+
+    #[test]
+    fun test_take_u64_be() {
+        let cursor = cursor::new(x"1300000025000001");
+        let u = bytes::take_u64_be(&mut cursor);
+        assert!(u == 0x1300000025000001, 0);
+        cursor::destroy_empty(cursor);
+    }
+
+    #[test]
+    fun test_take_u128_be() {
+        let cursor = cursor::new(x"130209AB2500FA0113CD00AE25000001");
+        let u = bytes::take_u128_be(&mut cursor);
+        assert!(u == 0x130209AB2500FA0113CD00AE25000001, 0);
+        cursor::destroy_empty(cursor);
+    }
+
+    #[test]
+    fun test_to_bytes() {
+        let cursor = cursor::new(b"hello world");
+        let hello = bytes::take_bytes(&mut cursor, 5);
+        bytes::take_u8(&mut cursor);
+        let world = bytes::take_bytes(&mut cursor, 5);
+        assert!(hello == b"hello", 0);
+        assert!(world == b"world", 0);
+        cursor::destroy_empty(cursor);
+    }
+
+}