gen

type AccountVarDecl struct {
	Value string
}

type AccountVarFill struct {
	Var   *builder.Var[builder.ExprTypeAccount]
	Value string
}

type BalanceKey struct {
	Account string
	Asset   string
}

type DestAllotmentClause struct {
	Portion *big.Rat
	// Same constraint as SourceAllotmentClause.PortionAsVar.
	PortionAsVar bool
	// Same meaning as SourceAllotmentClause.Div.
	Div        *PortionDiv
	KeptOrDest KeptOrDest
}

type DestInorderClause struct {
	Max        Monetary
	KeptOrDest KeptOrDest
}

type DestKind int

type Destination struct {
	Kind DestKind

	// DestAccount only
	Account      string
	AccountAsVar bool

	// DestInorder, DestOneof
	InorderClauses []DestInorderClause
	Remaining      *KeptOrDest

	// DestAllotment only
	AllotClauses []DestAllotmentClause
	// DestAllotment only: non-nil adds a trailing `remaining` clause, and the
	// clause portions sum to strictly less than 1.
	AllotRemaining *KeptOrDest
}

type ExtraStatement struct {
	Kind ExtraStatementKind

	// ExtraSave: the amount to save, either a literal (Monetary) or a
	// reference to Script.Vars[*VarIdx] (a declared VarFromBalance var) —
	// exactly one of the two is set. ExtraSendFromAccountVar,
	// ExtraSendToAccountVar: the send amount (always a literal).
	Monetary *Monetary

	// ExtraSave, ExtraSendVar (must index a VarFromBalance decl),
	// ExtraSetTxMetaVar (must index a VarFromMeta decl)
	VarIdx *int

	// ExtraSendFromAccountVar, ExtraSendToAccountVar: index into
	// Script.AccountVars for the account-typed var used as source/
	// destination (respectively); the other side is the literal Account.
	AccountVarIdx *int

	// ExtraSave (source account), ExtraSetAccountMeta, ExtraSendVar (source),
	// ExtraSendFromAccountVar (destination), ExtraSendToAccountVar (source)
	Account      string
	AccountAsVar bool

	// ExtraSaveAll
	Asset      string
	AssetAsVar bool

	// ExtraSetTxMeta, ExtraSetAccountMeta, ExtraSetTxMetaVar
	Key   string
	Value NumExpr
	// ExtraSetTxMeta, ExtraSetAccountMeta: when non-nil the meta value is this
	// string rather than the Value expression, exercising string-typed values.
	StringValue      *string
	StringValueAsVar bool

	// ExtraSendVar: `send $<Vars[VarIdx]> (source = Account, destination = Destination)`
	Destination      string
	DestinationAsVar bool
}

type ExtraStatementKind int

type Focus struct {
	Account string
	Asset   string
}

type Generated struct {
	Vars     map[string]string
	Balances map[BalanceKey]*big.Int
	Metadata map[MetaKey]string
	Script   string
	Shape    Shape

	// Flags are the feature flags the script needs on the numscript engines
	// (interpreter and compiler+VM). Derived from Shape.
	Flags []string
	// OracleCompatible is false when the script uses shapes outside the legacy
	// machine's grammar or decided behavior (oneof, colors, division portions,
	// wrong-asset caps): the harness then runs only the two numscript engines
	// and compares them against each other.
	OracleCompatible bool
}

type KeptOrDest struct {
	Kind KeptOrDestKind
	Dest *Destination // valid only when Kind == To
}

type KeptOrDestKind int

type MetaKey struct {
	Account string
	Key     string
}

type MetaType int

type Monetary struct {
	Asset      string
	AssetAsVar bool
	// Ignored for negative amounts: they have no literal form to bind.
	AsVar  bool
	Amount *big.Int
}

type NumExpr struct {
	Kind NumExprKind

	// NumLit only
	Lit *big.Int
	// NumLit only.
	LitAsVar bool

	// NumAdd, NumSub only
	Left, Right *NumExpr
}

type NumExprKind int

type PortionDiv struct {
	Num *big.Int
	Den *big.Int
}

type Program []Statement

type ScenarioStmt struct {
	Kind  string
	Send  *Statement
	Extra *ExtraStatement
}

