feat: sui contract

contracts/sui/mock_dapp/Move.lock → contracts/sui/intent_v1/Move.lock

@@ -2,11 +2,11 @@
 
 [move]
 version = 2
-manifest_digest = "21E81E673F20301CA05AB61BB8D16BE536D40D02C6F8E62987634453774206FC"
+manifest_digest = "6305771898C8BDB218E218C41F747AAA626C65587647B3F4A7184BF915238509"
 deps_digest = "3C4103934B1E040BB6B23F1D610B4EF9F2F1166A50A104EADCF77467C004C600"
 dependencies = [
   { name = "Sui" },
-  { name = "xcall" },
+  { name = "sui_rlp" },
 ]
 
 [[move.package]]
@@ -23,30 +23,21 @@ dependencies = [
 
 [[move.package]]
 name = "sui_rlp"
-source = { local = "../libs/sui_rlp" }
-
-dependencies = [
-  { name = "Sui" },
-]
-
-[[move.package]]
-name = "xcall"
-source = { local = "../xcall" }
+source = { git = "https://github.com/icon-project/xcall-multi.git", rev = "main", subdir = "contracts/sui/libs/sui_rlp" }
 
 dependencies = [
   { name = "Sui" },
-  { name = "sui_rlp" },
 ]
 
 [move.toolchain-version]
-compiler-version = "1.25.1"
+compiler-version = "1.33.2"
 edition = "2024.beta"
 flavor = "sui"
 
 [env]
 
 [env.testnet]
 chain-id = "4c78adac"
-original-published-id = "0x7545f1a2cd73437e731b73b718ebbf13c440880fb811dbdef53a76b8586ccb8f"
-latest-published-id = "0x7545f1a2cd73437e731b73b718ebbf13c440880fb811dbdef53a76b8586ccb8f"
+original-published-id = "0x468fb4326302ec28df8812a41e400f3a6be4a94d9fcedf51e5935c9ac2a44226"
+latest-published-id = "0x468fb4326302ec28df8812a41e400f3a6be4a94d9fcedf51e5935c9ac2a44226"
 published-version = "1"

contracts/sui/intent_v1/Move.toml

@@ -0,0 +1,37 @@
+[package]
+name = "intents_v1"
+edition = "2024.beta" # edition = "legacy" to use legacy (pre-2024) Move
+# license = ""           # e.g., "MIT", "GPL", "Apache 2.0"
+# authors = ["..."]      # e.g., ["Joe Smith (joesmith@noemail.com)", "John Snow (johnsnow@noemail.com)"]
+
+[dependencies]
+Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "framework/testnet" }
+sui_rlp={git = "https://github.com/icon-project/xcall-multi.git", subdir = "contracts/sui/libs/sui_rlp", rev = "main"}
+# For remote import, use the `{ git = "...", subdir = "...", rev = "..." }`.
+# Revision can be a branch, a tag, and a commit hash.
+# MyRemotePackage = { git = "https://some.remote/host.git", subdir = "remote/path", rev = "main" }
+
+# For local dependencies use `local = path`. Path is relative to the package root
+# Local = { local = "../path/to" }
+
+# To resolve a version conflict and force a specific version for dependency
+# override use `override = true`
+# Override = { local = "../conflicting/version", override = true }
+
+[addresses]
+intents_v1 = "0x0"
+
+# Named addresses will be accessible in Move as `@name`. They're also exported:
+# for example, `std = "0x1"` is exported by the Standard Library.
+# alice = "0xA11CE"
+
+[dev-dependencies]
+# The dev-dependencies section allows overriding dependencies for `--test` and
+# `--dev` modes. You can introduce test-only dependencies here.
+# Local = { local = "../path/to/dev-build" }
+
+[dev-addresses]
+# The dev-addresses section allows overwriting named addresses for the `--test`
+# and `--dev` modes.
+# alice = "0xB0B"
+

contracts/sui/intent_v1/sources/cluster_connection.move

