Skip to main content
Version: pre-release (v0.79)

Propose new futures successor market

Propose a cash-settled futures market to succeed an existing market, taking along the equity-like share and a portion of the insurance pool.

Requirements​

You will need:

  • A connected Vega wallet, with your wallet name and public key to hand
  • A minimum of whichever is larger, associated with that public key, based on the network parameter values for governance.proposal.market.minProposerBalance or spam.protection.proposal.min.tokens
  • Familiarity with successor market governance on Vega

Anatomy of a new successor market proposal​

The new successor market proposal requires the same fields as a new market proposal, with the addition of two fields described below.

See the new market proposal tutorial for what each field accepts and needs to contain.

  • Settlement asset must match that of the parent market.
  • Instrument name and code should be different to the parent market.

Successor market fields​

The following successor parameters need to be used if you are proposing a market that will succeed an existing market. A successor market that passes governance and is enacted will take the LPs' equity-like share from the parent market, and whatever percentage of the insurance market you choose in the proposal.

  • Parent market ID: Required to define the proposal as for a successor market
  • Insurance pool fraction: Required percentage of the parent market's insurance pool, up to 100%, can be earmarked for transfer to the successor market. It is submitted as a number between and including 0 and 1, which represents the factor for the percentage.

Submitting proposals in a batch​

If you want to submit this proposal as part of a larger batch of proposals, follow this sample structure:

{
    "batchProposalSubmission": {
        "rationale": {
            "title": "High level title",
            "description": "Description of all parts of this batch of proposals"
        },
        "terms": {
            "closingTimestamp": "123",
            "changes": [
                {
                    "enactmentTimestamp": 123,
                    "cancelTransfer": {
                        "changes": {
                            "transferId": "345"
                        }
                    }
                },
                {
                    "enactmentTimestamp": 123,
                    "cancelTransfer": {
                        "changes": {
                            "transferId": "789"
                        }
                    }
                }
            ]
        }
    }
}

Templates and submitting​

In the tabs below you'll see:

  • Annotated example describing what each field is for
  • JSON example
  • Command line examples for different operating systems

Replace the example data with the relevant details before submitting.

