@qubic.org/contracts 0.2.0

package/dist/__generated__/msvault.js

@@ -0,0 +1,1187 @@
+import { buildPayload, decodePayload } from '@qubic.org/registry';
+import { callContractFunction } from '../call-contract.js';
+export const MS_VAULT_CONTRACT_INDEX = 11;
+const STRUCTS = {
+    'Asset': {
+        name: 'Asset',
+        byteLength: 40,
+        fields: [
+            {
+                name: 'issuer',
+                type: 'id',
+                offset: 0,
+                byteLength: 32,
+            },
+            {
+                name: 'assetName',
+                type: 'uint64',
+                offset: 32,
+                byteLength: 8,
+            },
+        ],
+    },
+    'AssetBalance': {
+        name: 'AssetBalance',
+        byteLength: 48,
+        fields: [
+            {
+                name: 'asset',
+                type: 'struct',
+                offset: 0,
+                byteLength: 40,
+                structRef: 'Asset',
+            },
+            {
+                name: 'balance',
+                type: 'uint64',
+                offset: 40,
+                byteLength: 8,
+            },
+        ],
+    },
+    'MsVaultFeeVote': {
+        name: 'MsVaultFeeVote',
+        byteLength: 48,
+        fields: [
+            {
+                name: 'registeringFee',
+                type: 'uint64',
+                offset: 0,
+                byteLength: 8,
+            },
+            {
+                name: 'releaseFee',
+                type: 'uint64',
+                offset: 8,
+                byteLength: 8,
+            },
+            {
+                name: 'releaseResetFee',
+                type: 'uint64',
+                offset: 16,
+                byteLength: 8,
+            },
+            {
+                name: 'holdingFee',
+                type: 'uint64',
+                offset: 24,
+                byteLength: 8,
+            },
+            {
+                name: 'depositFee',
+                type: 'uint64',
+                offset: 32,
+                byteLength: 8,
+            },
+            {
+                name: 'burnFee',
+                type: 'uint64',
+                offset: 40,
+                byteLength: 8,
+            },
+        ],
+    },
+};
+export const MS_VAULT_REGISTER_VAULT_INPUT_TYPE = 7;
+const MS_VAULT_REGISTER_VAULT_INPUT_FIELDS = [
+    {
+        name: 'vaultName',
+        type: 'id',
+        offset: 0,
+        byteLength: 32,
+    },
+    {
+        name: 'owners',
+        type: 'array',
+        offset: 32,
+        byteLength: 512,
+        arrayLength: 16,
+        arrayItemType: 'id',
+        arrayItemByteLength: 32,
+    },
+    {
+        name: 'requiredApprovals',
+        type: 'uint64',
+        offset: 544,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultRegisterVaultInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_REGISTER_VAULT_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_REGISTER_VAULT_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultRegisterVaultOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_REGISTER_VAULT_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export const MS_VAULT_DEPOSIT_INPUT_TYPE = 8;
+const MS_VAULT_DEPOSIT_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultDepositInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_DEPOSIT_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_DEPOSIT_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultDepositOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_DEPOSIT_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export const MS_VAULT_RELEASE_TO_INPUT_TYPE = 9;
+const MS_VAULT_RELEASE_TO_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'amount',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+    {
+        name: 'destination',
+        type: 'id',
+        offset: 16,
+        byteLength: 32,
+    },
+];
+export function buildMsVaultReleaseToInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_RELEASE_TO_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_RELEASE_TO_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultReleaseToOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_RELEASE_TO_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export const MS_VAULT_RESET_RELEASE_INPUT_TYPE = 10;
+const MS_VAULT_RESET_RELEASE_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultResetReleaseInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_RESET_RELEASE_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_RESET_RELEASE_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultResetReleaseOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_RESET_RELEASE_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export const MS_VAULT_VOTE_FEE_CHANGE_INPUT_TYPE = 11;
+const MS_VAULT_VOTE_FEE_CHANGE_INPUT_FIELDS = [
+    {
+        name: 'newRegisteringFee',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'newReleaseFee',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+    {
+        name: 'newReleaseResetFee',
+        type: 'uint64',
+        offset: 16,
+        byteLength: 8,
+    },
+    {
+        name: 'newHoldingFee',
+        type: 'uint64',
+        offset: 24,
+        byteLength: 8,
+    },
+    {
+        name: 'newDepositFee',
+        type: 'uint64',
+        offset: 32,
+        byteLength: 8,
+    },
+    {
+        name: 'burnFee',
+        type: 'uint64',
+        offset: 40,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultVoteFeeChangeInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_VOTE_FEE_CHANGE_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_VOTE_FEE_CHANGE_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultVoteFeeChangeOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_VOTE_FEE_CHANGE_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export const MS_VAULT_DEPOSIT_ASSET_INPUT_TYPE = 24;
+const MS_VAULT_DEPOSIT_ASSET_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'asset',
+        type: 'struct',
+        offset: 8,
+        byteLength: 40,
+        structRef: 'Asset',
+    },
+    {
+        name: 'amount',
+        type: 'uint64',
+        offset: 48,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultDepositAssetInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_DEPOSIT_ASSET_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_DEPOSIT_ASSET_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultDepositAssetOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_DEPOSIT_ASSET_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export const MS_VAULT_REVOKE_ASSET_MANAGEMENT_RIGHTS_INPUT_TYPE = 25;
+const MS_VAULT_REVOKE_ASSET_MANAGEMENT_RIGHTS_INPUT_FIELDS = [
+    {
+        name: 'asset',
+        type: 'struct',
+        offset: 0,
+        byteLength: 40,
+        structRef: 'Asset',
+    },
+    {
+        name: 'numberOfShares',
+        type: 'sint64',
+        offset: 40,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultRevokeAssetManagementRightsInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_REVOKE_ASSET_MANAGEMENT_RIGHTS_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_REVOKE_ASSET_MANAGEMENT_RIGHTS_OUTPUT_FIELDS = [
+    {
+        name: 'transferredNumberOfShares',
+        type: 'sint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultRevokeAssetManagementRightsOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_REVOKE_ASSET_MANAGEMENT_RIGHTS_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export const MS_VAULT_RELEASE_ASSET_TO_INPUT_TYPE = 26;
+const MS_VAULT_RELEASE_ASSET_TO_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'asset',
+        type: 'struct',
+        offset: 8,
+        byteLength: 40,
+        structRef: 'Asset',
+    },
+    {
+        name: 'amount',
+        type: 'uint64',
+        offset: 48,
+        byteLength: 8,
+    },
+    {
+        name: 'destination',
+        type: 'id',
+        offset: 56,
+        byteLength: 32,
+    },
+];
+export function buildMsVaultReleaseAssetToInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_RELEASE_ASSET_TO_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_RELEASE_ASSET_TO_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultReleaseAssetToOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_RELEASE_ASSET_TO_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export const MS_VAULT_RESET_ASSET_RELEASE_INPUT_TYPE = 27;
+const MS_VAULT_RESET_ASSET_RELEASE_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultResetAssetReleaseInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_RESET_ASSET_RELEASE_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_RESET_ASSET_RELEASE_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultResetAssetReleaseOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_RESET_ASSET_RELEASE_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export const MS_VAULT_IS_SHARE_HOLDER_INPUT_TYPE = 5;
+export const MS_VAULT_IS_SHARE_HOLDER_INPUT_SIZE = 32;
+const MS_VAULT_IS_SHARE_HOLDER_INPUT_FIELDS = [
+    {
+        name: 'candidate',
+        type: 'id',
+        offset: 0,
+        byteLength: 32,
+    },
+];
+export function buildMsVaultIsShareHolderInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_IS_SHARE_HOLDER_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_IS_SHARE_HOLDER_OUTPUT_FIELDS = [
+    {
+        name: 'result',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultIsShareHolderOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_IS_SHARE_HOLDER_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultIsShareHolder(live, input, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_IS_SHARE_HOLDER_INPUT_TYPE,
+        inputSize: MS_VAULT_IS_SHARE_HOLDER_INPUT_SIZE,
+        inputFields: MS_VAULT_IS_SHARE_HOLDER_INPUT_FIELDS,
+        outputFields: MS_VAULT_IS_SHARE_HOLDER_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: input,
+        ...options,
+    });
+}
+export const MS_VAULT_GET_MANAGED_ASSET_BALANCE_INPUT_TYPE = 6;
+export const MS_VAULT_GET_MANAGED_ASSET_BALANCE_INPUT_SIZE = 72;
+const MS_VAULT_GET_MANAGED_ASSET_BALANCE_INPUT_FIELDS = [
+    {
+        name: 'asset',
+        type: 'struct',
+        offset: 0,
+        byteLength: 40,
+        structRef: 'Asset',
+    },
+    {
+        name: 'owner',
+        type: 'id',
+        offset: 40,
+        byteLength: 32,
+    },
+];
+export function buildMsVaultGetManagedAssetBalanceInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_GET_MANAGED_ASSET_BALANCE_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_GET_MANAGED_ASSET_BALANCE_OUTPUT_FIELDS = [
+    {
+        name: 'balance',
+        type: 'sint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultGetManagedAssetBalanceOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_MANAGED_ASSET_BALANCE_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetManagedAssetBalance(live, input, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_MANAGED_ASSET_BALANCE_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_MANAGED_ASSET_BALANCE_INPUT_SIZE,
+        inputFields: MS_VAULT_GET_MANAGED_ASSET_BALANCE_INPUT_FIELDS,
+        outputFields: MS_VAULT_GET_MANAGED_ASSET_BALANCE_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: input,
+        ...options,
+    });
+}
+export const MS_VAULT_GET_VAULTS_INPUT_TYPE = 12;
+export const MS_VAULT_GET_VAULTS_INPUT_SIZE = 32;
+const MS_VAULT_GET_VAULTS_INPUT_FIELDS = [
+    {
+        name: 'publicKey',
+        type: 'id',
+        offset: 0,
+        byteLength: 32,
+    },
+];
+export function buildMsVaultGetVaultsInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_GET_VAULTS_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_GET_VAULTS_OUTPUT_FIELDS = [
+    {
+        name: 'numberOfVaults',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'vaultIds',
+        type: 'array',
+        offset: 8,
+        byteLength: 64,
+        arrayLength: 8,
+        arrayItemType: 'uint64',
+        arrayItemByteLength: 8,
+    },
+    {
+        name: 'vaultNames',
+        type: 'array',
+        offset: 72,
+        byteLength: 256,
+        arrayLength: 8,
+        arrayItemType: 'id',
+        arrayItemByteLength: 32,
+    },
+];
+export function decodeMsVaultGetVaultsOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_VAULTS_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetVaults(live, input, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_VAULTS_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_VAULTS_INPUT_SIZE,
+        inputFields: MS_VAULT_GET_VAULTS_INPUT_FIELDS,
+        outputFields: MS_VAULT_GET_VAULTS_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: input,
+        ...options,
+    });
+}
+export const MS_VAULT_GET_RELEASE_STATUS_INPUT_TYPE = 13;
+export const MS_VAULT_GET_RELEASE_STATUS_INPUT_SIZE = 8;
+const MS_VAULT_GET_RELEASE_STATUS_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultGetReleaseStatusInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_GET_RELEASE_STATUS_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_GET_RELEASE_STATUS_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'amounts',
+        type: 'array',
+        offset: 8,
+        byteLength: 128,
+        arrayLength: 16,
+        arrayItemType: 'uint64',
+        arrayItemByteLength: 8,
+    },
+    {
+        name: 'destinations',
+        type: 'array',
+        offset: 136,
+        byteLength: 512,
+        arrayLength: 16,
+        arrayItemType: 'id',
+        arrayItemByteLength: 32,
+    },
+];
+export function decodeMsVaultGetReleaseStatusOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_RELEASE_STATUS_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetReleaseStatus(live, input, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_RELEASE_STATUS_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_RELEASE_STATUS_INPUT_SIZE,
+        inputFields: MS_VAULT_GET_RELEASE_STATUS_INPUT_FIELDS,
+        outputFields: MS_VAULT_GET_RELEASE_STATUS_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: input,
+        ...options,
+    });
+}
+export const MS_VAULT_GET_BALANCE_OF_INPUT_TYPE = 14;
+export const MS_VAULT_GET_BALANCE_OF_INPUT_SIZE = 8;
+const MS_VAULT_GET_BALANCE_OF_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultGetBalanceOfInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_GET_BALANCE_OF_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_GET_BALANCE_OF_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'balance',
+        type: 'sint64',
+        offset: 8,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultGetBalanceOfOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_BALANCE_OF_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetBalanceOf(live, input, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_BALANCE_OF_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_BALANCE_OF_INPUT_SIZE,
+        inputFields: MS_VAULT_GET_BALANCE_OF_INPUT_FIELDS,
+        outputFields: MS_VAULT_GET_BALANCE_OF_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: input,
+        ...options,
+    });
+}
+export const MS_VAULT_GET_VAULT_NAME_INPUT_TYPE = 15;
+export const MS_VAULT_GET_VAULT_NAME_INPUT_SIZE = 8;
+const MS_VAULT_GET_VAULT_NAME_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultGetVaultNameInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_GET_VAULT_NAME_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_GET_VAULT_NAME_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'vaultName',
+        type: 'id',
+        offset: 8,
+        byteLength: 32,
+    },
+];
+export function decodeMsVaultGetVaultNameOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_VAULT_NAME_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetVaultName(live, input, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_VAULT_NAME_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_VAULT_NAME_INPUT_SIZE,
+        inputFields: MS_VAULT_GET_VAULT_NAME_INPUT_FIELDS,
+        outputFields: MS_VAULT_GET_VAULT_NAME_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: input,
+        ...options,
+    });
+}
+export const MS_VAULT_GET_REVENUE_INFO_INPUT_TYPE = 16;
+export const MS_VAULT_GET_REVENUE_INFO_INPUT_SIZE = 0;
+const MS_VAULT_GET_REVENUE_INFO_OUTPUT_FIELDS = [
+    {
+        name: 'numberOfActiveVaults',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'totalRevenue',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+    {
+        name: 'totalDistributedToShareholders',
+        type: 'uint64',
+        offset: 16,
+        byteLength: 8,
+    },
+    {
+        name: 'burnedAmount',
+        type: 'uint64',
+        offset: 24,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultGetRevenueInfoOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_REVENUE_INFO_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetRevenueInfo(live, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_REVENUE_INFO_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_REVENUE_INFO_INPUT_SIZE,
+        inputFields: [],
+        outputFields: MS_VAULT_GET_REVENUE_INFO_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: {},
+        ...options,
+    });
+}
+export const MS_VAULT_GET_FEES_INPUT_TYPE = 17;
+export const MS_VAULT_GET_FEES_INPUT_SIZE = 0;
+const MS_VAULT_GET_FEES_OUTPUT_FIELDS = [
+    {
+        name: 'registeringFee',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'releaseFee',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+    {
+        name: 'releaseResetFee',
+        type: 'uint64',
+        offset: 16,
+        byteLength: 8,
+    },
+    {
+        name: 'holdingFee',
+        type: 'uint64',
+        offset: 24,
+        byteLength: 8,
+    },
+    {
+        name: 'depositFee',
+        type: 'uint64',
+        offset: 32,
+        byteLength: 8,
+    },
+    {
+        name: 'burnFee',
+        type: 'uint64',
+        offset: 40,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultGetFeesOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_FEES_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetFees(live, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_FEES_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_FEES_INPUT_SIZE,
+        inputFields: [],
+        outputFields: MS_VAULT_GET_FEES_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: {},
+        ...options,
+    });
+}
+export const MS_VAULT_GET_VAULT_OWNERS_INPUT_TYPE = 18;
+export const MS_VAULT_GET_VAULT_OWNERS_INPUT_SIZE = 8;
+const MS_VAULT_GET_VAULT_OWNERS_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultGetVaultOwnersInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_GET_VAULT_OWNERS_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_GET_VAULT_OWNERS_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'numberOfOwners',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+    {
+        name: 'owners',
+        type: 'array',
+        offset: 16,
+        byteLength: 512,
+        arrayLength: 16,
+        arrayItemType: 'id',
+        arrayItemByteLength: 32,
+    },
+    {
+        name: 'requiredApprovals',
+        type: 'uint64',
+        offset: 528,
+        byteLength: 8,
+    },
+];
+export function decodeMsVaultGetVaultOwnersOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_VAULT_OWNERS_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetVaultOwners(live, input, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_VAULT_OWNERS_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_VAULT_OWNERS_INPUT_SIZE,
+        inputFields: MS_VAULT_GET_VAULT_OWNERS_INPUT_FIELDS,
+        outputFields: MS_VAULT_GET_VAULT_OWNERS_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: input,
+        ...options,
+    });
+}
+export const MS_VAULT_GET_FEE_VOTES_INPUT_TYPE = 19;
+export const MS_VAULT_GET_FEE_VOTES_INPUT_SIZE = 0;
+const MS_VAULT_GET_FEE_VOTES_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'numberOfFeeVotes',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+    {
+        name: 'feeVotes',
+        type: 'array',
+        offset: 16,
+        byteLength: 3072,
+        arrayLength: 64,
+        arrayItemByteLength: 48,
+        arrayItemStructRef: 'MsVaultFeeVote',
+    },
+];
+export function decodeMsVaultGetFeeVotesOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_FEE_VOTES_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetFeeVotes(live, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_FEE_VOTES_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_FEE_VOTES_INPUT_SIZE,
+        inputFields: [],
+        outputFields: MS_VAULT_GET_FEE_VOTES_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: {},
+        ...options,
+    });
+}
+export const MS_VAULT_GET_FEE_VOTES_OWNER_INPUT_TYPE = 20;
+export const MS_VAULT_GET_FEE_VOTES_OWNER_INPUT_SIZE = 0;
+const MS_VAULT_GET_FEE_VOTES_OWNER_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'numberOfFeeVotes',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+    {
+        name: 'feeVotesOwner',
+        type: 'array',
+        offset: 16,
+        byteLength: 2048,
+        arrayLength: 64,
+        arrayItemType: 'id',
+        arrayItemByteLength: 32,
+    },
+];
+export function decodeMsVaultGetFeeVotesOwnerOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_FEE_VOTES_OWNER_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetFeeVotesOwner(live, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_FEE_VOTES_OWNER_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_FEE_VOTES_OWNER_INPUT_SIZE,
+        inputFields: [],
+        outputFields: MS_VAULT_GET_FEE_VOTES_OWNER_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: {},
+        ...options,
+    });
+}
+export const MS_VAULT_GET_FEE_VOTES_SCORE_INPUT_TYPE = 21;
+export const MS_VAULT_GET_FEE_VOTES_SCORE_INPUT_SIZE = 0;
+const MS_VAULT_GET_FEE_VOTES_SCORE_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'numberOfFeeVotes',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+    {
+        name: 'feeVotesScore',
+        type: 'array',
+        offset: 16,
+        byteLength: 512,
+        arrayLength: 64,
+        arrayItemType: 'uint64',
+        arrayItemByteLength: 8,
+    },
+];
+export function decodeMsVaultGetFeeVotesScoreOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_FEE_VOTES_SCORE_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetFeeVotesScore(live, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_FEE_VOTES_SCORE_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_FEE_VOTES_SCORE_INPUT_SIZE,
+        inputFields: [],
+        outputFields: MS_VAULT_GET_FEE_VOTES_SCORE_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: {},
+        ...options,
+    });
+}
+export const MS_VAULT_GET_UNIQUE_FEE_VOTES_INPUT_TYPE = 22;
+export const MS_VAULT_GET_UNIQUE_FEE_VOTES_INPUT_SIZE = 0;
+const MS_VAULT_GET_UNIQUE_FEE_VOTES_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'numberOfUniqueFeeVotes',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+    {
+        name: 'uniqueFeeVotes',
+        type: 'array',
+        offset: 16,
+        byteLength: 3072,
+        arrayLength: 64,
+        arrayItemByteLength: 48,
+        arrayItemStructRef: 'MsVaultFeeVote',
+    },
+];
+export function decodeMsVaultGetUniqueFeeVotesOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_UNIQUE_FEE_VOTES_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetUniqueFeeVotes(live, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_UNIQUE_FEE_VOTES_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_UNIQUE_FEE_VOTES_INPUT_SIZE,
+        inputFields: [],
+        outputFields: MS_VAULT_GET_UNIQUE_FEE_VOTES_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: {},
+        ...options,
+    });
+}
+export const MS_VAULT_GET_UNIQUE_FEE_VOTES_RANKING_INPUT_TYPE = 23;
+export const MS_VAULT_GET_UNIQUE_FEE_VOTES_RANKING_INPUT_SIZE = 0;
+const MS_VAULT_GET_UNIQUE_FEE_VOTES_RANKING_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'numberOfUniqueFeeVotes',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+    {
+        name: 'uniqueFeeVotesRanking',
+        type: 'array',
+        offset: 16,
+        byteLength: 512,
+        arrayLength: 64,
+        arrayItemType: 'uint64',
+        arrayItemByteLength: 8,
+    },
+];
+export function decodeMsVaultGetUniqueFeeVotesRankingOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_UNIQUE_FEE_VOTES_RANKING_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetUniqueFeeVotesRanking(live, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_UNIQUE_FEE_VOTES_RANKING_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_UNIQUE_FEE_VOTES_RANKING_INPUT_SIZE,
+        inputFields: [],
+        outputFields: MS_VAULT_GET_UNIQUE_FEE_VOTES_RANKING_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: {},
+        ...options,
+    });
+}
+export const MS_VAULT_GET_ASSET_RELEASE_STATUS_INPUT_TYPE = 28;
+export const MS_VAULT_GET_ASSET_RELEASE_STATUS_INPUT_SIZE = 8;
+const MS_VAULT_GET_ASSET_RELEASE_STATUS_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultGetAssetReleaseStatusInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_GET_ASSET_RELEASE_STATUS_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_GET_ASSET_RELEASE_STATUS_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'assets',
+        type: 'array',
+        offset: 8,
+        byteLength: 640,
+        arrayLength: 16,
+        arrayItemByteLength: 40,
+        arrayItemStructRef: 'Asset',
+    },
+    {
+        name: 'amounts',
+        type: 'array',
+        offset: 648,
+        byteLength: 128,
+        arrayLength: 16,
+        arrayItemType: 'uint64',
+        arrayItemByteLength: 8,
+    },
+    {
+        name: 'destinations',
+        type: 'array',
+        offset: 776,
+        byteLength: 512,
+        arrayLength: 16,
+        arrayItemType: 'id',
+        arrayItemByteLength: 32,
+    },
+];
+export function decodeMsVaultGetAssetReleaseStatusOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_ASSET_RELEASE_STATUS_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetAssetReleaseStatus(live, input, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_ASSET_RELEASE_STATUS_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_ASSET_RELEASE_STATUS_INPUT_SIZE,
+        inputFields: MS_VAULT_GET_ASSET_RELEASE_STATUS_INPUT_FIELDS,
+        outputFields: MS_VAULT_GET_ASSET_RELEASE_STATUS_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: input,
+        ...options,
+    });
+}
+export const MS_VAULT_GET_VAULT_ASSET_BALANCES_INPUT_TYPE = 29;
+export const MS_VAULT_GET_VAULT_ASSET_BALANCES_INPUT_SIZE = 8;
+const MS_VAULT_GET_VAULT_ASSET_BALANCES_INPUT_FIELDS = [
+    {
+        name: 'vaultId',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+];
+export function buildMsVaultGetVaultAssetBalancesInput(input, identityToPublicKey = (_identity) => new Uint8Array(32)) {
+    return buildPayload(MS_VAULT_GET_VAULT_ASSET_BALANCES_INPUT_FIELDS, STRUCTS, input, identityToPublicKey);
+}
+const MS_VAULT_GET_VAULT_ASSET_BALANCES_OUTPUT_FIELDS = [
+    {
+        name: 'status',
+        type: 'uint64',
+        offset: 0,
+        byteLength: 8,
+    },
+    {
+        name: 'numberOfAssetTypes',
+        type: 'uint64',
+        offset: 8,
+        byteLength: 8,
+    },
+    {
+        name: 'assetBalances',
+        type: 'array',
+        offset: 16,
+        byteLength: 384,
+        arrayLength: 8,
+        arrayItemByteLength: 48,
+        arrayItemStructRef: 'AssetBalance',
+    },
+];
+export function decodeMsVaultGetVaultAssetBalancesOutput(data, publicKeyToIdentity = (_pk) => 'A'.repeat(60)) {
+    return decodePayload(data, MS_VAULT_GET_VAULT_ASSET_BALANCES_OUTPUT_FIELDS, STRUCTS, publicKeyToIdentity);
+}
+export async function msVaultGetVaultAssetBalances(live, input, options) {
+    return callContractFunction({
+        live,
+        contractIndex: MS_VAULT_CONTRACT_INDEX,
+        inputType: MS_VAULT_GET_VAULT_ASSET_BALANCES_INPUT_TYPE,
+        inputSize: MS_VAULT_GET_VAULT_ASSET_BALANCES_INPUT_SIZE,
+        inputFields: MS_VAULT_GET_VAULT_ASSET_BALANCES_INPUT_FIELDS,
+        outputFields: MS_VAULT_GET_VAULT_ASSET_BALANCES_OUTPUT_FIELDS,
+        structs: STRUCTS,
+        input: input,
+        ...options,
+    });
+}
+export const msVault = {
+    contractIndex: MS_VAULT_CONTRACT_INDEX,
+    isShareHolder: msVaultIsShareHolder,
+    getManagedAssetBalance: msVaultGetManagedAssetBalance,
+    getVaults: msVaultGetVaults,
+    getReleaseStatus: msVaultGetReleaseStatus,
+    getBalanceOf: msVaultGetBalanceOf,
+    getVaultName: msVaultGetVaultName,
+    getRevenueInfo: msVaultGetRevenueInfo,
+    getFees: msVaultGetFees,
+    getVaultOwners: msVaultGetVaultOwners,
+    getFeeVotes: msVaultGetFeeVotes,
+    getFeeVotesOwner: msVaultGetFeeVotesOwner,
+    getFeeVotesScore: msVaultGetFeeVotesScore,
+    getUniqueFeeVotes: msVaultGetUniqueFeeVotes,
+    getUniqueFeeVotesRanking: msVaultGetUniqueFeeVotesRanking,
+    getAssetReleaseStatus: msVaultGetAssetReleaseStatus,
+    getVaultAssetBalances: msVaultGetVaultAssetBalances,
+    buildRegisterVaultInput: buildMsVaultRegisterVaultInput,
+    decodeRegisterVaultOutput: decodeMsVaultRegisterVaultOutput,
+    buildDepositInput: buildMsVaultDepositInput,
+    decodeDepositOutput: decodeMsVaultDepositOutput,
+    buildReleaseToInput: buildMsVaultReleaseToInput,
+    decodeReleaseToOutput: decodeMsVaultReleaseToOutput,
+    buildResetReleaseInput: buildMsVaultResetReleaseInput,
+    decodeResetReleaseOutput: decodeMsVaultResetReleaseOutput,
+    buildVoteFeeChangeInput: buildMsVaultVoteFeeChangeInput,
+    decodeVoteFeeChangeOutput: decodeMsVaultVoteFeeChangeOutput,
+    buildDepositAssetInput: buildMsVaultDepositAssetInput,
+    decodeDepositAssetOutput: decodeMsVaultDepositAssetOutput,
+    buildRevokeAssetManagementRightsInput: buildMsVaultRevokeAssetManagementRightsInput,
+    decodeRevokeAssetManagementRightsOutput: decodeMsVaultRevokeAssetManagementRightsOutput,
+    buildReleaseAssetToInput: buildMsVaultReleaseAssetToInput,
+    decodeReleaseAssetToOutput: decodeMsVaultReleaseAssetToOutput,
+    buildResetAssetReleaseInput: buildMsVaultResetAssetReleaseInput,
+    decodeResetAssetReleaseOutput: decodeMsVaultResetAssetReleaseOutput,
+};
+//# sourceMappingURL=msvault.js.map