type Script struct {
	Vars        []VarDecl
	AccountVars []AccountVarDecl
	Seeds       Program
	Program     Program
	Extra       []ExtraStatement
	Order       []bool
	Strategy    Strategy
	Focus       *Focus
	Scenario    []ScenarioStmt
	ScenarioPos int
	Balances    map[BalanceKey]*big.Int
	Metadata    map[MetaKey]string
}

type Shape struct {
	Strategy Strategy

	HasSave             bool
	HasBoundedOverdraft bool
	// A save and a bounded-overdraft source on the same account, any assets.
	SaveOverdraftSameAccount bool
	// Same, on the same (account, asset).
	SaveOverdraftSameResource bool
	// Same, with the save executing before the overdraft draw.
	SaveOverdraftSameResourceInOrder bool
	// An in-order pair whose literal save amount exceeds the pair's starting
	// balance (preset plus seed funding), with no earlier statement touching
	// the pair. A var-valued or `*` save never counts.
	SaveOverdrawsInitial bool

	// An allotment (source or destination side) with a `remaining` clause.
	HasAllotmentRemaining bool
	// An allotment clause whose portion is a var rather than an n/d literal.
	HasPortionVar bool
	// A statement references a vars-block origin that reads through another
	// origin var (VarDecl.AccountFromVarIdx). Counted on references, not
	// declarations: an unreferenced origin var is never rendered into the
	// script.
	HasChainedOrigin bool

	// numscript-only shapes (see sourceOptions.numscriptOnly). Any of these
	// makes the script skip the oracle legs: the legacy machine's grammar has
	// no oneof, colors or division expressions, and its clause-evaluation
	// order on wrong-asset caps is not the behavior under test.
	HasOneof         bool
	HasColoredSource bool
	HasWrongAssetCap bool
	HasPortionDiv    bool

	// Scenario kinds in block order, empty without a scenario block.
	SetupKinds    []string
	ObserverKinds []string
}

type Source struct {
	Kind SourceKind

	// SrcAccount, SrcAccountOverdraft
	Account      string
	AccountAsVar bool

	// SrcAccount, SrcAccountOverdraft: non-empty adds a `\ "COLOR"` clause.
	// numscript-only (experimental-asset-colors): scripts containing it skip
	// the oracle legs.
	Color      string
	ColorAsVar bool

	// SrcAccountOverdraft only: nil means unbounded overdraft
	Overdraft *Monetary

	// SrcCapped only
	Cap   *Monetary
	Inner *Source

	// SrcInorder, SrcOneof
	Sources []Source

	// SrcAllotment only
	Clauses []SourceAllotmentClause
	// SrcAllotment only: non-nil adds a trailing `remaining from` clause, and
	// the clause portions sum to strictly less than 1.
	AllotmentRemaining *Source
}

type SourceAllotmentClause struct {
	Portion *big.Rat
	// Rendered as a runtime-bound portion var instead of an n/d literal. Only
	// legal in an allotment with a remaining clause: without one, the oracle
	// rejects the block at compile time ("might be less than 100%").
	PortionAsVar bool
	// When non-nil, the clause portion is Div rendered as a division expression
	// and Portion/PortionAsVar are ignored.
	Div    *PortionDiv
	Source Source
}

type SourceKind int

type Statement struct {
	// If IsSendAll, Asset is used (unbounded send). Otherwise Amount is used.
	IsSendAll bool
	Amount    Monetary
	Asset     string
	// IsSendAll only.
	AssetAsVar  bool
	Source      Source
	Destination Destination
}

type Strategy int

type VarDecl struct {
	Kind    VarDeclKind
	Account string
	// Makes `balance($accountN, ...)` and a literal `@acc` elsewhere alias
	// one account.
	AccountAsVar bool
	// Chains this origin onto an earlier declaration: the account read by
	// balance()/meta() is the origin var at this index, which must be an
	// earlier VarFromMeta declaration of MetaType MetaAccount. Account then
	// holds the account name that parent's meta value resolves to (known at
	// generation time), so the balance/metadata this declaration observes can
	// still be steered; AccountAsVar is ignored.
	AccountFromVarIdx *int

	// VarFromBalance only
	Asset      string
	AssetAsVar bool

	// VarFromMeta only
	Key string
	// VarFromMeta only. Must match how the preset value at (Account, Key) is
	// written.
	MetaType MetaType
}

type VarDeclKind int