{
 proposalSubmission: {
  rationale: {
   title: "Lorem Ipsum successor",
   description: "A successor market"
  },
  terms: {
   newMarket: {
    changes: {
     // Successor configuration. If this proposal is meant to succeed a given market, then this should be set.
     successor: {
      // ID of the market that the successor should take over from.
      parentMarketId: "marketid",

      // A decimal value between or equal to 0 and 1, specifying the fraction of the insurance pool balance that is carried over from the parent market to the successor.
      insurancePoolFraction: "1"
     },

     // Linear slippage factor is used to cap the slippage component of maintenance margin - it is applied to the slippage volume.
     linearSlippageFactor: 0.001,

     // Decimal places used for the new futures market, sets the smallest price increment on the book. (uint64 as string)
     decimalPlaces: "5",

     // Decimal places for order sizes, sets what size the smallest order / position on the futures market can be. (int64 as string)
     positionDecimalPlaces: "5",

     // Instrument configuration
     instrument: {
      // Instrument name.
      name: "Oranges Daily",

      // Instrument code, human-readable shortcode used to describe the instrument.
      code: "ORANGES.24h",

      // Future product configuration
      future: {
       // Asset ID for the product's settlement asset. (string)
       settlementAsset: "8b52d4a3a4b0ffe733cddbc2b67be273816cfeb6ca4c8b339bac03ffba08e4e4",

       // Product quote name. (string)
       quoteName: "tEuro",

       // Data source spec describing the data source for settlement. (object)
       dataSourceSpecForSettlementData: {
        // DataSourceDefinitionExternal is the top level object used for all external 
        // data sources. It contains one of any of the defined `SourceType` variants. 
        external: {
         // Contains the data specification that is received from Ethereum sources.
         ethOracle: {
          // The ID of the EVM based chain which is to be used to source the oracle data. (uint64 as string)
          // The ID of the EVM based chain which is to be used to source the oracle data. 
          sourceChainId: "1",

          // Ethereum address of the contract to call.
          address: "0x1b44F3514812d835EB1BDB0acB33d3fA3351Ee43",

          // The ABI of that contract.
          abi: "[{" inputs ":[]," name ":" latestRoundData "," outputs ":[{" internalType ":" int256 "," name ":" "," type ":" int256 "}]," stateMutability ":" view "," type ":" function "}]",

          // Name of the method on the contract to call.
          method: "latestRoundData",


          /* Normalisers are used to convert the data returned from the contract method
           * into a standard format. The key of the map is the name of the property,
           * which identifies the specific piece of data to other parts of the data
           * sourcing framework, for example filters. The value is a JSONPath expression
           * for expressing where in the contract call result the required data is
           * located, for example $[0] indicates the first result. $[1].price would look
           * in the second result returned from the contract for a structure with a key
           * called 'price' and use that if it exists. */
          normalisers: [
           {
            name: "prices.ORANGES.value",
            expression: "$[0]"
           }
          ],

          // Number of confirmations required before the query is considered verified
          requiredConfirmations: 3,

          // Conditions for determining when to call the contract method.
          trigger: {
           /* Trigger for an Ethereum call based on the Ethereum block timestamp. Can be
            * one-off or repeating. */
           timeTrigger: {
            /* Repeat the call every n seconds after the initial call. If no time for
             * initial call was specified, begin repeating immediately. */
            every: 30
           }
          },

          // Filters the data returned from the contract method
          filters: [
           {
            key: {
             name: "prices.ORANGES.value",
             type: "TYPE_INTEGER",
             numberDecimalPlaces: 8
            },
            conditions: [
             {
              operator: "OPERATOR_GREATER_THAN_OR_EQUAL",
              value: "0"
             }
            ]
           }
          ]
         }
        }
       },

       // The external data source spec describing the data source of trading termination. (object)
       dataSourceSpecForTradingTermination: {
        // The external data source spec describing the data source of trading termination.
        internal {
         // Internal data source used for emitting timestamps.
         time: {
          // Conditions that the timestamps should meet in order to be considered.
          conditions: [
           {
            // Type of comparison to make on the value. (string)
            operator: "OPERATOR_GREATER_THAN_OR_EQUAL",

            // Value to be compared with by the operator. (string)
            value: "1648684800",
           }
          ]
         }
        },

        // DataSourceSpecToFutureBinding describes which property of the data source data is to be
        used as settlement data and which to use as the trading terminated trigger(object) dataSourceSpecBinding: {
         // Name of the property in the source data that should be used as settlement data.
         // If it is set to "prices.BTC.value", then the Future will use the value of
         // this property as settlement data. (string)
         settlementDataProperty: "prices.ORANGES.value",

         // Name of the property in the data source data that signals termination of trading. (string)
         tradingTerminationProperty: "vegaprotocol.builtin.timestamp"
        }
       },

       // Optional new futures market metadata, tags.
       metadata: [
        "enactment:2024-11-17T15:09:31Z",
        "settlement:2024-11-16T15:09:31Z",
        "source:docs.vega.xyz"
       ],

       // PriceMonitoringParameters contains a collection of triggers to be used for a given market
       priceMonitoringParameters: {
        // PriceMonitoringTrigger holds together price projection horizon τ, probability level p, and auction extension duration
        triggers: [
         {
          // Price monitoring projection horizon τ in seconds. (int64 as string)
          horizon: "43200",

          // Price monitoring probability level p. (string)
          probability: "0.9999999",


          /* Price monitoring auction extension duration in seconds should the price
           * breach its theoretical level over the specified horizon at the specified
           * probability level. (string) */
          auctionExtension: "3600",
         }
        ]
       },

       // Risk model for log normal
       logNormal: {
        // Tau parameter of the risk model, projection horizon measured as a year fraction used in the expected shortfall
        calculation to obtain the maintenance margin,
        must be a strictly non - negative real number.(number) tau: 0.0001140771161,

        // Risk Aversion Parameter. (double as number)
        riskAversionParameter: "0.00001",

        // Risk model parameters for log normal
        params: {
         // Mu parameter, annualised growth rate of the underlying asset. (double as number)
         mu: 0,

         // R parameter, annualised growth rate of the risk-free asset, used for discounting of future cash flows, can be any real number. (double as number)
         r: 0.016,

         // Sigma parameter, annualised volatility of the underlying asset, must be a strictly non-negative real number. (double as number)
         sigma: 0.15,
        }
       },

       // Liquidity SLA parameters
       liquiditySlaParameters: {
        // (string)
        priceRange: 0.1,

        // Specifies the minimum fraction of time LPs must spend "on the book" providing their committed liquidity. (string)
        commitmentMinTimeFraction: "0.1",

        // Specifies the number of liquidity epochs over which past performance will continue to affect rewards. (uint64 as string)
        performanceHysteresisEpochs: "10",

        // Specifies the maximum fraction of their accrued fees an LP that meets the SLA implied by market.liquidity.commitmentMinTimeFraction will lose to liquidity providers
        // that achieved a higher SLA performance than them. (string)
        slaCompetitionFactor: "0.2",
       },

       // Liquidation strategy for this market.
       liquidationStrategy: {
        // Interval, in seconds, at which the network will attempt to close its position. (int64 as string)
        disposalTimeStep: 500,

        // Fraction of the open position the market will try to close in a single attempt; range 0 through 1. (string)
        disposalFraction: "1",

        // Size of the position that the network will try to close in a single attempt. (uint64 as string)
        fullDisposalSize: "18446744073709551615",

        // Max fraction of the total volume of the orderbook, within liquidity bounds, that the network can use to close its position; range 0 through 1. (string)
        maxFractionConsumed: "1",


        /* Decimal > 0 specifying the range range above and below the mid price within which the network will trade to dispose of its position.
         * The value can be > 1. For example, if set to 1.5, the minimum price will be 0, ie max(0, mid_price * (1 - 1.5)), and the maximum price will be mid_price * (1 + 1.5). (string) */
        disposalSlippageRange: "0.1",
       },

       // Specifies how the liquidity fee for the market will be calculated.
       liquidityFeeSettings: {
        // Method used to calculate the market's liquidity fee.
        method: "METHOD_CONSTANT",

        // Constant liquidity fee used when using the constant fee method. (string)
        feeConstant: "0.00005",
       },

       // Liquidity monitoring parameters.
       liquidityMonitoringParameters: {
        // Specifies parameters related to target stake calculation.
        targetStakeParameters: {
         timeWindow: "3600",
         scalingFactor: "0.05"
        },
       },

       // Mark price configuration.
       markPriceConfiguration: {
        // Decay weight used for calculation of mark price.
        decayWeight: "1",

        // Decay power used for the calculation of mark price. (string)
        decayPower: "1",

        // Cash amount, in asset decimals, used for the calculation of the mark price from the order book. (string)
        cashAmount: "5000000",

        // Weights for each composite price data source. (array)
        sourceWeights: [
         "0",
         "1",
         "0"
        ],

        // For how long a price source is considered valid. One entry for each data source
        // such that the first is for the trade based mark price, the second is for the book based price
        // the third is for the first oracle, followed by more oracle data source staleness tolerance. (array)
        sourceStalenessTolerance: [
         "1m0s",
         "1m0s",
         "1m0s"
        ],

        // Which method is used for the calculation of the composite price for the market. (string)
        compositePriceType: "COMPOSITE_PRICE_TYPE_WEIGHTED",

        // Additional price sources to be used for internal composite price calculation. (array)
        dataSourcesSpec: [],

        // List of each price source and its corresponding binding (array)
        dataSourcesSpecBinding: []
       },

       // The market tick size defines the minimum change in quote price for the market
       tickSize: "1",


       /* If enabled aggressive orders sent to the market will be delayed by the configured number of blocks */
       enableTransactionReordering: true
      },

      // Timestamp as Unix time in seconds when voting closes for this proposal,
      // constrained by `minClose` and `maxClose` network parameters. (int64 as string)
      closingTimestamp: 1731769771,

      // Timestamp as Unix time in seconds when proposal gets enacted if passed,
      // constrained by `minEnact` and `maxEnact` network parameters. (int64 as string)
      enactmentTimestamp: 1731856171,
     }
    }
   }

Voting​

All proposals are voted on by the community.

To vote, community members need, at a minimum, the larger of the values of the following network parameters governance.proposal.market.minVoterBalance or spam.protection.voting.min.tokens associated to their Vega key.

Your proposal will need participation determined by the value of the parameter governance.proposal.market.requiredParticipation and a majority of the value of the parameter governance.proposal.market.requiredMajority.

Enactment​

If successful, the proposal will be enacted at the time you specify in the enactmentTimestamp field, depending on the status of other successor market proposals.