@@ -0,0 +1,77 @@
+module intents_v1::cluster_connection {
+    use std::string::{String, Self};
+    use sui::table::{Table, Self};
+    use intents_v1::order_message::{OrderMessage, Self};
+    use sui::event::{ Self };
+
+    public struct Receipt has drop, copy, store {
+        src_nid: String,
+        conn_sn: u128,
+    }
+
+    public struct ConnectionState has store {
+        conn_sn: u128,
+        relayer: address, // Address of the relayer
+        receipts: Table<Receipt, bool>, // Mapping of receipts for tracking
+    }
+
+    public struct Message has copy, drop {
+        to: String,
+        conn_sn: u128,
+        msg: vector<u8>,
+    }
+
+    public(package) fun new(relayer: address, ctx: &mut TxContext): ConnectionState {
+        ConnectionState {
+            conn_sn: 0,
+            relayer: relayer,
+            receipts: table::new(ctx),
+        }
+    }
+
+    public fun get_relayer(self: &ConnectionState): address {
+        self.relayer
+    }
+
+    public(package) fun receive_message(
+        self: &mut ConnectionState,
+        srcNid: String,
+        conn_sn: u128,
+        msg: vector<u8>,
+        ctx: &TxContext
+    ): OrderMessage {
+        assert!(self.relayer == ctx.sender());
+        let key = Receipt {src_nid: srcNid, conn_sn};
+        assert!(!self.receipts.contains(key));
+        self.receipts.add(key, true);
+        order_message::decode(&msg)
+    }
+
+    public(package) fun send_message(
+        self: &mut ConnectionState,
+        toNid: String,
+        msg: vector<u8>
+    ) {
+        let conn_sn = get_next_conn_sn(self);
+        event::emit(Message {to: toNid, conn_sn, msg,})
+
+    }
+
+    public(package) fun set_relayer(
+        self: &mut ConnectionState,
+        relayer: address
+    ) {
+        self.relayer = relayer;
+    }
+
+    fun get_next_conn_sn(self: &mut ConnectionState): u128 {
+        let sn = self.conn_sn + 1;
+        self.conn_sn = sn;
+        sn
+    }
+
+     public fun get_receipt(self: &ConnectionState, net_id: String, sn: u128): bool {
+        let receipt_key = Receipt { src_nid: net_id, conn_sn: sn };
+        self.receipts.contains<Receipt,bool>(receipt_key)
+    }
+}

contracts/sui/intent_v1/sources/messages/order_cancel.move

@@ -0,0 +1,48 @@
+module intents_v1::order_cancel {
+    use sui_rlp::encoder::{Self};
+    use sui_rlp::decoder::{Self};
+    /// @title Cancel type
+    /// @notice Represents a cancellation of an order with the corresponding order hash.
+    public struct Cancel has copy,drop{
+        order_bytes:vector<u8>,                 // Hash of the order to be canceled
+    }
+
+    public fun new(order_bytes:vector<u8>):Cancel {
+        Cancel { order_bytes }
+    }
+
+    public fun get_order_bytes(self:&Cancel): vector<u8>{
+        self.order_bytes
+    }
+
+    public fun encode(self:Cancel):vector<u8>{
+        let mut list=vector::empty<vector<u8>>();
+        vector::push_back(&mut list,encoder::encode(&self.order_bytes));
+
+        let encoded=encoder::encode_list(&list,false);
+        encoded
+
+    }
+
+    public fun decode(bytes:&vector<u8>):Cancel{
+        let decoded=decoder::decode_list(bytes);
+        let data=  *vector::borrow(&decoded,0);
+
+        Cancel {
+        order_bytes:data,
+        }
+    }
+
+#[test]
+ fun test_order_cancel_encoding(){
+    let swap_order= Cancel {
+      order_bytes:x"6c449988e2f33302803c93f8287dc1d8cb33848a",
+    };
+
+    let encoded= swap_order.encode();
+    std::debug::print(&encoded);
+    assert!(encoded==x"d5946c449988e2f33302803c93f8287dc1d8cb33848a")
+
+ }
+
+}

contracts/sui/intent_v1/sources/messages/order_fill.move

