StateSet Orders Quickstart

// Msg defines the order Msg service.
service Msg {
  // MsgCreateOrder defines a method for creating an order
  rpc Create(MsgCreateOrder) returns (MsgCreateResponse);

  // MsgFulfillOrder defines a method for fulfilling an order
  rpc Fulfill(MsgFulfillOrder) returns (MsgFulfillResponse);

  // MsgCancelOrder defines a method for cancelling an order
  rpc Cancel(MsgCancelOrder) returns (MsgCancelResponse);
}

    import { Type, Field } from "protobufjs";

    const MsgCreateOrder = new Type("MsgCreateOrder")
    .add(new Field("creator", 1, "string"))
    .add(new Field("seller", 2, "string"))
    .add(new Field("amount", 3, "string"))
    .add(new Field("fee", 4, "string"))
    .add(new Field("order_number", 5, "string"))
    .add(new Field("name", 6, "string"))
    .add(new Field("state", 7, "string"));


    const handleSubmitOrder = async () => {
        setStatus(prevStatus => ({ ...prevStatus, submitting: true }))

        const myRegistry = new Registry(defaultStargateTypes);
        myRegistry.register("/StateSet.core.order.MsgCreateOrder", MsgCreateOrder);

        const wallet = await DirectSecp256k1HdWallet.fromMnemonic(
            inputs.mnemonic,
            { prefix: "StateSet" },
        );

        const firstAccount = await wallet.getAccounts();

        var creator_address;

        if (firstAccount) {

            creator_address = firstAccount[0].address;

        }

        const rpcEndpoint = "https://rpc.StateSet.zone";

        const client = await SigningStateSetClient.connectWithSigner(rpcEndpoint, wallet, { registry: myRegistry, gasPrice: "0.00025state" });

        if (client) {

            var _uuid = uuid();

            // collateral
            const collateral = {
                amount: [
                    {
                        denom: "ustate",
                        amount: inputs.collateral,
                    },
                ],
            };

            const message = {
                typeUrl: "/StateSet.core.order.MsgCreateOrder",
                value: {
                    buyer: creator_address,
                    seller: inputs.seller,
                    amount: inputs.amount,
                    fee: inputs.fee,
                    order_number: _uuid,
                    name: inputs.name,
                    state: "UNFULFILLED"

                },
            };


            // Fee
            const fee = {
                amount: [
                    {
                        denom: "state",
                        amount: "0",
                    },
                ],
                gas: "10000",
            };

            const result = await client.signAndBroadcast(creator_address, [message], "auto", 'creating an order from the StateSet zone');

            if (result) {

                setStatus(prevStatus => ({
                    ...prevStatus,
                    submitted: true,
                }))

                setOrderID(_uuid);
            }

        }
    }

const Order = () => {

    const router = useRouter();
    const id = router.query;
    var id_ = id.id;

    const [orders, setOrders] = useState([]);

    useEffect(() => {
        async function getOrders() {
            const res = await fetch(`https://rest-api.StateSet.zone/StateSet/core/order/order/${id_}`, {
                method: 'GET'
            });
            const order_data = await res.json();
            setOrdets(order_data.Order);
        };

        getOrders();
    }, []);

    return (<OrderPage order={orders} />);

}

export default Order

    import { Type, Field } from "protobufjs";

    const MsgFulfillOrder = new Type("MsgFulfillOrder")
    .add(new Field("creator", 1, "string"))
    .add(new Field("state", 2, "string"));


    const handleFulfillOrder = async () => {

        setStatus(prevStatus => ({ ...prevStatus, submitting: true }))

        const myRegistry = new Registry(defaultStargateTypes);
        myRegistry.register("/StateSet.core.order.MsgFulfillOrder", MsgFulfillOrder);

        const wallet = await DirectSecp256k1HdWallet.fromMnemonic(
            inputs.mnemonic,
            { prefix: "StateSet" },
        );

        const firstAccount = await wallet.getAccounts();

        var creator_address;

        if (firstAccount) {

            creator_address = firstAccount[0].address;

        }

        const rpcEndpoint = "https://rpc.StateSet.zone";

        const client = await SigningStateSetClient.connectWithSigner(rpcEndpoint, wallet, { registry: myRegistry, gasPrice: "0.00025state" });

        if (client) {

            // collateral
            const collateral = {
                amount: [
                    {
                        denom: "ustate",
                        amount: inputs.collateral,
                    },
                ],
            };

            const message = {
                typeUrl: "/StateSet.core.order.MsgFulfillOrder",
                value: {
                    creator: creator_address,
                    state: "FULFILLED"

                },
            }

        }
    }

StateSetd tx order create-order \
    --from <key-name> \
    --seller <seller-address> \
    --amount <amount> \
    --fee <fee> \
    --order-number <order-number> \
    --name <name> \
    --state <state> \
    --chain-id StateSet-1 \
    --node tcp://rpc.StateSet.zone:26657 \
    --gas-prices 0.00025state \
    --gas auto \
    --broadcast-mode block \
    --yes

StateSetd query order order <order-id> \
    --chain-id StateSet-1 \
    --node tcp://rpc.StateSet.zone:26657

StateSetd tx order fulfill-order \
    --from <key-name> \
    --state <state> \
    --chain-id StateSet-1 \
    --node tcp://rpc.StateSet.zone:26657 \
    --gas-prices 0.00025state \
    --gas auto \
    --broadcast-mode block \
    --yes