msvault.h

#pragma once

#include "structs.h"
#include <cstdint>

#include "asset_utils.h"

#define MSVAULT_CONTRACT_INDEX 11
#define MSVAULT_MAX_OWNERS 16
#define MSVAULT_MAX_COOWNER 8
#define MSVAULT_MAX_ASSET_TYPES 8
#define MSVAULT_MAX_FEE_VOTES 64

struct MsVaultRegisterVault_input {
    uint8_t vaultName[32];
    // owners: 32 owners, each 32-byte
    uint8_t owners[MSVAULT_MAX_OWNERS * 32];
    uint64_t requiredApprovals;
};
struct MsVaultRegisterVault_output {
    uint64_t status;
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultDeposit_input {
    uint64_t vaultID;
};
struct MsVaultDeposit_output {
    uint64_t status;
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultReleaseTo_input {
    uint64_t vaultID;
    uint64_t amount;
    uint8_t destination[32];
};
struct MsVaultReleaseTo_output {
    uint64_t status;
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultResetRelease_input {
    uint64_t vaultID;
};
struct MsVaultResetRelease_output {
    uint64_t status;
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetVaults_input {
    uint8_t publicKey[32];
};
struct MsVaultGetVaults_output {
    uint64_t numberOfVaults;
    uint64_t vaultIDs[MSVAULT_MAX_COOWNER];
    uint8_t vaultNames[MSVAULT_MAX_COOWNER][32];
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetReleaseStatus_input {
    uint64_t vaultID;
};
struct MsVaultGetReleaseStatus_output {
    uint64_t status;
    uint64_t amounts[MSVAULT_MAX_OWNERS];
    uint8_t destinations[MSVAULT_MAX_OWNERS][32];
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetBalanceOf_input {
    uint64_t vaultID;
};
struct MsVaultGetBalanceOf_output {
    uint64_t status;
    int64_t balance;
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetVaultName_input {
    uint64_t vaultID;
};
struct MsVaultGetVaultName_output {
    uint64_t status;
    uint8_t vaultName[32];
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetRevenueInfo_input {};
struct MsVaultGetRevenueInfo_output {
    uint64_t numberOfActiveVaults;
    uint64_t totalRevenue;
    uint64_t totalDistributedToShareholders;
    uint64_t burnedAmount;
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetFees_input {
};
struct MsVaultGetFees_output {
    uint64_t registeringFee;
    uint64_t releaseFee;
    uint64_t releaseResetFee;
    uint64_t holdingFee;
    uint64_t depositFee;
    uint64_t burnFee;
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetVaultOwners_input {
    uint64_t vaultID;
};
struct MsVaultGetVaultOwners_output {
    uint64_t status;
    uint64_t numberOfOwners;
    uint8_t owners[MSVAULT_MAX_OWNERS][32];
    uint64_t requiredApprovals;
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct AssetBalance
{
    qpi::Asset asset;
    uint64_t balance;
};

struct MsVaultDepositAsset_input
{
    uint64_t vaultID;
    qpi::Asset asset;
    uint64_t amount;
};
struct MsVaultDepositAsset_output
{
    uint64_t status;
    static constexpr unsigned char type()
    {
        return RespondContractFunction::type();
    }
};

struct MsVaultReleaseAssetTo_input
{
    uint64_t vaultID;
    qpi::Asset asset;
    uint64_t amount;
    uint8_t destination[32];
};
struct MsVaultReleaseAssetTo_output
{
    uint64_t status;
    static constexpr unsigned char type()
    {
        return RespondContractFunction::type();
    }
};

struct MsVaultResetAssetRelease_input
{
    uint64_t vaultID;
};
struct MsVaultResetAssetRelease_output
{
    uint64_t status;
    static constexpr unsigned char type()
    {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetVaultAssetBalances_input
{
    uint64_t vaultID;
};
struct MsVaultGetVaultAssetBalances_output
{
    uint64_t status;
    uint64_t numberOfAssetTypes;
    AssetBalance assetBalances[MSVAULT_MAX_ASSET_TYPES];
    static constexpr unsigned char type()
    {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetAssetReleaseStatus_input
{
    uint64_t vaultID;
};
struct MsVaultGetAssetReleaseStatus_output
{
    uint64_t status;
    qpi::Asset assets[MSVAULT_MAX_OWNERS];
    uint64_t amounts[MSVAULT_MAX_OWNERS];
    uint8_t destinations[MSVAULT_MAX_OWNERS][32];
    static constexpr unsigned char type()
    {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetManagedAssetBalance_input
{
    qpi::Asset asset;
    uint8_t owner[32];
};
struct MsVaultGetManagedAssetBalance_output
{
    int64_t balance;
    static constexpr unsigned char type()
    {
        return RespondContractFunction::type();
    }
};

struct MsVaultRevokeAssetManagementRights_input
{
    qpi::Asset asset;
    int64_t numberOfShares;
};

struct MsVaultRevokeAssetManagementRights_output
{
    uint64_t status;
    int64_t transferredNumberOfShares;
    static constexpr unsigned char type()
    {
        return RespondContractFunction::type();
    }
};


// Fee Voting structs

struct MsVaultIsShareHolder_input {
    uint8_t candidate[32];
};
struct MsVaultIsShareHolder_output {
    uint64_t result; // 1 if shareholder, 0 otherwise
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultVoteFeeChange_input {
    uint64_t newRegisteringFee;
    uint64_t newReleaseFee;
    uint64_t newReleaseResetFee;
    uint64_t newHoldingFee;
    uint64_t newDepositFee;
    uint64_t burnFee;
};

struct MsVaultVoteFeeChange_output {
    uint64_t status;
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultFeeVote {
    uint64_t registeringFee;
    uint64_t releaseFee;
    uint64_t releaseResetFee;
    uint64_t holdingFee;
    uint64_t depositFee;
    uint64_t burnFee;
};

struct MsVaultGetFeeVotes_input {};
struct MsVaultGetFeeVotes_output {
    uint64_t status;
    uint64_t numberOfFeeVotes;
    MsVaultFeeVote feeVotes[MSVAULT_MAX_FEE_VOTES];
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetFeeVotesOwner_input {};
struct MsVaultGetFeeVotesOwner_output {
    uint64_t status;
    uint64_t numberOfFeeVotes;
    uint8_t feeVotesOwner[MSVAULT_MAX_FEE_VOTES][32];
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetFeeVotesScore_input {};
struct MsVaultGetFeeVotesScore_output {
    uint64_t status;
    uint64_t numberOfFeeVotes;
    uint64_t feeVotesScore[MSVAULT_MAX_FEE_VOTES];
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetUniqueFeeVotes_input {};
struct MsVaultGetUniqueFeeVotes_output {
    uint64_t status;
    uint64_t numberOfUniqueFeeVotes;
    MsVaultFeeVote uniqueFeeVotes[MSVAULT_MAX_FEE_VOTES];
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

struct MsVaultGetUniqueFeeVotesRanking_input {};
struct MsVaultGetUniqueFeeVotesRanking_output {
    uint64_t status;
    uint64_t numberOfUniqueFeeVotes;
    uint64_t uniqueFeeVotesRanking[MSVAULT_MAX_FEE_VOTES];
    static constexpr unsigned char type() {
        return RespondContractFunction::type();
    }
};

void msvaultRegisterVault(const char* nodeIp, int nodePort, const char* seed,
    uint64_t requiredApprovals, const uint8_t vaultName[32],
    const char* ownersCommaSeparated,
    uint32_t scheduledTickOffset);

void msvaultDeposit(const char* nodeIp, int nodePort, const char* seed,
    uint64_t vaultID, uint64_t amount, uint32_t scheduledTickOffset);

void msvaultReleaseTo(const char* nodeIp, int nodePort, const char* seed,
    uint64_t vaultID, uint64_t amount, const char* destinationIdentity,
    uint32_t scheduledTickOffset);

void msvaultResetRelease(const char* nodeIp, int nodePort, const char* seed,
    uint64_t vaultID, uint32_t scheduledTickOffset);

void msvaultGetVaults(const char* nodeIp, int nodePort, const char* identity);
void msvaultGetReleaseStatus(const char* nodeIp, int nodePort, uint64_t vaultID);
void msvaultGetBalanceOf(const char* nodeIp, int nodePort, uint64_t vaultID);
void msvaultGetVaultName(const char* nodeIp, int nodePort, uint64_t vaultID);
void msvaultGetRevenueInfo(const char* nodeIp, int nodePort);
void msvaultGetFees(const char* nodeIp, int nodePort);
void msvaultGetVaultOwners(const char* nodeIp, int nodePort, uint64_t vaultID);

void msvaultDepositAsset(const char* nodeIp, int nodePort, const char* seed,
    uint64_t vaultID, const char* assetName, const char* issuer, uint64_t amount,
    uint32_t scheduledTickOffset);

void msvaultReleaseAssetTo(const char* nodeIp, int nodePort, const char* seed,
    uint64_t vaultID, const char* assetName, const char* issuer, uint64_t amount, const char* destination,
    uint32_t scheduledTickOffset);

void msvaultResetAssetRelease(const char* nodeIp, int nodePort, const char* seed,
    uint64_t vaultID, uint32_t scheduledTickOffset);

void msvaultGetVaultAssetBalances(const char* nodeIp, int nodePort, uint64_t vaultID);

void msvaultGetAssetReleaseStatus(const char* nodeIp, int nodePort, uint64_t vaultID);

void msvaultGetManagedAssetBalance(const char* nodeIp, int nodePort, const char* assetName, const char* issuer, const char* owner);

void msvaultRevokeAssetManagementRights(const char* nodeIp, int nodePort, const char* seed,
    const char* assetName, const char* issuer, int64_t numberOfShares,
    uint32_t scheduledTickOffset);

// Fee votings
void msvaultIsShareHolder(const char* nodeIp, int nodePort, const char* identity);

void msvaultVoteFeeChange(const char* nodeIp, int nodePort, const char* seed,
    uint64_t newRegisteringFee, uint64_t newReleaseFee, uint64_t newReleaseResetFee,
    uint64_t newHoldingFee, uint64_t newDepositFee, uint64_t burnFee,
    uint32_t scheduledTickOffset);

void msvaultGetFeeVotes(const char* nodeIp, int nodePort);
void msvaultGetFeeVotesOwner(const char* nodeIp, int nodePort);
void msvaultGetFeeVotesScore(const char* nodeIp, int nodePort);
void msvaultGetUniqueFeeVotes(const char* nodeIp, int nodePort);
void msvaultGetUniqueFeeVotesRanking(const char* nodeIp, int nodePort);