@@ -0,0 +1,94 @@
+module intents_v1::order_fill {
+    use sui_rlp::encoder::{Self};
+    use sui_rlp::decoder::{Self};
+    use std::string::{String,Self};
+    /// @title OrderFill type
+    /// @notice Represents an order fill with the corresponding order ID, order hash, solver address, and fill amount.
+    public struct OrderFill has copy,drop,store{
+        id:u128,                      // ID of the order being filled
+        order_bytes:vector<u8>,                 // Hash of the order
+        solver:String,                    // Address of the solver that fills the order
+    }
+
+    public fun new( id:u128,                      // ID of the order being filled
+        order_bytes:vector<u8>,                 // Hash of the order
+        solver:String):OrderFill{
+            OrderFill {
+                id,
+                order_bytes,
+                solver,
+            }
+        }
+
+    public fun get_id(self:&OrderFill):u128{
+        self.id
+    }
+    public fun get_order_bytes(self:&OrderFill):vector<u8>{
+        self.order_bytes
+    }
+    public fun get_solver(self:&OrderFill):String{
+        self.solver
+    }
+
+    public fun encode(self:&OrderFill):vector<u8>{
+        let mut list=vector::empty<vector<u8>>();
+        vector::push_back(&mut list,encoder::encode_u128(self.id));
+        vector::push_back(&mut list,encoder::encode(&self.order_bytes));
+        vector::push_back(&mut list,encoder::encode_string(&self.solver));
+
+
+        let encoded=encoder::encode_list(&list,false);
+        encoded
+    }
+
+    public fun decode(bytes:&vector<u8>):OrderFill {
+        let decoded=decoder::decode_list(bytes);
+        let id= decoder::decode_u128(vector::borrow(&decoded,0));
+        let order_bytes=  *vector::borrow(&decoded,1);
+        let solver=  decoder::decode_string(vector::borrow(&decoded,2));
+
+        OrderFill {
+        id,
+        order_bytes,
+        solver,
+        }
+
+    }
+
+ #[test]
+ fun test_order_fill_encoding(){
+    let swap_order= OrderFill {
+      id: 1,
+    order_bytes: x"6c449988e2f33302803c93f8287dc1d8cb33848a",
+    solver: string::utf8(b"0xcb0a6bbccfccde6be9f10ae781b9d9b00d6e63"),
+
+    };
+
+    let encoded= swap_order.encode();
+    std::debug::print(&encoded);
+    assert!(encoded==x"f83f01946c449988e2f33302803c93f8287dc1d8cb33848aa830786362306136626263636663636465366265396631306165373831623964396230306436653633")
+
+ }
+
+
+
+ #[test]
+ fun test_order_fill_encoding2(){
+    let swap_order= OrderFill {
+      id: 2,
+    order_bytes: x"cb0a6bbccfccde6be9f10ae781b9d9b00d6e63",
+    solver: string::utf8(b"0x6c449988e2f33302803c93f8287dc1d8cb33848a"),
+
+    };
+
+    let encoded= swap_order.encode();
+    std::debug::print(&encoded);
+    assert!(encoded==x"f8400293cb0a6bbccfccde6be9f10ae781b9d9b00d6e63aa307836633434393938386532663333333032383033633933663832383764633164386362333338343861")
+
+ }
+
+
+
+
+
+}

contracts/sui/intent_v1/sources/messages/order_message.move

@@ -0,0 +1,71 @@
+module intents_v1::order_message {
+     use sui_rlp::encoder::{Self};
+     use sui_rlp::decoder::{Self};
+    public struct OrderMessage has copy,drop{
+    message_type:u8,            // Message type: FILL or CANCEL
+    message:vector<u8>                 // Encoded message content
+}
+
+public fun new(message_type:u8,message:vector<u8>):OrderMessage{
+    OrderMessage { message_type, message }
+}
+
+public fun get_type(self:&OrderMessage):u8{
+    self.message_type
+}
+
+public fun get_message(self:&OrderMessage):vector<u8>{self.message}
+
+
+public fun encode(self:&OrderMessage):vector<u8>{
+    let mut list=vector::empty<vector<u8>>();
+    list.push_back(encoder::encode_u8(self.message_type));
+    vector::push_back(&mut list,encoder::encode(&self.message));
+
+    let encoded=encoder::encode_list(&list,false);
+    encoded
+
+}
+ public fun decode(bytes:&vector<u8>):OrderMessage {
+         let decoded=decoder::decode_list(bytes);
+         let message_type= decoder::decode_u8(vector::borrow(&decoded,0));
+         let message=  *vector::borrow(&decoded,1);
+
+         OrderMessage{
+            message_type,
+            message
+
+         }
+
+    }
+
+
+    #[test]
+ fun test_order_message_encoding(){
+    let swap_order= OrderMessage {
+    message_type: 1,
+    message: x"6c449988e2f33302803c93f8287dc1d8cb33848a"
+   };
+
+
+    let encoded= swap_order.encode();
+    std::debug::print(&encoded);
+    assert!(encoded==x"d601946c449988e2f33302803c93f8287dc1d8cb33848a")
+
+ }
+
+ #[test]
+ fun test_order_message_encoding2(){
+    let swap_order= OrderMessage {
+    message_type: 2,
+    message: x"6c449988e2f33302803c93f8287dc1d8cb33848a"
+   };
+
+
+    let encoded= swap_order.encode();
+    std::debug::print(&encoded);
+    assert!(encoded==x"d602946c449988e2f33302803c93f8287dc1d8cb33848a")
+
+ }
+
+}

contracts/sui/intent_v1/sources/types/swap_order.move

@@ -0,0 +1,211 @@
+module intents_v1::swap_order {
+    use std::string::{String,Self};
+    use sui::event::{Self};
+     use sui_rlp::encoder::{Self};
+     use sui::hex::{Self};
+     use sui_rlp::decoder::{Self};
+     public struct SwapOrder has copy,drop,store {
+        id:u128,   
+        emitter:String,                
+        src_nid:String,               
+        dst_nid: String,             
+        creator:String,                
+        destination_address:String,    
+        token:String,                
+        amount:u128,                 
+        to_token:String,                 
+        to_amount:u128,             
+        data:vector<u8>,
+}
+
+public fun new( id:u128,    
+    emitter:String,                 
+    src_nid:String,               
+    dst_nid: String,             
+    creator:String,                
+    destination_address:String,    
+    token:String,                  
+    amount:u128,                 
+    to_token:String,                 
+    to_amount:u128,             
+    data:vector<u8>):SwapOrder{
+        SwapOrder {
+            id,
+            emitter,
+            src_nid,
+            dst_nid,
+            creator,
+            destination_address,
+            token,
+            amount,
+            to_token,
+            to_amount,
+            data,
+        }
+    }
+
+
+
+
+    public fun get_id(self:&SwapOrder):u128 {
+    self.id
+}
+
+public fun get_emitter(self:&SwapOrder):String{
+    self.emitter
+}
+public fun get_src_nid(self:&SwapOrder):String {
+    self.src_nid
+}
+public fun get_dst_nid(self:&SwapOrder):String {
+    self.dst_nid
+}
+public fun get_creator(self:&SwapOrder):String {
+    self.creator
+}
+public fun get_destination_address(self:&SwapOrder):String{
+    self.destination_address
+}
+public fun get_to_token(self:&SwapOrder):String {
+    self.to_token
+}
+public fun get_to_amount(self:&SwapOrder):u128 {
+    self.to_amount
+}
+public fun get_data(self:&SwapOrder):&vector<u8> {
+    &self.data
+}
+
+public fun get_token(self:&SwapOrder):String {
+    return self.token
+}
+
+public fun get_amount(self:&SwapOrder):u128 {self.amount}
+
+public(package) fun emit(self:SwapOrder){
+    event::emit(self)
+}
+
+public(package) fun deduct_to_amount(self:&mut SwapOrder,amount:u128){
+    self.to_amount=self.to_amount-amount
+
+}
+
+public(package) fun deduct_amount(self:&mut SwapOrder,amount:u128){
+    self.amount=self.amount-amount;
+
+}
+
+public fun encode(self:&SwapOrder):vector<u8>{
+     let mut list=vector::empty<vector<u8>>();
+           vector::push_back(&mut list,encoder::encode_u128(self.get_id()));
+            vector::push_back(&mut list,encoder::encode_string(&self.get_emitter()));
+          vector::push_back(&mut list,encoder::encode_string(&self.get_src_nid()));
+          vector::push_back(&mut list,encoder::encode_string(&self.get_dst_nid()));
+          vector::push_back(&mut list,encoder::encode_string(&self.get_creator()));
+            vector::push_back(&mut list,encoder::encode_string(&self.get_destination_address()));
+           vector::push_back(&mut list,encoder::encode_string(&self.get_token()));
+           vector::push_back(&mut list,encoder::encode_u128(self.get_amount()));
+         vector::push_back(&mut list,encoder::encode_string(&self.get_to_token()));
+           vector::push_back(&mut list,encoder::encode_u128(self.get_to_amount()));
+            vector::push_back(&mut list,encoder::encode(self.get_data()));
+
+          let encoded=encoder::encode_list(&list,false);
+          encoded
+
+}
+
+public fun decode(bytes:&vector<u8>):SwapOrder{
+       let decoded=decoder::decode_list(bytes);
+        let id= decoder::decode_u128(vector::borrow(&decoded,0));
+         let emitter= decoder::decode_string(decoded.borrow(1));
+        let src_nid= decoder::decode_string(decoded.borrow(2));
+         let dst_nid= decoder::decode_string(decoded.borrow(3));
+         let creator= decoder::decode_string(decoded.borrow(4));
+         let destination_address=decoder::decode_string(decoded.borrow(5));
+         let token= decoder::decode_string(decoded.borrow(6));
+         let amount= decoder::decode_u128(decoded.borrow(7));
+         let to_token=decoder::decode_string(decoded.borrow(8));
+         let to_amount= decoder::decode_u128(decoded.borrow(9));
+         let data= *decoded.borrow(10);
+         SwapOrder {
+            id,
+            emitter,
+            src_nid,
+            dst_nid,
+            creator,
+            destination_address,
+            token,
+            amount,
+            to_token,
+            to_amount,
+            data,
+         }
+
+
+
+
+}
+
+/*
+
+0xf8880193cc7936ea419516635fc6feb8ad2d41b5d0c2b3894e6574776f726b2d31894e6574776f726b2d3293cc7936ea419516635fc6feb8ad2d41b5d0c2b393cc7936ea419516635fc6feb8ad2d41b5d0c2b393cc7936ea419516635fc6feb8ad2d41b5d0c2b38300afc893cc7936ea419516635fc6feb8ad2d41b5d0c2b3893635c9adc5dea0000080
+Types.SwapOrder memory orderEncodingTest = Types.SwapOrder({
+            id: 1,
+            emitter: hex"CC7936eA419516635fC6fEb8AD2d41b5D0C2B3",
+            srcNID: "Network-1",
+            dstNID: "Network-2",
+            creator: hex"CC7936eA419516635fC6fEb8AD2d41b5D0C2B3",
+            destinationAddress: hex"CC7936eA419516635fC6fEb8AD2d41b5D0C2B3",
+            token:hex"CC7936eA419516635fC6fEb8AD2d41b5D0C2B3",
+            amount: 250*10**18,
+            toToken: hex"CC7936eA419516635fC6fEb8AD2d41b5D0C2B3",
+            minReceive: 1000'*10**18,
+            data: hex""
+        }); 
+
+*/
+
+#[test]
+ fun test_swap_order_encoding(){
+    let swap_order= SwapOrder {
+        id:1,
+        emitter:string::utf8(b"0xbe6452d4d6c61cee97d3"),
+        src_nid:string::utf8(b"Ethereum"),
+        dst_nid:string::utf8(b"Polygon"),
+        creator:string::utf8(b"0x3e36eddd65e239222e7e67"),
+        destination_address:string::utf8(b"0xd2c6218b875457a41b6fb7964e"),
+        token:string::utf8(b"0x14355340e857912188b7f202d550222487"),
+        amount:1000,
+        to_token:string::utf8(b"0x91a4728b517484f0f610de7b"),
+        to_amount:900,
+        data:x"",
+    };
+
+    let encoded= swap_order.encode();
+    assert!(encoded==x"f8a601963078626536343532643464366336316365653937643388457468657265756d87506f6c79676f6e983078336533366564646436356532333932323265376536379c30786432633632313862383735343537613431623666623739363465a43078313433353533343065383537393132313838623766323032643535303232323438378203e89a307839316134373238623531373438346630663631306465376282038480")
+
+ }
+
+ #[test]
+ fun test_swap_order_encoding2(){
+    let swap_order= SwapOrder {
+        id:1,
+        emitter:string::utf8(b"0xbe6452d4d6c61cee97d3"),
+        src_nid:string::utf8(b"Ethereum"),
+        dst_nid:string::utf8(b"Polygon"),
+        creator:string::utf8(b"0x3e36eddd65e239222e7e67"),
+        destination_address:string::utf8(b"0xd2c6218b875457a41b6fb7964e"),
+        token:string::utf8(b"0x14355340e857912188b7f202d550222487"),
+        amount:100000*10000000000000000000000,
+        to_token:string::utf8(b"0x91a4728b517484f0f610de7b"),
+        to_amount:900*10000000,
+        data:x"6c449988e2f33302803c93f8287dc1d8cb33848a",
+    };
+
+    let encoded= swap_order.encode();
+    assert!(encoded==x"f8c701963078626536343532643464366336316365653937643388457468657265756d87506f6c79676f6e983078336533366564646436356532333932323265376536379c30786432633632313862383735343537613431623666623739363465a43078313433353533343065383537393132313838623766323032643535303232323438378c033b2e3c9fd0803ce80000009a3078393161343732386235313734383466306636313064653762850218711a00946c449988e2f33302803c93f8287dc1d8cb33848a")
+
+ }
+}
+

contracts/sui/intent_v1/sources/types/utils.move

@@ -0,0 +1,60 @@
+module intents_v1::utils {
+    use std::string::{Self,String};
+    use sui::hex::{Self};
+    use sui::bcs::{Self};
+    use sui::address::{Self as suiaddress};
+    use std::type_name::{Self};
+
+     public fun id_to_hex_string(id:&ID): String {
+        let bytes = object::id_to_bytes(id);
+        let hex_bytes = hex::encode(bytes);
+        to_hex_string(string::utf8(hex_bytes))
+
+
+    }
+     public fun id_from_hex_string(str: &String): ID {
+        let encoded = format_sui_address(str);
+        let bytes = encoded.as_bytes();
+        let hex_bytes = hex::decode(*bytes);
+        object::id_from_bytes(hex_bytes)
+    }
+     public fun format_sui_address(addr: &String): String {
+        let mut sui_addr = *addr;
+        if (sui_addr.substring(0, 2) == string::utf8(b"0x")) {
+            sui_addr = addr.substring(2, addr.length());
+        };
+        sui_addr
+    }
+
+     public fun address_to_hex_string(address:&address): String {
+        let bytes = bcs::to_bytes(address);
+        let hex_bytes = hex::encode(bytes);
+        to_hex_string(string::utf8(hex_bytes))
+    }
+
+    public fun address_from_hex_string(str: &String): address {
+        let mut modified_str = str;
+        if(string::length(str) == 66 ){
+            modified_str = &str.substring(2, 66);
+        };
+        let bytes = modified_str.as_bytes();
+        let hex_bytes = hex::decode(*bytes);
+        bcs::peel_address(&mut bcs::new(hex_bytes))
+    }
+
+    public fun address_from_str(val:&String):address{
+        let addr_string=format_sui_address(val);
+        suiaddress::from_ascii_bytes(addr_string.as_bytes())
+    }
+
+    public fun get_type_string<T>():String{
+        to_hex_string(string::from_ascii(type_name::get<T>().into_string()))
+    }
+
+    public fun to_hex_string(str:String):String{
+        let mut prefix = string::utf8(b"0x");
+        prefix.append(str);
+        prefix
+    }
+
+}

contracts/sui/intent_v1/tests/settlement_tests.move

@@ -0,0 +1,19 @@
+/*
+#[test_only]
+module settlement::settlement_tests {
+    // uncomment this line to import the module
+    // use settlement::settlement;
+
+    const ENotImplemented: u64 = 0;
+
+    #[test]
+    fun test_settlement() {
+        // pass
+    }
+
+    #[test, expected_failure(abort_code = ::settlement::settlement_tests::ENotImplemented)]
+    fun test_settlement_fail() {
+        abort ENotImplemented
+    }
+}
+*/