From f1dc2e163daf9ced5896efbdf16273ad6f66b00b Mon Sep 17 00:00:00 2001 From: Justin Franco Date: Mon, 19 Oct 2026 12:46:11 -0600 Subject: [PATCH 1/4] DS-4344 Updates for per digest PDAs and verification --- Cargo.lock | 4 +- client/go/verifier/ActivateConfig.go | 165 ++++ ...gActive_test.go => ActivateConfig_test.go} | 8 +- client/go/verifier/CloseConfig.go | 165 ++++ ...testConfig_test.go => CloseConfig_test.go} | 8 +- client/go/verifier/DeactivateConfig.go | 165 ++++ client/go/verifier/DeactivateConfig_test.go | 32 + client/go/verifier/SetConfig.go | 95 +- client/go/verifier/SetConfigActive.go | 169 ---- .../verifier/SetConfigWithActivationTime.go | 192 ---- ...veLatestConfig.go => SetLegacyFallback.go} | 73 +- ...Time_test.go => SetLegacyFallback_test.go} | 8 +- client/go/verifier/UpdateConfig.go | 211 +++++ client/go/verifier/UpdateConfig_test.go | 32 + client/go/verifier/accounts.go | 127 ++- client/go/verifier/instructions.go | 46 +- programs/verifier/Cargo.lock | 2 +- programs/verifier/Cargo.toml | 5 +- programs/verifier/README.md | 22 + .../src/context/close_config_context.rs | 15 + programs/verifier/src/context/mod.rs | 8 +- .../src/context/set_config_context.rs | 22 + .../context/update_digest_config_context.rs | 15 + programs/verifier/src/errors.rs | 7 + programs/verifier/src/events.rs | 28 +- programs/verifier/src/evm/encoding.rs | 32 +- programs/verifier/src/evm/encoding_test.rs | 161 ++++ programs/verifier/src/evm/signature_test.rs | 114 +++ programs/verifier/src/lib.rs | 281 +++--- programs/verifier/src/state/digest_config.rs | 26 + programs/verifier/src/state/mod.rs | 2 + .../verifier/src/state/verifier_account.rs | 7 +- programs/verifier/tests/common/fixtures.rs | 25 + programs/verifier/tests/common/mod.rs | 1 + .../tests/verifier_activate_config_test.rs | 181 ++++ .../tests/verifier_close_config_test.rs | 228 +++++ .../tests/verifier_legacy_fallback_test.rs | 446 ++++++++++ .../verifier_remove_latest_config_test.rs | 174 ---- .../tests/verifier_set_config_active_test.rs | 118 --- .../tests/verifier_set_config_test.rs | 349 +++++++- ...er_set_config_with_activation_time_test.rs | 778 ----------------- .../tests/verifier_update_config_test.rs | 239 +++++ .../verifier/tests/verifier_verify_test.rs | 825 +++++++++--------- target/idl/verifier.json | 309 ++++++- test_utils/Cargo.toml | 1 + test_utils/src/client/verifier_client.rs | 249 ++++-- test_utils/src/report.rs | 15 +- 47 files changed, 4006 insertions(+), 2179 deletions(-) create mode 100644 client/go/verifier/ActivateConfig.go rename client/go/verifier/{SetConfigActive_test.go => ActivateConfig_test.go} (76%) create mode 100644 client/go/verifier/CloseConfig.go rename client/go/verifier/{RemoveLatestConfig_test.go => CloseConfig_test.go} (75%) create mode 100644 client/go/verifier/DeactivateConfig.go create mode 100644 client/go/verifier/DeactivateConfig_test.go delete mode 100644 client/go/verifier/SetConfigActive.go delete mode 100644 client/go/verifier/SetConfigWithActivationTime.go rename client/go/verifier/{RemoveLatestConfig.go => SetLegacyFallback.go} (50%) rename client/go/verifier/{SetConfigWithActivationTime_test.go => SetLegacyFallback_test.go} (72%) create mode 100644 client/go/verifier/UpdateConfig.go create mode 100644 client/go/verifier/UpdateConfig_test.go create mode 100644 programs/verifier/src/context/close_config_context.rs create mode 100644 programs/verifier/src/context/set_config_context.rs create mode 100644 programs/verifier/src/context/update_digest_config_context.rs create mode 100644 programs/verifier/src/evm/encoding_test.rs create mode 100644 programs/verifier/src/evm/signature_test.rs create mode 100644 programs/verifier/src/state/digest_config.rs create mode 100644 programs/verifier/tests/common/fixtures.rs create mode 100644 programs/verifier/tests/verifier_activate_config_test.rs create mode 100644 programs/verifier/tests/verifier_close_config_test.rs create mode 100644 programs/verifier/tests/verifier_legacy_fallback_test.rs delete mode 100644 programs/verifier/tests/verifier_remove_latest_config_test.rs delete mode 100644 programs/verifier/tests/verifier_set_config_active_test.rs delete mode 100644 programs/verifier/tests/verifier_set_config_with_activation_time_test.rs create mode 100644 programs/verifier/tests/verifier_update_config_test.rs diff --git a/Cargo.lock b/Cargo.lock index 1d2dec8..0e3b568 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5603,6 +5603,7 @@ dependencies = [ "access-controller", "anchor-lang", "arrayref", + "bytemuck", "ethabi", "hex", "hex-literal", @@ -6101,12 +6102,13 @@ checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191" [[package]] name = "verifier" -version = "0.4.0" +version = "0.5.0" dependencies = [ "access-controller", "anchor-lang", "arrayvec 1.0.1", "bytemuck", + "chainlink_solana_data_streams", "ethabi", "hex", "hex-literal", diff --git a/client/go/verifier/ActivateConfig.go b/client/go/verifier/ActivateConfig.go new file mode 100644 index 0000000..5034298 --- /dev/null +++ b/client/go/verifier/ActivateConfig.go @@ -0,0 +1,165 @@ +// Code generated by https://github.com/gagliardetto/anchor-go. DO NOT EDIT. + +package verifier + +import ( + "errors" + ag_binary "github.com/gagliardetto/binary" + ag_solanago "github.com/gagliardetto/solana-go" + ag_format "github.com/gagliardetto/solana-go/text/format" + ag_treeout "github.com/gagliardetto/treeout" +) + +// ActivateConfig is the `activateConfig` instruction. +type ActivateConfig struct { + ConfigDigest *[32]uint8 + + // [0] = [] verifierAccount + // + // [1] = [WRITE] configAccount + // + // [2] = [SIGNER] owner + ag_solanago.AccountMetaSlice `bin:"-"` +} + +// NewActivateConfigInstructionBuilder creates a new `ActivateConfig` instruction builder. +func NewActivateConfigInstructionBuilder() *ActivateConfig { + nd := &ActivateConfig{ + AccountMetaSlice: make(ag_solanago.AccountMetaSlice, 3), + } + return nd +} + +// SetConfigDigest sets the "configDigest" parameter. +func (inst *ActivateConfig) SetConfigDigest(configDigest [32]uint8) *ActivateConfig { + inst.ConfigDigest = &configDigest + return inst +} + +// SetVerifierAccountAccount sets the "verifierAccount" account. +func (inst *ActivateConfig) SetVerifierAccountAccount(verifierAccount ag_solanago.PublicKey) *ActivateConfig { + inst.AccountMetaSlice[0] = ag_solanago.Meta(verifierAccount) + return inst +} + +// GetVerifierAccountAccount gets the "verifierAccount" account. +func (inst *ActivateConfig) GetVerifierAccountAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(0) +} + +// SetConfigAccountAccount sets the "configAccount" account. +func (inst *ActivateConfig) SetConfigAccountAccount(configAccount ag_solanago.PublicKey) *ActivateConfig { + inst.AccountMetaSlice[1] = ag_solanago.Meta(configAccount).WRITE() + return inst +} + +// GetConfigAccountAccount gets the "configAccount" account. +func (inst *ActivateConfig) GetConfigAccountAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(1) +} + +// SetOwnerAccount sets the "owner" account. +func (inst *ActivateConfig) SetOwnerAccount(owner ag_solanago.PublicKey) *ActivateConfig { + inst.AccountMetaSlice[2] = ag_solanago.Meta(owner).SIGNER() + return inst +} + +// GetOwnerAccount gets the "owner" account. +func (inst *ActivateConfig) GetOwnerAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(2) +} + +func (inst ActivateConfig) Build() *Instruction { + return &Instruction{BaseVariant: ag_binary.BaseVariant{ + Impl: inst, + TypeID: Instruction_ActivateConfig, + }} +} + +// ValidateAndBuild validates the instruction parameters and accounts; +// if there is a validation error, it returns the error. +// Otherwise, it builds and returns the instruction. +func (inst ActivateConfig) ValidateAndBuild() (*Instruction, error) { + if err := inst.Validate(); err != nil { + return nil, err + } + return inst.Build(), nil +} + +func (inst *ActivateConfig) Validate() error { + // Check whether all (required) parameters are set: + { + if inst.ConfigDigest == nil { + return errors.New("ConfigDigest parameter is not set") + } + } + + // Check whether all (required) accounts are set: + { + if inst.AccountMetaSlice[0] == nil { + return errors.New("accounts.VerifierAccount is not set") + } + if inst.AccountMetaSlice[1] == nil { + return errors.New("accounts.ConfigAccount is not set") + } + if inst.AccountMetaSlice[2] == nil { + return errors.New("accounts.Owner is not set") + } + } + return nil +} + +func (inst *ActivateConfig) EncodeToTree(parent ag_treeout.Branches) { + parent.Child(ag_format.Program(ProgramName, ProgramID)). + // + ParentFunc(func(programBranch ag_treeout.Branches) { + programBranch.Child(ag_format.Instruction("ActivateConfig")). + // + ParentFunc(func(instructionBranch ag_treeout.Branches) { + + // Parameters of the instruction: + instructionBranch.Child("Params[len=1]").ParentFunc(func(paramsBranch ag_treeout.Branches) { + paramsBranch.Child(ag_format.Param("ConfigDigest", *inst.ConfigDigest)) + }) + + // Accounts of the instruction: + instructionBranch.Child("Accounts[len=3]").ParentFunc(func(accountsBranch ag_treeout.Branches) { + accountsBranch.Child(ag_format.Meta("verifier", inst.AccountMetaSlice.Get(0))) + accountsBranch.Child(ag_format.Meta(" config", inst.AccountMetaSlice.Get(1))) + accountsBranch.Child(ag_format.Meta(" owner", inst.AccountMetaSlice.Get(2))) + }) + }) + }) +} + +func (obj ActivateConfig) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) { + // Serialize `ConfigDigest` param: + err = encoder.Encode(obj.ConfigDigest) + if err != nil { + return err + } + return nil +} +func (obj *ActivateConfig) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) { + // Deserialize `ConfigDigest`: + err = decoder.Decode(&obj.ConfigDigest) + if err != nil { + return err + } + return nil +} + +// NewActivateConfigInstruction declares a new ActivateConfig instruction with the provided parameters and accounts. +func NewActivateConfigInstruction( + // Parameters: + configDigest [32]uint8, + // Accounts: + verifierAccount ag_solanago.PublicKey, + configAccount ag_solanago.PublicKey, + owner ag_solanago.PublicKey) *ActivateConfig { + return NewActivateConfigInstructionBuilder(). + SetConfigDigest(configDigest). + SetVerifierAccountAccount(verifierAccount). + SetConfigAccountAccount(configAccount). + SetOwnerAccount(owner) +} diff --git a/client/go/verifier/SetConfigActive_test.go b/client/go/verifier/ActivateConfig_test.go similarity index 76% rename from client/go/verifier/SetConfigActive_test.go rename to client/go/verifier/ActivateConfig_test.go index dff47ab..6501e01 100644 --- a/client/go/verifier/SetConfigActive_test.go +++ b/client/go/verifier/ActivateConfig_test.go @@ -10,18 +10,18 @@ import ( "testing" ) -func TestEncodeDecode_SetConfigActive(t *testing.T) { +func TestEncodeDecode_ActivateConfig(t *testing.T) { fu := ag_gofuzz.New().NilChance(0) for i := 0; i < 1; i++ { - t.Run("SetConfigActive"+strconv.Itoa(i), func(t *testing.T) { + t.Run("ActivateConfig"+strconv.Itoa(i), func(t *testing.T) { { - params := new(SetConfigActive) + params := new(ActivateConfig) fu.Fuzz(params) params.AccountMetaSlice = nil buf := new(bytes.Buffer) err := encodeT(*params, buf) ag_require.NoError(t, err) - got := new(SetConfigActive) + got := new(ActivateConfig) err = decodeT(got, buf.Bytes()) got.AccountMetaSlice = nil ag_require.NoError(t, err) diff --git a/client/go/verifier/CloseConfig.go b/client/go/verifier/CloseConfig.go new file mode 100644 index 0000000..befb60d --- /dev/null +++ b/client/go/verifier/CloseConfig.go @@ -0,0 +1,165 @@ +// Code generated by https://github.com/gagliardetto/anchor-go. DO NOT EDIT. + +package verifier + +import ( + "errors" + ag_binary "github.com/gagliardetto/binary" + ag_solanago "github.com/gagliardetto/solana-go" + ag_format "github.com/gagliardetto/solana-go/text/format" + ag_treeout "github.com/gagliardetto/treeout" +) + +// Closes the config PDA for a config digest and refunds its rent to the owner +type CloseConfig struct { + ConfigDigest *[32]uint8 + + // [0] = [] verifierAccount + // + // [1] = [WRITE] configAccount + // + // [2] = [WRITE, SIGNER] owner + ag_solanago.AccountMetaSlice `bin:"-"` +} + +// NewCloseConfigInstructionBuilder creates a new `CloseConfig` instruction builder. +func NewCloseConfigInstructionBuilder() *CloseConfig { + nd := &CloseConfig{ + AccountMetaSlice: make(ag_solanago.AccountMetaSlice, 3), + } + return nd +} + +// SetConfigDigest sets the "configDigest" parameter. +func (inst *CloseConfig) SetConfigDigest(configDigest [32]uint8) *CloseConfig { + inst.ConfigDigest = &configDigest + return inst +} + +// SetVerifierAccountAccount sets the "verifierAccount" account. +func (inst *CloseConfig) SetVerifierAccountAccount(verifierAccount ag_solanago.PublicKey) *CloseConfig { + inst.AccountMetaSlice[0] = ag_solanago.Meta(verifierAccount) + return inst +} + +// GetVerifierAccountAccount gets the "verifierAccount" account. +func (inst *CloseConfig) GetVerifierAccountAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(0) +} + +// SetConfigAccountAccount sets the "configAccount" account. +func (inst *CloseConfig) SetConfigAccountAccount(configAccount ag_solanago.PublicKey) *CloseConfig { + inst.AccountMetaSlice[1] = ag_solanago.Meta(configAccount).WRITE() + return inst +} + +// GetConfigAccountAccount gets the "configAccount" account. +func (inst *CloseConfig) GetConfigAccountAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(1) +} + +// SetOwnerAccount sets the "owner" account. +func (inst *CloseConfig) SetOwnerAccount(owner ag_solanago.PublicKey) *CloseConfig { + inst.AccountMetaSlice[2] = ag_solanago.Meta(owner).WRITE().SIGNER() + return inst +} + +// GetOwnerAccount gets the "owner" account. +func (inst *CloseConfig) GetOwnerAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(2) +} + +func (inst CloseConfig) Build() *Instruction { + return &Instruction{BaseVariant: ag_binary.BaseVariant{ + Impl: inst, + TypeID: Instruction_CloseConfig, + }} +} + +// ValidateAndBuild validates the instruction parameters and accounts; +// if there is a validation error, it returns the error. +// Otherwise, it builds and returns the instruction. +func (inst CloseConfig) ValidateAndBuild() (*Instruction, error) { + if err := inst.Validate(); err != nil { + return nil, err + } + return inst.Build(), nil +} + +func (inst *CloseConfig) Validate() error { + // Check whether all (required) parameters are set: + { + if inst.ConfigDigest == nil { + return errors.New("ConfigDigest parameter is not set") + } + } + + // Check whether all (required) accounts are set: + { + if inst.AccountMetaSlice[0] == nil { + return errors.New("accounts.VerifierAccount is not set") + } + if inst.AccountMetaSlice[1] == nil { + return errors.New("accounts.ConfigAccount is not set") + } + if inst.AccountMetaSlice[2] == nil { + return errors.New("accounts.Owner is not set") + } + } + return nil +} + +func (inst *CloseConfig) EncodeToTree(parent ag_treeout.Branches) { + parent.Child(ag_format.Program(ProgramName, ProgramID)). + // + ParentFunc(func(programBranch ag_treeout.Branches) { + programBranch.Child(ag_format.Instruction("CloseConfig")). + // + ParentFunc(func(instructionBranch ag_treeout.Branches) { + + // Parameters of the instruction: + instructionBranch.Child("Params[len=1]").ParentFunc(func(paramsBranch ag_treeout.Branches) { + paramsBranch.Child(ag_format.Param("ConfigDigest", *inst.ConfigDigest)) + }) + + // Accounts of the instruction: + instructionBranch.Child("Accounts[len=3]").ParentFunc(func(accountsBranch ag_treeout.Branches) { + accountsBranch.Child(ag_format.Meta("verifier", inst.AccountMetaSlice.Get(0))) + accountsBranch.Child(ag_format.Meta(" config", inst.AccountMetaSlice.Get(1))) + accountsBranch.Child(ag_format.Meta(" owner", inst.AccountMetaSlice.Get(2))) + }) + }) + }) +} + +func (obj CloseConfig) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) { + // Serialize `ConfigDigest` param: + err = encoder.Encode(obj.ConfigDigest) + if err != nil { + return err + } + return nil +} +func (obj *CloseConfig) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) { + // Deserialize `ConfigDigest`: + err = decoder.Decode(&obj.ConfigDigest) + if err != nil { + return err + } + return nil +} + +// NewCloseConfigInstruction declares a new CloseConfig instruction with the provided parameters and accounts. +func NewCloseConfigInstruction( + // Parameters: + configDigest [32]uint8, + // Accounts: + verifierAccount ag_solanago.PublicKey, + configAccount ag_solanago.PublicKey, + owner ag_solanago.PublicKey) *CloseConfig { + return NewCloseConfigInstructionBuilder(). + SetConfigDigest(configDigest). + SetVerifierAccountAccount(verifierAccount). + SetConfigAccountAccount(configAccount). + SetOwnerAccount(owner) +} diff --git a/client/go/verifier/RemoveLatestConfig_test.go b/client/go/verifier/CloseConfig_test.go similarity index 75% rename from client/go/verifier/RemoveLatestConfig_test.go rename to client/go/verifier/CloseConfig_test.go index cb3c0f2..63a5fb9 100644 --- a/client/go/verifier/RemoveLatestConfig_test.go +++ b/client/go/verifier/CloseConfig_test.go @@ -10,18 +10,18 @@ import ( "testing" ) -func TestEncodeDecode_RemoveLatestConfig(t *testing.T) { +func TestEncodeDecode_CloseConfig(t *testing.T) { fu := ag_gofuzz.New().NilChance(0) for i := 0; i < 1; i++ { - t.Run("RemoveLatestConfig"+strconv.Itoa(i), func(t *testing.T) { + t.Run("CloseConfig"+strconv.Itoa(i), func(t *testing.T) { { - params := new(RemoveLatestConfig) + params := new(CloseConfig) fu.Fuzz(params) params.AccountMetaSlice = nil buf := new(bytes.Buffer) err := encodeT(*params, buf) ag_require.NoError(t, err) - got := new(RemoveLatestConfig) + got := new(CloseConfig) err = decodeT(got, buf.Bytes()) got.AccountMetaSlice = nil ag_require.NoError(t, err) diff --git a/client/go/verifier/DeactivateConfig.go b/client/go/verifier/DeactivateConfig.go new file mode 100644 index 0000000..967f075 --- /dev/null +++ b/client/go/verifier/DeactivateConfig.go @@ -0,0 +1,165 @@ +// Code generated by https://github.com/gagliardetto/anchor-go. DO NOT EDIT. + +package verifier + +import ( + "errors" + ag_binary "github.com/gagliardetto/binary" + ag_solanago "github.com/gagliardetto/solana-go" + ag_format "github.com/gagliardetto/solana-go/text/format" + ag_treeout "github.com/gagliardetto/treeout" +) + +// DeactivateConfig is the `deactivateConfig` instruction. +type DeactivateConfig struct { + ConfigDigest *[32]uint8 + + // [0] = [] verifierAccount + // + // [1] = [WRITE] configAccount + // + // [2] = [SIGNER] owner + ag_solanago.AccountMetaSlice `bin:"-"` +} + +// NewDeactivateConfigInstructionBuilder creates a new `DeactivateConfig` instruction builder. +func NewDeactivateConfigInstructionBuilder() *DeactivateConfig { + nd := &DeactivateConfig{ + AccountMetaSlice: make(ag_solanago.AccountMetaSlice, 3), + } + return nd +} + +// SetConfigDigest sets the "configDigest" parameter. +func (inst *DeactivateConfig) SetConfigDigest(configDigest [32]uint8) *DeactivateConfig { + inst.ConfigDigest = &configDigest + return inst +} + +// SetVerifierAccountAccount sets the "verifierAccount" account. +func (inst *DeactivateConfig) SetVerifierAccountAccount(verifierAccount ag_solanago.PublicKey) *DeactivateConfig { + inst.AccountMetaSlice[0] = ag_solanago.Meta(verifierAccount) + return inst +} + +// GetVerifierAccountAccount gets the "verifierAccount" account. +func (inst *DeactivateConfig) GetVerifierAccountAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(0) +} + +// SetConfigAccountAccount sets the "configAccount" account. +func (inst *DeactivateConfig) SetConfigAccountAccount(configAccount ag_solanago.PublicKey) *DeactivateConfig { + inst.AccountMetaSlice[1] = ag_solanago.Meta(configAccount).WRITE() + return inst +} + +// GetConfigAccountAccount gets the "configAccount" account. +func (inst *DeactivateConfig) GetConfigAccountAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(1) +} + +// SetOwnerAccount sets the "owner" account. +func (inst *DeactivateConfig) SetOwnerAccount(owner ag_solanago.PublicKey) *DeactivateConfig { + inst.AccountMetaSlice[2] = ag_solanago.Meta(owner).SIGNER() + return inst +} + +// GetOwnerAccount gets the "owner" account. +func (inst *DeactivateConfig) GetOwnerAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(2) +} + +func (inst DeactivateConfig) Build() *Instruction { + return &Instruction{BaseVariant: ag_binary.BaseVariant{ + Impl: inst, + TypeID: Instruction_DeactivateConfig, + }} +} + +// ValidateAndBuild validates the instruction parameters and accounts; +// if there is a validation error, it returns the error. +// Otherwise, it builds and returns the instruction. +func (inst DeactivateConfig) ValidateAndBuild() (*Instruction, error) { + if err := inst.Validate(); err != nil { + return nil, err + } + return inst.Build(), nil +} + +func (inst *DeactivateConfig) Validate() error { + // Check whether all (required) parameters are set: + { + if inst.ConfigDigest == nil { + return errors.New("ConfigDigest parameter is not set") + } + } + + // Check whether all (required) accounts are set: + { + if inst.AccountMetaSlice[0] == nil { + return errors.New("accounts.VerifierAccount is not set") + } + if inst.AccountMetaSlice[1] == nil { + return errors.New("accounts.ConfigAccount is not set") + } + if inst.AccountMetaSlice[2] == nil { + return errors.New("accounts.Owner is not set") + } + } + return nil +} + +func (inst *DeactivateConfig) EncodeToTree(parent ag_treeout.Branches) { + parent.Child(ag_format.Program(ProgramName, ProgramID)). + // + ParentFunc(func(programBranch ag_treeout.Branches) { + programBranch.Child(ag_format.Instruction("DeactivateConfig")). + // + ParentFunc(func(instructionBranch ag_treeout.Branches) { + + // Parameters of the instruction: + instructionBranch.Child("Params[len=1]").ParentFunc(func(paramsBranch ag_treeout.Branches) { + paramsBranch.Child(ag_format.Param("ConfigDigest", *inst.ConfigDigest)) + }) + + // Accounts of the instruction: + instructionBranch.Child("Accounts[len=3]").ParentFunc(func(accountsBranch ag_treeout.Branches) { + accountsBranch.Child(ag_format.Meta("verifier", inst.AccountMetaSlice.Get(0))) + accountsBranch.Child(ag_format.Meta(" config", inst.AccountMetaSlice.Get(1))) + accountsBranch.Child(ag_format.Meta(" owner", inst.AccountMetaSlice.Get(2))) + }) + }) + }) +} + +func (obj DeactivateConfig) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) { + // Serialize `ConfigDigest` param: + err = encoder.Encode(obj.ConfigDigest) + if err != nil { + return err + } + return nil +} +func (obj *DeactivateConfig) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) { + // Deserialize `ConfigDigest`: + err = decoder.Decode(&obj.ConfigDigest) + if err != nil { + return err + } + return nil +} + +// NewDeactivateConfigInstruction declares a new DeactivateConfig instruction with the provided parameters and accounts. +func NewDeactivateConfigInstruction( + // Parameters: + configDigest [32]uint8, + // Accounts: + verifierAccount ag_solanago.PublicKey, + configAccount ag_solanago.PublicKey, + owner ag_solanago.PublicKey) *DeactivateConfig { + return NewDeactivateConfigInstructionBuilder(). + SetConfigDigest(configDigest). + SetVerifierAccountAccount(verifierAccount). + SetConfigAccountAccount(configAccount). + SetOwnerAccount(owner) +} diff --git a/client/go/verifier/DeactivateConfig_test.go b/client/go/verifier/DeactivateConfig_test.go new file mode 100644 index 0000000..d4643e4 --- /dev/null +++ b/client/go/verifier/DeactivateConfig_test.go @@ -0,0 +1,32 @@ +// Code generated by https://github.com/gagliardetto/anchor-go. DO NOT EDIT. + +package verifier + +import ( + "bytes" + ag_gofuzz "github.com/gagliardetto/gofuzz" + ag_require "github.com/stretchr/testify/require" + "strconv" + "testing" +) + +func TestEncodeDecode_DeactivateConfig(t *testing.T) { + fu := ag_gofuzz.New().NilChance(0) + for i := 0; i < 1; i++ { + t.Run("DeactivateConfig"+strconv.Itoa(i), func(t *testing.T) { + { + params := new(DeactivateConfig) + fu.Fuzz(params) + params.AccountMetaSlice = nil + buf := new(bytes.Buffer) + err := encodeT(*params, buf) + ag_require.NoError(t, err) + got := new(DeactivateConfig) + err = decodeT(got, buf.Bytes()) + got.AccountMetaSlice = nil + ag_require.NoError(t, err) + ag_require.Equal(t, params, got) + } + }) + } +} diff --git a/client/go/verifier/SetConfig.go b/client/go/verifier/SetConfig.go index d2d4438..c9724d1 100644 --- a/client/go/verifier/SetConfig.go +++ b/client/go/verifier/SetConfig.go @@ -10,25 +10,36 @@ import ( ag_treeout "github.com/gagliardetto/treeout" ) -// SetConfig is the `setConfig` instruction. +// Sets the DON configuration for a config digest. Creates the config PDA derived from `[config_digest]` type SetConfig struct { - Signers *[][20]uint8 - F *uint8 + ConfigDigest *[32]uint8 + Signers *[][20]uint8 + F *uint8 - // [0] = [WRITE] verifierAccount + // [0] = [] verifierAccount // - // [1] = [SIGNER] owner + // [1] = [WRITE] configAccount + // + // [2] = [WRITE, SIGNER] owner + // + // [3] = [] systemProgram ag_solanago.AccountMetaSlice `bin:"-"` } // NewSetConfigInstructionBuilder creates a new `SetConfig` instruction builder. func NewSetConfigInstructionBuilder() *SetConfig { nd := &SetConfig{ - AccountMetaSlice: make(ag_solanago.AccountMetaSlice, 2), + AccountMetaSlice: make(ag_solanago.AccountMetaSlice, 4), } return nd } +// SetConfigDigest sets the "configDigest" parameter. +func (inst *SetConfig) SetConfigDigest(configDigest [32]uint8) *SetConfig { + inst.ConfigDigest = &configDigest + return inst +} + // SetSigners sets the "signers" parameter. func (inst *SetConfig) SetSigners(signers [][20]uint8) *SetConfig { inst.Signers = &signers @@ -43,7 +54,7 @@ func (inst *SetConfig) SetF(f uint8) *SetConfig { // SetVerifierAccountAccount sets the "verifierAccount" account. func (inst *SetConfig) SetVerifierAccountAccount(verifierAccount ag_solanago.PublicKey) *SetConfig { - inst.AccountMetaSlice[0] = ag_solanago.Meta(verifierAccount).WRITE() + inst.AccountMetaSlice[0] = ag_solanago.Meta(verifierAccount) return inst } @@ -52,15 +63,37 @@ func (inst *SetConfig) GetVerifierAccountAccount() *ag_solanago.AccountMeta { return inst.AccountMetaSlice.Get(0) } +// SetConfigAccountAccount sets the "configAccount" account. +func (inst *SetConfig) SetConfigAccountAccount(configAccount ag_solanago.PublicKey) *SetConfig { + inst.AccountMetaSlice[1] = ag_solanago.Meta(configAccount).WRITE() + return inst +} + +// GetConfigAccountAccount gets the "configAccount" account. +func (inst *SetConfig) GetConfigAccountAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(1) +} + // SetOwnerAccount sets the "owner" account. func (inst *SetConfig) SetOwnerAccount(owner ag_solanago.PublicKey) *SetConfig { - inst.AccountMetaSlice[1] = ag_solanago.Meta(owner).SIGNER() + inst.AccountMetaSlice[2] = ag_solanago.Meta(owner).WRITE().SIGNER() return inst } // GetOwnerAccount gets the "owner" account. func (inst *SetConfig) GetOwnerAccount() *ag_solanago.AccountMeta { - return inst.AccountMetaSlice.Get(1) + return inst.AccountMetaSlice.Get(2) +} + +// SetSystemProgramAccount sets the "systemProgram" account. +func (inst *SetConfig) SetSystemProgramAccount(systemProgram ag_solanago.PublicKey) *SetConfig { + inst.AccountMetaSlice[3] = ag_solanago.Meta(systemProgram) + return inst +} + +// GetSystemProgramAccount gets the "systemProgram" account. +func (inst *SetConfig) GetSystemProgramAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(3) } func (inst SetConfig) Build() *Instruction { @@ -83,6 +116,9 @@ func (inst SetConfig) ValidateAndBuild() (*Instruction, error) { func (inst *SetConfig) Validate() error { // Check whether all (required) parameters are set: { + if inst.ConfigDigest == nil { + return errors.New("ConfigDigest parameter is not set") + } if inst.Signers == nil { return errors.New("Signers parameter is not set") } @@ -97,8 +133,14 @@ func (inst *SetConfig) Validate() error { return errors.New("accounts.VerifierAccount is not set") } if inst.AccountMetaSlice[1] == nil { + return errors.New("accounts.ConfigAccount is not set") + } + if inst.AccountMetaSlice[2] == nil { return errors.New("accounts.Owner is not set") } + if inst.AccountMetaSlice[3] == nil { + return errors.New("accounts.SystemProgram is not set") + } } return nil } @@ -112,21 +154,29 @@ func (inst *SetConfig) EncodeToTree(parent ag_treeout.Branches) { ParentFunc(func(instructionBranch ag_treeout.Branches) { // Parameters of the instruction: - instructionBranch.Child("Params[len=2]").ParentFunc(func(paramsBranch ag_treeout.Branches) { - paramsBranch.Child(ag_format.Param("Signers", *inst.Signers)) - paramsBranch.Child(ag_format.Param(" F", *inst.F)) + instructionBranch.Child("Params[len=3]").ParentFunc(func(paramsBranch ag_treeout.Branches) { + paramsBranch.Child(ag_format.Param("ConfigDigest", *inst.ConfigDigest)) + paramsBranch.Child(ag_format.Param(" Signers", *inst.Signers)) + paramsBranch.Child(ag_format.Param(" F", *inst.F)) }) // Accounts of the instruction: - instructionBranch.Child("Accounts[len=2]").ParentFunc(func(accountsBranch ag_treeout.Branches) { - accountsBranch.Child(ag_format.Meta("verifier", inst.AccountMetaSlice.Get(0))) - accountsBranch.Child(ag_format.Meta(" owner", inst.AccountMetaSlice.Get(1))) + instructionBranch.Child("Accounts[len=4]").ParentFunc(func(accountsBranch ag_treeout.Branches) { + accountsBranch.Child(ag_format.Meta(" verifier", inst.AccountMetaSlice.Get(0))) + accountsBranch.Child(ag_format.Meta(" config", inst.AccountMetaSlice.Get(1))) + accountsBranch.Child(ag_format.Meta(" owner", inst.AccountMetaSlice.Get(2))) + accountsBranch.Child(ag_format.Meta("systemProgram", inst.AccountMetaSlice.Get(3))) }) }) }) } func (obj SetConfig) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) { + // Serialize `ConfigDigest` param: + err = encoder.Encode(obj.ConfigDigest) + if err != nil { + return err + } // Serialize `Signers` param: err = encoder.Encode(obj.Signers) if err != nil { @@ -140,6 +190,11 @@ func (obj SetConfig) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) return nil } func (obj *SetConfig) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) { + // Deserialize `ConfigDigest`: + err = decoder.Decode(&obj.ConfigDigest) + if err != nil { + return err + } // Deserialize `Signers`: err = decoder.Decode(&obj.Signers) if err != nil { @@ -156,14 +211,20 @@ func (obj *SetConfig) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err erro // NewSetConfigInstruction declares a new SetConfig instruction with the provided parameters and accounts. func NewSetConfigInstruction( // Parameters: + configDigest [32]uint8, signers [][20]uint8, f uint8, // Accounts: verifierAccount ag_solanago.PublicKey, - owner ag_solanago.PublicKey) *SetConfig { + configAccount ag_solanago.PublicKey, + owner ag_solanago.PublicKey, + systemProgram ag_solanago.PublicKey) *SetConfig { return NewSetConfigInstructionBuilder(). + SetConfigDigest(configDigest). SetSigners(signers). SetF(f). SetVerifierAccountAccount(verifierAccount). - SetOwnerAccount(owner) + SetConfigAccountAccount(configAccount). + SetOwnerAccount(owner). + SetSystemProgramAccount(systemProgram) } diff --git a/client/go/verifier/SetConfigActive.go b/client/go/verifier/SetConfigActive.go deleted file mode 100644 index 500f1b7..0000000 --- a/client/go/verifier/SetConfigActive.go +++ /dev/null @@ -1,169 +0,0 @@ -// Code generated by https://github.com/gagliardetto/anchor-go. DO NOT EDIT. - -package verifier - -import ( - "errors" - ag_binary "github.com/gagliardetto/binary" - ag_solanago "github.com/gagliardetto/solana-go" - ag_format "github.com/gagliardetto/solana-go/text/format" - ag_treeout "github.com/gagliardetto/treeout" -) - -// SetConfigActive is the `setConfigActive` instruction. -type SetConfigActive struct { - DonConfigIndex *uint64 - IsActive *uint8 - - // [0] = [WRITE] verifierAccount - // - // [1] = [SIGNER] owner - ag_solanago.AccountMetaSlice `bin:"-"` -} - -// NewSetConfigActiveInstructionBuilder creates a new `SetConfigActive` instruction builder. -func NewSetConfigActiveInstructionBuilder() *SetConfigActive { - nd := &SetConfigActive{ - AccountMetaSlice: make(ag_solanago.AccountMetaSlice, 2), - } - return nd -} - -// SetDonConfigIndex sets the "donConfigIndex" parameter. -func (inst *SetConfigActive) SetDonConfigIndex(donConfigIndex uint64) *SetConfigActive { - inst.DonConfigIndex = &donConfigIndex - return inst -} - -// SetIsActive sets the "isActive" parameter. -func (inst *SetConfigActive) SetIsActive(isActive uint8) *SetConfigActive { - inst.IsActive = &isActive - return inst -} - -// SetVerifierAccountAccount sets the "verifierAccount" account. -func (inst *SetConfigActive) SetVerifierAccountAccount(verifierAccount ag_solanago.PublicKey) *SetConfigActive { - inst.AccountMetaSlice[0] = ag_solanago.Meta(verifierAccount).WRITE() - return inst -} - -// GetVerifierAccountAccount gets the "verifierAccount" account. -func (inst *SetConfigActive) GetVerifierAccountAccount() *ag_solanago.AccountMeta { - return inst.AccountMetaSlice.Get(0) -} - -// SetOwnerAccount sets the "owner" account. -func (inst *SetConfigActive) SetOwnerAccount(owner ag_solanago.PublicKey) *SetConfigActive { - inst.AccountMetaSlice[1] = ag_solanago.Meta(owner).SIGNER() - return inst -} - -// GetOwnerAccount gets the "owner" account. -func (inst *SetConfigActive) GetOwnerAccount() *ag_solanago.AccountMeta { - return inst.AccountMetaSlice.Get(1) -} - -func (inst SetConfigActive) Build() *Instruction { - return &Instruction{BaseVariant: ag_binary.BaseVariant{ - Impl: inst, - TypeID: Instruction_SetConfigActive, - }} -} - -// ValidateAndBuild validates the instruction parameters and accounts; -// if there is a validation error, it returns the error. -// Otherwise, it builds and returns the instruction. -func (inst SetConfigActive) ValidateAndBuild() (*Instruction, error) { - if err := inst.Validate(); err != nil { - return nil, err - } - return inst.Build(), nil -} - -func (inst *SetConfigActive) Validate() error { - // Check whether all (required) parameters are set: - { - if inst.DonConfigIndex == nil { - return errors.New("DonConfigIndex parameter is not set") - } - if inst.IsActive == nil { - return errors.New("IsActive parameter is not set") - } - } - - // Check whether all (required) accounts are set: - { - if inst.AccountMetaSlice[0] == nil { - return errors.New("accounts.VerifierAccount is not set") - } - if inst.AccountMetaSlice[1] == nil { - return errors.New("accounts.Owner is not set") - } - } - return nil -} - -func (inst *SetConfigActive) EncodeToTree(parent ag_treeout.Branches) { - parent.Child(ag_format.Program(ProgramName, ProgramID)). - // - ParentFunc(func(programBranch ag_treeout.Branches) { - programBranch.Child(ag_format.Instruction("SetConfigActive")). - // - ParentFunc(func(instructionBranch ag_treeout.Branches) { - - // Parameters of the instruction: - instructionBranch.Child("Params[len=2]").ParentFunc(func(paramsBranch ag_treeout.Branches) { - paramsBranch.Child(ag_format.Param("DonConfigIndex", *inst.DonConfigIndex)) - paramsBranch.Child(ag_format.Param(" IsActive", *inst.IsActive)) - }) - - // Accounts of the instruction: - instructionBranch.Child("Accounts[len=2]").ParentFunc(func(accountsBranch ag_treeout.Branches) { - accountsBranch.Child(ag_format.Meta("verifier", inst.AccountMetaSlice.Get(0))) - accountsBranch.Child(ag_format.Meta(" owner", inst.AccountMetaSlice.Get(1))) - }) - }) - }) -} - -func (obj SetConfigActive) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) { - // Serialize `DonConfigIndex` param: - err = encoder.Encode(obj.DonConfigIndex) - if err != nil { - return err - } - // Serialize `IsActive` param: - err = encoder.Encode(obj.IsActive) - if err != nil { - return err - } - return nil -} -func (obj *SetConfigActive) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) { - // Deserialize `DonConfigIndex`: - err = decoder.Decode(&obj.DonConfigIndex) - if err != nil { - return err - } - // Deserialize `IsActive`: - err = decoder.Decode(&obj.IsActive) - if err != nil { - return err - } - return nil -} - -// NewSetConfigActiveInstruction declares a new SetConfigActive instruction with the provided parameters and accounts. -func NewSetConfigActiveInstruction( - // Parameters: - donConfigIndex uint64, - isActive uint8, - // Accounts: - verifierAccount ag_solanago.PublicKey, - owner ag_solanago.PublicKey) *SetConfigActive { - return NewSetConfigActiveInstructionBuilder(). - SetDonConfigIndex(donConfigIndex). - SetIsActive(isActive). - SetVerifierAccountAccount(verifierAccount). - SetOwnerAccount(owner) -} diff --git a/client/go/verifier/SetConfigWithActivationTime.go b/client/go/verifier/SetConfigWithActivationTime.go deleted file mode 100644 index 099ec70..0000000 --- a/client/go/verifier/SetConfigWithActivationTime.go +++ /dev/null @@ -1,192 +0,0 @@ -// Code generated by https://github.com/gagliardetto/anchor-go. DO NOT EDIT. - -package verifier - -import ( - "errors" - ag_binary "github.com/gagliardetto/binary" - ag_solanago "github.com/gagliardetto/solana-go" - ag_format "github.com/gagliardetto/solana-go/text/format" - ag_treeout "github.com/gagliardetto/treeout" -) - -// SetConfigWithActivationTime is the `setConfigWithActivationTime` instruction. -type SetConfigWithActivationTime struct { - Signers *[][20]uint8 - F *uint8 - ActivationTime *uint32 - - // [0] = [WRITE] verifierAccount - // - // [1] = [SIGNER] owner - ag_solanago.AccountMetaSlice `bin:"-"` -} - -// NewSetConfigWithActivationTimeInstructionBuilder creates a new `SetConfigWithActivationTime` instruction builder. -func NewSetConfigWithActivationTimeInstructionBuilder() *SetConfigWithActivationTime { - nd := &SetConfigWithActivationTime{ - AccountMetaSlice: make(ag_solanago.AccountMetaSlice, 2), - } - return nd -} - -// SetSigners sets the "signers" parameter. -func (inst *SetConfigWithActivationTime) SetSigners(signers [][20]uint8) *SetConfigWithActivationTime { - inst.Signers = &signers - return inst -} - -// SetF sets the "f" parameter. -func (inst *SetConfigWithActivationTime) SetF(f uint8) *SetConfigWithActivationTime { - inst.F = &f - return inst -} - -// SetActivationTime sets the "activationTime" parameter. -func (inst *SetConfigWithActivationTime) SetActivationTime(activationTime uint32) *SetConfigWithActivationTime { - inst.ActivationTime = &activationTime - return inst -} - -// SetVerifierAccountAccount sets the "verifierAccount" account. -func (inst *SetConfigWithActivationTime) SetVerifierAccountAccount(verifierAccount ag_solanago.PublicKey) *SetConfigWithActivationTime { - inst.AccountMetaSlice[0] = ag_solanago.Meta(verifierAccount).WRITE() - return inst -} - -// GetVerifierAccountAccount gets the "verifierAccount" account. -func (inst *SetConfigWithActivationTime) GetVerifierAccountAccount() *ag_solanago.AccountMeta { - return inst.AccountMetaSlice.Get(0) -} - -// SetOwnerAccount sets the "owner" account. -func (inst *SetConfigWithActivationTime) SetOwnerAccount(owner ag_solanago.PublicKey) *SetConfigWithActivationTime { - inst.AccountMetaSlice[1] = ag_solanago.Meta(owner).SIGNER() - return inst -} - -// GetOwnerAccount gets the "owner" account. -func (inst *SetConfigWithActivationTime) GetOwnerAccount() *ag_solanago.AccountMeta { - return inst.AccountMetaSlice.Get(1) -} - -func (inst SetConfigWithActivationTime) Build() *Instruction { - return &Instruction{BaseVariant: ag_binary.BaseVariant{ - Impl: inst, - TypeID: Instruction_SetConfigWithActivationTime, - }} -} - -// ValidateAndBuild validates the instruction parameters and accounts; -// if there is a validation error, it returns the error. -// Otherwise, it builds and returns the instruction. -func (inst SetConfigWithActivationTime) ValidateAndBuild() (*Instruction, error) { - if err := inst.Validate(); err != nil { - return nil, err - } - return inst.Build(), nil -} - -func (inst *SetConfigWithActivationTime) Validate() error { - // Check whether all (required) parameters are set: - { - if inst.Signers == nil { - return errors.New("Signers parameter is not set") - } - if inst.F == nil { - return errors.New("F parameter is not set") - } - if inst.ActivationTime == nil { - return errors.New("ActivationTime parameter is not set") - } - } - - // Check whether all (required) accounts are set: - { - if inst.AccountMetaSlice[0] == nil { - return errors.New("accounts.VerifierAccount is not set") - } - if inst.AccountMetaSlice[1] == nil { - return errors.New("accounts.Owner is not set") - } - } - return nil -} - -func (inst *SetConfigWithActivationTime) EncodeToTree(parent ag_treeout.Branches) { - parent.Child(ag_format.Program(ProgramName, ProgramID)). - // - ParentFunc(func(programBranch ag_treeout.Branches) { - programBranch.Child(ag_format.Instruction("SetConfigWithActivationTime")). - // - ParentFunc(func(instructionBranch ag_treeout.Branches) { - - // Parameters of the instruction: - instructionBranch.Child("Params[len=3]").ParentFunc(func(paramsBranch ag_treeout.Branches) { - paramsBranch.Child(ag_format.Param(" Signers", *inst.Signers)) - paramsBranch.Child(ag_format.Param(" F", *inst.F)) - paramsBranch.Child(ag_format.Param("ActivationTime", *inst.ActivationTime)) - }) - - // Accounts of the instruction: - instructionBranch.Child("Accounts[len=2]").ParentFunc(func(accountsBranch ag_treeout.Branches) { - accountsBranch.Child(ag_format.Meta("verifier", inst.AccountMetaSlice.Get(0))) - accountsBranch.Child(ag_format.Meta(" owner", inst.AccountMetaSlice.Get(1))) - }) - }) - }) -} - -func (obj SetConfigWithActivationTime) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) { - // Serialize `Signers` param: - err = encoder.Encode(obj.Signers) - if err != nil { - return err - } - // Serialize `F` param: - err = encoder.Encode(obj.F) - if err != nil { - return err - } - // Serialize `ActivationTime` param: - err = encoder.Encode(obj.ActivationTime) - if err != nil { - return err - } - return nil -} -func (obj *SetConfigWithActivationTime) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) { - // Deserialize `Signers`: - err = decoder.Decode(&obj.Signers) - if err != nil { - return err - } - // Deserialize `F`: - err = decoder.Decode(&obj.F) - if err != nil { - return err - } - // Deserialize `ActivationTime`: - err = decoder.Decode(&obj.ActivationTime) - if err != nil { - return err - } - return nil -} - -// NewSetConfigWithActivationTimeInstruction declares a new SetConfigWithActivationTime instruction with the provided parameters and accounts. -func NewSetConfigWithActivationTimeInstruction( - // Parameters: - signers [][20]uint8, - f uint8, - activationTime uint32, - // Accounts: - verifierAccount ag_solanago.PublicKey, - owner ag_solanago.PublicKey) *SetConfigWithActivationTime { - return NewSetConfigWithActivationTimeInstructionBuilder(). - SetSigners(signers). - SetF(f). - SetActivationTime(activationTime). - SetVerifierAccountAccount(verifierAccount). - SetOwnerAccount(owner) -} diff --git a/client/go/verifier/RemoveLatestConfig.go b/client/go/verifier/SetLegacyFallback.go similarity index 50% rename from client/go/verifier/RemoveLatestConfig.go rename to client/go/verifier/SetLegacyFallback.go index d280914..430835d 100644 --- a/client/go/verifier/RemoveLatestConfig.go +++ b/client/go/verifier/SetLegacyFallback.go @@ -10,8 +10,9 @@ import ( ag_treeout "github.com/gagliardetto/treeout" ) -// RemoveLatestConfig is the `removeLatestConfig` instruction. -type RemoveLatestConfig struct { +// Enables or disables falling back to the legacy `don_configs` when no config PDA exists for a report's digest +type SetLegacyFallback struct { + Enabled *bool // [0] = [WRITE] verifierAccount // @@ -19,54 +20,67 @@ type RemoveLatestConfig struct { ag_solanago.AccountMetaSlice `bin:"-"` } -// NewRemoveLatestConfigInstructionBuilder creates a new `RemoveLatestConfig` instruction builder. -func NewRemoveLatestConfigInstructionBuilder() *RemoveLatestConfig { - nd := &RemoveLatestConfig{ +// NewSetLegacyFallbackInstructionBuilder creates a new `SetLegacyFallback` instruction builder. +func NewSetLegacyFallbackInstructionBuilder() *SetLegacyFallback { + nd := &SetLegacyFallback{ AccountMetaSlice: make(ag_solanago.AccountMetaSlice, 2), } return nd } +// SetEnabled sets the "enabled" parameter. +func (inst *SetLegacyFallback) SetEnabled(enabled bool) *SetLegacyFallback { + inst.Enabled = &enabled + return inst +} + // SetVerifierAccountAccount sets the "verifierAccount" account. -func (inst *RemoveLatestConfig) SetVerifierAccountAccount(verifierAccount ag_solanago.PublicKey) *RemoveLatestConfig { +func (inst *SetLegacyFallback) SetVerifierAccountAccount(verifierAccount ag_solanago.PublicKey) *SetLegacyFallback { inst.AccountMetaSlice[0] = ag_solanago.Meta(verifierAccount).WRITE() return inst } // GetVerifierAccountAccount gets the "verifierAccount" account. -func (inst *RemoveLatestConfig) GetVerifierAccountAccount() *ag_solanago.AccountMeta { +func (inst *SetLegacyFallback) GetVerifierAccountAccount() *ag_solanago.AccountMeta { return inst.AccountMetaSlice.Get(0) } // SetOwnerAccount sets the "owner" account. -func (inst *RemoveLatestConfig) SetOwnerAccount(owner ag_solanago.PublicKey) *RemoveLatestConfig { +func (inst *SetLegacyFallback) SetOwnerAccount(owner ag_solanago.PublicKey) *SetLegacyFallback { inst.AccountMetaSlice[1] = ag_solanago.Meta(owner).SIGNER() return inst } // GetOwnerAccount gets the "owner" account. -func (inst *RemoveLatestConfig) GetOwnerAccount() *ag_solanago.AccountMeta { +func (inst *SetLegacyFallback) GetOwnerAccount() *ag_solanago.AccountMeta { return inst.AccountMetaSlice.Get(1) } -func (inst RemoveLatestConfig) Build() *Instruction { +func (inst SetLegacyFallback) Build() *Instruction { return &Instruction{BaseVariant: ag_binary.BaseVariant{ Impl: inst, - TypeID: Instruction_RemoveLatestConfig, + TypeID: Instruction_SetLegacyFallback, }} } // ValidateAndBuild validates the instruction parameters and accounts; // if there is a validation error, it returns the error. // Otherwise, it builds and returns the instruction. -func (inst RemoveLatestConfig) ValidateAndBuild() (*Instruction, error) { +func (inst SetLegacyFallback) ValidateAndBuild() (*Instruction, error) { if err := inst.Validate(); err != nil { return nil, err } return inst.Build(), nil } -func (inst *RemoveLatestConfig) Validate() error { +func (inst *SetLegacyFallback) Validate() error { + // Check whether all (required) parameters are set: + { + if inst.Enabled == nil { + return errors.New("Enabled parameter is not set") + } + } + // Check whether all (required) accounts are set: { if inst.AccountMetaSlice[0] == nil { @@ -79,16 +93,18 @@ func (inst *RemoveLatestConfig) Validate() error { return nil } -func (inst *RemoveLatestConfig) EncodeToTree(parent ag_treeout.Branches) { +func (inst *SetLegacyFallback) EncodeToTree(parent ag_treeout.Branches) { parent.Child(ag_format.Program(ProgramName, ProgramID)). // ParentFunc(func(programBranch ag_treeout.Branches) { - programBranch.Child(ag_format.Instruction("RemoveLatestConfig")). + programBranch.Child(ag_format.Instruction("SetLegacyFallback")). // ParentFunc(func(instructionBranch ag_treeout.Branches) { // Parameters of the instruction: - instructionBranch.Child("Params[len=0]").ParentFunc(func(paramsBranch ag_treeout.Branches) {}) + instructionBranch.Child("Params[len=1]").ParentFunc(func(paramsBranch ag_treeout.Branches) { + paramsBranch.Child(ag_format.Param("Enabled", *inst.Enabled)) + }) // Accounts of the instruction: instructionBranch.Child("Accounts[len=2]").ParentFunc(func(accountsBranch ag_treeout.Branches) { @@ -99,19 +115,32 @@ func (inst *RemoveLatestConfig) EncodeToTree(parent ag_treeout.Branches) { }) } -func (obj RemoveLatestConfig) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) { +func (obj SetLegacyFallback) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) { + // Serialize `Enabled` param: + err = encoder.Encode(obj.Enabled) + if err != nil { + return err + } return nil } -func (obj *RemoveLatestConfig) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) { +func (obj *SetLegacyFallback) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) { + // Deserialize `Enabled`: + err = decoder.Decode(&obj.Enabled) + if err != nil { + return err + } return nil } -// NewRemoveLatestConfigInstruction declares a new RemoveLatestConfig instruction with the provided parameters and accounts. -func NewRemoveLatestConfigInstruction( +// NewSetLegacyFallbackInstruction declares a new SetLegacyFallback instruction with the provided parameters and accounts. +func NewSetLegacyFallbackInstruction( + // Parameters: + enabled bool, // Accounts: verifierAccount ag_solanago.PublicKey, - owner ag_solanago.PublicKey) *RemoveLatestConfig { - return NewRemoveLatestConfigInstructionBuilder(). + owner ag_solanago.PublicKey) *SetLegacyFallback { + return NewSetLegacyFallbackInstructionBuilder(). + SetEnabled(enabled). SetVerifierAccountAccount(verifierAccount). SetOwnerAccount(owner) } diff --git a/client/go/verifier/SetConfigWithActivationTime_test.go b/client/go/verifier/SetLegacyFallback_test.go similarity index 72% rename from client/go/verifier/SetConfigWithActivationTime_test.go rename to client/go/verifier/SetLegacyFallback_test.go index efe5316..79d4522 100644 --- a/client/go/verifier/SetConfigWithActivationTime_test.go +++ b/client/go/verifier/SetLegacyFallback_test.go @@ -10,18 +10,18 @@ import ( "testing" ) -func TestEncodeDecode_SetConfigWithActivationTime(t *testing.T) { +func TestEncodeDecode_SetLegacyFallback(t *testing.T) { fu := ag_gofuzz.New().NilChance(0) for i := 0; i < 1; i++ { - t.Run("SetConfigWithActivationTime"+strconv.Itoa(i), func(t *testing.T) { + t.Run("SetLegacyFallback"+strconv.Itoa(i), func(t *testing.T) { { - params := new(SetConfigWithActivationTime) + params := new(SetLegacyFallback) fu.Fuzz(params) params.AccountMetaSlice = nil buf := new(bytes.Buffer) err := encodeT(*params, buf) ag_require.NoError(t, err) - got := new(SetConfigWithActivationTime) + got := new(SetLegacyFallback) err = decodeT(got, buf.Bytes()) got.AccountMetaSlice = nil ag_require.NoError(t, err) diff --git a/client/go/verifier/UpdateConfig.go b/client/go/verifier/UpdateConfig.go new file mode 100644 index 0000000..16fc74a --- /dev/null +++ b/client/go/verifier/UpdateConfig.go @@ -0,0 +1,211 @@ +// Code generated by https://github.com/gagliardetto/anchor-go. DO NOT EDIT. + +package verifier + +import ( + "errors" + ag_binary "github.com/gagliardetto/binary" + ag_solanago "github.com/gagliardetto/solana-go" + ag_format "github.com/gagliardetto/solana-go/text/format" + ag_treeout "github.com/gagliardetto/treeout" +) + +// Replaces the signers and fault tolerance of an existing config digest. The active state is unchanged +type UpdateConfig struct { + ConfigDigest *[32]uint8 + Signers *[][20]uint8 + F *uint8 + + // [0] = [] verifierAccount + // + // [1] = [WRITE] configAccount + // + // [2] = [SIGNER] owner + ag_solanago.AccountMetaSlice `bin:"-"` +} + +// NewUpdateConfigInstructionBuilder creates a new `UpdateConfig` instruction builder. +func NewUpdateConfigInstructionBuilder() *UpdateConfig { + nd := &UpdateConfig{ + AccountMetaSlice: make(ag_solanago.AccountMetaSlice, 3), + } + return nd +} + +// SetConfigDigest sets the "configDigest" parameter. +func (inst *UpdateConfig) SetConfigDigest(configDigest [32]uint8) *UpdateConfig { + inst.ConfigDigest = &configDigest + return inst +} + +// SetSigners sets the "signers" parameter. +func (inst *UpdateConfig) SetSigners(signers [][20]uint8) *UpdateConfig { + inst.Signers = &signers + return inst +} + +// SetF sets the "f" parameter. +func (inst *UpdateConfig) SetF(f uint8) *UpdateConfig { + inst.F = &f + return inst +} + +// SetVerifierAccountAccount sets the "verifierAccount" account. +func (inst *UpdateConfig) SetVerifierAccountAccount(verifierAccount ag_solanago.PublicKey) *UpdateConfig { + inst.AccountMetaSlice[0] = ag_solanago.Meta(verifierAccount) + return inst +} + +// GetVerifierAccountAccount gets the "verifierAccount" account. +func (inst *UpdateConfig) GetVerifierAccountAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(0) +} + +// SetConfigAccountAccount sets the "configAccount" account. +func (inst *UpdateConfig) SetConfigAccountAccount(configAccount ag_solanago.PublicKey) *UpdateConfig { + inst.AccountMetaSlice[1] = ag_solanago.Meta(configAccount).WRITE() + return inst +} + +// GetConfigAccountAccount gets the "configAccount" account. +func (inst *UpdateConfig) GetConfigAccountAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(1) +} + +// SetOwnerAccount sets the "owner" account. +func (inst *UpdateConfig) SetOwnerAccount(owner ag_solanago.PublicKey) *UpdateConfig { + inst.AccountMetaSlice[2] = ag_solanago.Meta(owner).SIGNER() + return inst +} + +// GetOwnerAccount gets the "owner" account. +func (inst *UpdateConfig) GetOwnerAccount() *ag_solanago.AccountMeta { + return inst.AccountMetaSlice.Get(2) +} + +func (inst UpdateConfig) Build() *Instruction { + return &Instruction{BaseVariant: ag_binary.BaseVariant{ + Impl: inst, + TypeID: Instruction_UpdateConfig, + }} +} + +// ValidateAndBuild validates the instruction parameters and accounts; +// if there is a validation error, it returns the error. +// Otherwise, it builds and returns the instruction. +func (inst UpdateConfig) ValidateAndBuild() (*Instruction, error) { + if err := inst.Validate(); err != nil { + return nil, err + } + return inst.Build(), nil +} + +func (inst *UpdateConfig) Validate() error { + // Check whether all (required) parameters are set: + { + if inst.ConfigDigest == nil { + return errors.New("ConfigDigest parameter is not set") + } + if inst.Signers == nil { + return errors.New("Signers parameter is not set") + } + if inst.F == nil { + return errors.New("F parameter is not set") + } + } + + // Check whether all (required) accounts are set: + { + if inst.AccountMetaSlice[0] == nil { + return errors.New("accounts.VerifierAccount is not set") + } + if inst.AccountMetaSlice[1] == nil { + return errors.New("accounts.ConfigAccount is not set") + } + if inst.AccountMetaSlice[2] == nil { + return errors.New("accounts.Owner is not set") + } + } + return nil +} + +func (inst *UpdateConfig) EncodeToTree(parent ag_treeout.Branches) { + parent.Child(ag_format.Program(ProgramName, ProgramID)). + // + ParentFunc(func(programBranch ag_treeout.Branches) { + programBranch.Child(ag_format.Instruction("UpdateConfig")). + // + ParentFunc(func(instructionBranch ag_treeout.Branches) { + + // Parameters of the instruction: + instructionBranch.Child("Params[len=3]").ParentFunc(func(paramsBranch ag_treeout.Branches) { + paramsBranch.Child(ag_format.Param("ConfigDigest", *inst.ConfigDigest)) + paramsBranch.Child(ag_format.Param(" Signers", *inst.Signers)) + paramsBranch.Child(ag_format.Param(" F", *inst.F)) + }) + + // Accounts of the instruction: + instructionBranch.Child("Accounts[len=3]").ParentFunc(func(accountsBranch ag_treeout.Branches) { + accountsBranch.Child(ag_format.Meta("verifier", inst.AccountMetaSlice.Get(0))) + accountsBranch.Child(ag_format.Meta(" config", inst.AccountMetaSlice.Get(1))) + accountsBranch.Child(ag_format.Meta(" owner", inst.AccountMetaSlice.Get(2))) + }) + }) + }) +} + +func (obj UpdateConfig) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) { + // Serialize `ConfigDigest` param: + err = encoder.Encode(obj.ConfigDigest) + if err != nil { + return err + } + // Serialize `Signers` param: + err = encoder.Encode(obj.Signers) + if err != nil { + return err + } + // Serialize `F` param: + err = encoder.Encode(obj.F) + if err != nil { + return err + } + return nil +} +func (obj *UpdateConfig) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) { + // Deserialize `ConfigDigest`: + err = decoder.Decode(&obj.ConfigDigest) + if err != nil { + return err + } + // Deserialize `Signers`: + err = decoder.Decode(&obj.Signers) + if err != nil { + return err + } + // Deserialize `F`: + err = decoder.Decode(&obj.F) + if err != nil { + return err + } + return nil +} + +// NewUpdateConfigInstruction declares a new UpdateConfig instruction with the provided parameters and accounts. +func NewUpdateConfigInstruction( + // Parameters: + configDigest [32]uint8, + signers [][20]uint8, + f uint8, + // Accounts: + verifierAccount ag_solanago.PublicKey, + configAccount ag_solanago.PublicKey, + owner ag_solanago.PublicKey) *UpdateConfig { + return NewUpdateConfigInstructionBuilder(). + SetConfigDigest(configDigest). + SetSigners(signers). + SetF(f). + SetVerifierAccountAccount(verifierAccount). + SetConfigAccountAccount(configAccount). + SetOwnerAccount(owner) +} diff --git a/client/go/verifier/UpdateConfig_test.go b/client/go/verifier/UpdateConfig_test.go new file mode 100644 index 0000000..bf266f2 --- /dev/null +++ b/client/go/verifier/UpdateConfig_test.go @@ -0,0 +1,32 @@ +// Code generated by https://github.com/gagliardetto/anchor-go. DO NOT EDIT. + +package verifier + +import ( + "bytes" + ag_gofuzz "github.com/gagliardetto/gofuzz" + ag_require "github.com/stretchr/testify/require" + "strconv" + "testing" +) + +func TestEncodeDecode_UpdateConfig(t *testing.T) { + fu := ag_gofuzz.New().NilChance(0) + for i := 0; i < 1; i++ { + t.Run("UpdateConfig"+strconv.Itoa(i), func(t *testing.T) { + { + params := new(UpdateConfig) + fu.Fuzz(params) + params.AccountMetaSlice = nil + buf := new(bytes.Buffer) + err := encodeT(*params, buf) + ag_require.NoError(t, err) + got := new(UpdateConfig) + err = decodeT(got, buf.Bytes()) + got.AccountMetaSlice = nil + ag_require.NoError(t, err) + ag_require.Equal(t, params, got) + } + }) + } +} diff --git a/client/go/verifier/accounts.go b/client/go/verifier/accounts.go index 06c3b52..b2f145f 100644 --- a/client/go/verifier/accounts.go +++ b/client/go/verifier/accounts.go @@ -7,11 +7,120 @@ import ( ag_binary "github.com/gagliardetto/binary" ) +type DigestConfig struct { + Version uint8 + ConfigDigest [32]uint8 + F uint8 + IsActive bool + Bump uint8 + Signers [][20]uint8 + Reserved [32]uint8 +} + +var DigestConfigDiscriminator = [8]byte{164, 237, 222, 122, 66, 51, 150, 114} + +func (obj DigestConfig) MarshalWithEncoder(encoder *ag_binary.Encoder) (err error) { + // Write account discriminator: + err = encoder.WriteBytes(DigestConfigDiscriminator[:], false) + if err != nil { + return err + } + // Serialize `Version` param: + err = encoder.Encode(obj.Version) + if err != nil { + return err + } + // Serialize `ConfigDigest` param: + err = encoder.Encode(obj.ConfigDigest) + if err != nil { + return err + } + // Serialize `F` param: + err = encoder.Encode(obj.F) + if err != nil { + return err + } + // Serialize `IsActive` param: + err = encoder.Encode(obj.IsActive) + if err != nil { + return err + } + // Serialize `Bump` param: + err = encoder.Encode(obj.Bump) + if err != nil { + return err + } + // Serialize `Signers` param: + err = encoder.Encode(obj.Signers) + if err != nil { + return err + } + // Serialize `Reserved` param: + err = encoder.Encode(obj.Reserved) + if err != nil { + return err + } + return nil +} + +func (obj *DigestConfig) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (err error) { + // Read and check account discriminator: + { + discriminator, err := decoder.ReadTypeID() + if err != nil { + return err + } + if !discriminator.Equal(DigestConfigDiscriminator[:]) { + return fmt.Errorf( + "wrong discriminator: wanted %s, got %s", + "[164 237 222 122 66 51 150 114]", + fmt.Sprint(discriminator[:])) + } + } + // Deserialize `Version`: + err = decoder.Decode(&obj.Version) + if err != nil { + return err + } + // Deserialize `ConfigDigest`: + err = decoder.Decode(&obj.ConfigDigest) + if err != nil { + return err + } + // Deserialize `F`: + err = decoder.Decode(&obj.F) + if err != nil { + return err + } + // Deserialize `IsActive`: + err = decoder.Decode(&obj.IsActive) + if err != nil { + return err + } + // Deserialize `Bump`: + err = decoder.Decode(&obj.Bump) + if err != nil { + return err + } + // Deserialize `Signers`: + err = decoder.Decode(&obj.Signers) + if err != nil { + return err + } + // Deserialize `Reserved`: + err = decoder.Decode(&obj.Reserved) + if err != nil { + return err + } + return nil +} + type VerifierAccount struct { - Version uint8 - Padding [7]uint8 - VerifierAccountConfig VerifierAccountConfig - DonConfigs DonConfigs + Version uint8 + LegacyFallbackDisabled uint8 + Padding [6]uint8 + VerifierAccountConfig VerifierAccountConfig + DonConfigs DonConfigs } var VerifierAccountDiscriminator = [8]byte{81, 120, 248, 87, 107, 174, 58, 157} @@ -27,6 +136,11 @@ func (obj VerifierAccount) MarshalWithEncoder(encoder *ag_binary.Encoder) (err e if err != nil { return err } + // Serialize `LegacyFallbackDisabled` param: + err = encoder.Encode(obj.LegacyFallbackDisabled) + if err != nil { + return err + } // Serialize `Padding` param: err = encoder.Encode(obj.Padding) if err != nil { @@ -64,6 +178,11 @@ func (obj *VerifierAccount) UnmarshalWithDecoder(decoder *ag_binary.Decoder) (er if err != nil { return err } + // Deserialize `LegacyFallbackDisabled`: + err = decoder.Decode(&obj.LegacyFallbackDisabled) + if err != nil { + return err + } // Deserialize `Padding`: err = decoder.Decode(&obj.Padding) if err != nil { diff --git a/client/go/verifier/instructions.go b/client/go/verifier/instructions.go index c30a40a..4e2c5cc 100644 --- a/client/go/verifier/instructions.go +++ b/client/go/verifier/instructions.go @@ -30,13 +30,21 @@ func init() { var ( Instruction_Verify = ag_binary.TypeID([8]byte{133, 161, 141, 48, 120, 198, 88, 150}) - Instruction_SetConfigWithActivationTime = ag_binary.TypeID([8]byte{189, 64, 69, 231, 128, 29, 197, 29}) - + // Sets the DON configuration for a config digest. Creates the config PDA derived from `[config_digest]` Instruction_SetConfig = ag_binary.TypeID([8]byte{108, 158, 154, 175, 212, 98, 52, 66}) - Instruction_SetConfigActive = ag_binary.TypeID([8]byte{90, 95, 224, 173, 96, 184, 36, 136}) + // Replaces the signers and fault tolerance of an existing config digest. The active state is unchanged + Instruction_UpdateConfig = ag_binary.TypeID([8]byte{29, 158, 252, 191, 10, 83, 219, 99}) + + Instruction_ActivateConfig = ag_binary.TypeID([8]byte{125, 127, 55, 160, 125, 212, 222, 207}) + + Instruction_DeactivateConfig = ag_binary.TypeID([8]byte{240, 42, 36, 120, 166, 3, 130, 231}) - Instruction_RemoveLatestConfig = ag_binary.TypeID([8]byte{171, 221, 188, 175, 156, 87, 156, 63}) + // Closes the config PDA for a config digest and refunds its rent to the owner + Instruction_CloseConfig = ag_binary.TypeID([8]byte{145, 9, 72, 157, 95, 125, 61, 85}) + + // Enables or disables falling back to the legacy `don_configs` when no config PDA exists for a report's digest + Instruction_SetLegacyFallback = ag_binary.TypeID([8]byte{217, 148, 168, 130, 83, 167, 106, 82}) // Used to Set the access controller // We use an optional access controller. @@ -63,14 +71,18 @@ func InstructionIDToName(id ag_binary.TypeID) string { switch id { case Instruction_Verify: return "Verify" - case Instruction_SetConfigWithActivationTime: - return "SetConfigWithActivationTime" case Instruction_SetConfig: return "SetConfig" - case Instruction_SetConfigActive: - return "SetConfigActive" - case Instruction_RemoveLatestConfig: - return "RemoveLatestConfig" + case Instruction_UpdateConfig: + return "UpdateConfig" + case Instruction_ActivateConfig: + return "ActivateConfig" + case Instruction_DeactivateConfig: + return "DeactivateConfig" + case Instruction_CloseConfig: + return "CloseConfig" + case Instruction_SetLegacyFallback: + return "SetLegacyFallback" case Instruction_SetAccessController: return "SetAccessController" case Instruction_Initialize: @@ -107,16 +119,22 @@ var InstructionImplDef = ag_binary.NewVariantDefinition( "verify", (*Verify)(nil), }, { - "set_config_with_activation_time", (*SetConfigWithActivationTime)(nil), + "set_config", (*SetConfig)(nil), + }, + { + "update_config", (*UpdateConfig)(nil), }, { - "set_config", (*SetConfig)(nil), + "activate_config", (*ActivateConfig)(nil), + }, + { + "deactivate_config", (*DeactivateConfig)(nil), }, { - "set_config_active", (*SetConfigActive)(nil), + "close_config", (*CloseConfig)(nil), }, { - "remove_latest_config", (*RemoveLatestConfig)(nil), + "set_legacy_fallback", (*SetLegacyFallback)(nil), }, { "set_access_controller", (*SetAccessController)(nil), diff --git a/programs/verifier/Cargo.lock b/programs/verifier/Cargo.lock index 6680fff..b8036f7 100644 --- a/programs/verifier/Cargo.lock +++ b/programs/verifier/Cargo.lock @@ -6136,7 +6136,7 @@ checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191" [[package]] name = "verifier" -version = "0.4.0" +version = "0.5.0" dependencies = [ "anchor-lang", "anchor-spl", diff --git a/programs/verifier/Cargo.toml b/programs/verifier/Cargo.toml index fdc6c16..d313ca2 100644 --- a/programs/verifier/Cargo.toml +++ b/programs/verifier/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "verifier" -version = "0.4.0" # This version should align with the features of EVM verifier version +version = "0.5.0" # This version should align with the features of EVM verifier version description = "Verifier for Data Streams" edition = "2021" @@ -30,4 +30,5 @@ bytemuck = "1.19.0" [dev-dependencies] solana-program-test = "1.18.26" solana-sdk = "1.18.26" -test_utils = { path = "../../test_utils" } \ No newline at end of file +test_utils = { path = "../../test_utils" } +chainlink_solana_data_streams = { path = "../../crates/chainlink-solana-data-streams" } \ No newline at end of file diff --git a/programs/verifier/README.md b/programs/verifier/README.md index 4ed4482..7b04140 100644 --- a/programs/verifier/README.md +++ b/programs/verifier/README.md @@ -15,8 +15,30 @@ The accounts that are required to be passed to the verifier program are: - The signer of the transaction - The report config account (PDA) - Derived from the first 32 bytes of the uncompressed report received from the data streams off-chain server. + These bytes are the report's config digest, and the account holds the DON configuration for that digest. The SDK has a utility method to do this for you. +## DON Configurations +DON configurations are keyed by config digest, consistent with the EVM (v0.5.0+), Aptos, Sui and Stellar verifiers. +Each digest's configuration (signers, `f`, active state) is stored in its own PDA derived from `[config_digest]`. +Reports are verified against the configuration of the digest they were signed for, so reports from multiple DONs +can be verified at the same time. + +Owner instructions: +- `set_config(config_digest, signers, f)` creates the config account for a digest. Fails if the digest is already set. +- `update_config(config_digest, signers, f)` replaces the signers and `f` of a digest. +- `activate_config(config_digest)` / `deactivate_config(config_digest)` +- `close_config(config_digest)` deletes the config account and refunds its rent to the owner. +- `set_legacy_fallback(enabled)` see below. + +All config accounts can be listed with `getProgramAccounts` filtered by the `DigestConfig` account discriminator. + +### Legacy Configurations +Before v0.5.0 configurations were stored in the verifier account and selected by report timestamp. These are kept +read-only. While the legacy fallback is enabled (the default), a report whose digest has no config account is +verified against the legacy configurations, and `legacy config fallback` is logged. Once all digests in use have +a config account, disable the fallback with `set_legacy_fallback(false)` so only registered digests verify. + ### Integration Examples - [On-Chain Integration](https://docs.chain.link/data-streams/tutorials/streams-direct/solana-onchain-report-verification) - [Off-Chain Integration](https://docs.chain.link/data-streams/tutorials/streams-direct/solana-offchain-report-verification) diff --git a/programs/verifier/src/context/close_config_context.rs b/programs/verifier/src/context/close_config_context.rs new file mode 100644 index 0000000..3e5e85b --- /dev/null +++ b/programs/verifier/src/context/close_config_context.rs @@ -0,0 +1,15 @@ +use crate::errors::ErrorCode; +use crate::state::{DigestConfig, VerifierAccount}; +use anchor_lang::prelude::*; + +#[derive(Accounts)] +#[instruction(config_digest: [u8; 32])] +pub struct CloseConfigContext<'info> { + #[account(seeds = [b"verifier"], bump)] + pub verifier_account: AccountLoader<'info, VerifierAccount>, + // Rent is refunded to the owner + #[account(mut, close = owner, seeds = [config_digest.as_ref()], bump = config_account.bump)] + pub config_account: Account<'info, DigestConfig>, + #[account(mut, address = verifier_account.load()?.verifier_account_config.owner @ ErrorCode::Unauthorized)] + pub owner: Signer<'info>, +} diff --git a/programs/verifier/src/context/mod.rs b/programs/verifier/src/context/mod.rs index 83c7f49..02ffa9b 100644 --- a/programs/verifier/src/context/mod.rs +++ b/programs/verifier/src/context/mod.rs @@ -6,6 +6,9 @@ mod accept_ownership_context; mod update_config_context; mod realloc_account_context; mod initialize_account_data_context; +mod set_config_context; +mod update_digest_config_context; +mod close_config_context; pub use initialize_account_data_context::*; pub use initialize_account_context::*; @@ -14,4 +17,7 @@ pub use verify_context::*; pub use transfer_ownership_context::*; pub use accept_ownership_context::*; pub use update_config_context::*; -pub use realloc_account_context::*; \ No newline at end of file +pub use realloc_account_context::*; +pub use set_config_context::*; +pub use update_digest_config_context::*; +pub use close_config_context::*; \ No newline at end of file diff --git a/programs/verifier/src/context/set_config_context.rs b/programs/verifier/src/context/set_config_context.rs new file mode 100644 index 0000000..cfd60be --- /dev/null +++ b/programs/verifier/src/context/set_config_context.rs @@ -0,0 +1,22 @@ +use crate::errors::ErrorCode; +use crate::state::{DigestConfig, VerifierAccount}; +use anchor_lang::prelude::*; + +#[derive(Accounts)] +#[instruction(config_digest: [u8; 32])] +pub struct SetConfigContext<'info> { + #[account(seeds = [b"verifier"], bump)] + pub verifier_account: AccountLoader<'info, VerifierAccount>, + // `init_if_needed` so that an existing digest fails with `ConfigDigestAlreadySet` in the handler + #[account( + init_if_needed, + payer = owner, + space = 8 + DigestConfig::INIT_SPACE, + seeds = [config_digest.as_ref()], + bump + )] + pub config_account: Account<'info, DigestConfig>, + #[account(mut, address = verifier_account.load()?.verifier_account_config.owner @ ErrorCode::Unauthorized)] + pub owner: Signer<'info>, + pub system_program: Program<'info, System>, +} diff --git a/programs/verifier/src/context/update_digest_config_context.rs b/programs/verifier/src/context/update_digest_config_context.rs new file mode 100644 index 0000000..b2e2c3f --- /dev/null +++ b/programs/verifier/src/context/update_digest_config_context.rs @@ -0,0 +1,15 @@ +use crate::errors::ErrorCode; +use crate::state::{DigestConfig, VerifierAccount}; +use anchor_lang::prelude::*; + +/// Used by `update_config`, `activate_config` and `deactivate_config` +#[derive(Accounts)] +#[instruction(config_digest: [u8; 32])] +pub struct UpdateDigestConfigContext<'info> { + #[account(seeds = [b"verifier"], bump)] + pub verifier_account: AccountLoader<'info, VerifierAccount>, + #[account(mut, seeds = [config_digest.as_ref()], bump = config_account.bump)] + pub config_account: Account<'info, DigestConfig>, + #[account(address = verifier_account.load()?.verifier_account_config.owner @ ErrorCode::Unauthorized)] + pub owner: Signer<'info>, +} diff --git a/programs/verifier/src/errors.rs b/programs/verifier/src/errors.rs index 6a4d559..05c7f0b 100644 --- a/programs/verifier/src/errors.rs +++ b/programs/verifier/src/errors.rs @@ -38,4 +38,11 @@ pub enum ErrorCode { ConfigDeactivated, #[msg("Invalid inputs")] InvalidInputs, + // New errors must be appended to keep existing error codes stable for integrators + #[msg("Config digest is empty")] + DigestEmpty, + #[msg("Config digest is not set")] + DigestNotSet, + #[msg("Config digest is already set")] + ConfigDigestAlreadySet, } diff --git a/programs/verifier/src/events.rs b/programs/verifier/src/events.rs index fdebcb8..7748330 100644 --- a/programs/verifier/src/events.rs +++ b/programs/verifier/src/events.rs @@ -2,13 +2,17 @@ use anchor_lang::prelude::*; #[event] pub struct ConfigActivated { - pub don_config_id: String, - pub is_active: bool, + pub config_digest: [u8; 32], } #[event] -pub struct ConfigRemoved { - pub don_config_id: String, +pub struct ConfigDeactivated { + pub config_digest: [u8; 32], +} + +#[event] +pub struct ConfigClosed { + pub config_digest: [u8; 32], } #[event] @@ -19,11 +23,23 @@ pub struct ReportVerified { #[event] pub struct ConfigSet { - pub don_config_id: String, + pub config_digest: [u8; 32], + pub signers: Vec<[u8; 20]>, + pub f: u8, +} + +#[event] +pub struct ConfigUpdated { + pub config_digest: [u8; 32], pub signers: Vec<[u8; 20]>, pub f: u8, - pub don_config_index: u16, } + +#[event] +pub struct LegacyFallbackSet { + pub enabled: bool, +} + #[event] pub struct AccessControllerSet { pub access_controller: Pubkey, diff --git a/programs/verifier/src/evm/encoding.rs b/programs/verifier/src/evm/encoding.rs index 90fc2c1..522d05d 100644 --- a/programs/verifier/src/evm/encoding.rs +++ b/programs/verifier/src/evm/encoding.rs @@ -1,6 +1,5 @@ use crate::domain::{Report, SignedReport}; use crate::errors::ErrorCode; -use anchor_lang::solana_program::keccak::hash as keccak256; use ethabi::{decode, ParamType, Token}; use std::convert::TryInto; @@ -84,8 +83,8 @@ impl Encoder { data: &[u8], offset: usize, ) -> Result<&[u8], ErrorCode> { - // Ensure the input has at least the minimum required length - if offset + WORD_SIZE > data.len() { + // Ensure the input has at least the minimum required length, without overflowing on malformed offsets + if offset.checked_add(WORD_SIZE).map_or(true, |end| end > data.len()) { return Err(ErrorCode::BadVerification); } @@ -110,8 +109,8 @@ impl Encoder { data: &[u8], offset: usize, ) -> Result<&[[u8; WORD_SIZE]], ErrorCode> { - // Ensure the input has at least the minimum required length - if offset + WORD_SIZE > data.len() { + // Ensure the input has at least the minimum required length, without overflowing on malformed offsets + if offset.checked_add(WORD_SIZE).map_or(true, |end| end > data.len()) { return Err(ErrorCode::BadVerification); } @@ -175,27 +174,4 @@ impl Encoder { report_timestamp, }) } - - pub fn encode_don_config_id(signers: &[[u8; 20]], f: u8) -> Vec { - // `abi.encodePacked` includes padding for array types. Padded to multiple of 32 bytes. - // `+1` for `f` byte - let mut encoded = Vec::with_capacity(signers.len() * WORD_SIZE + 1); - const PADDING: [u8; 12] = [0u8; 12]; - for item in signers { - encoded.extend_from_slice(&PADDING); - encoded.extend_from_slice(&item[..]); - } - encoded.push(f); - encoded - } - - - pub fn compute_don_config_id(encoded: &[u8]) -> [u8; 24] { - let hash = keccak256(encoded); - // For consistency with source chain contract - first 24 bytes of hash is `don_config_id`. - let don_config_id = hash.to_bytes()[..24] - .try_into() - .expect("Slice with incorrect length"); - don_config_id - } } \ No newline at end of file diff --git a/programs/verifier/src/evm/encoding_test.rs b/programs/verifier/src/evm/encoding_test.rs new file mode 100644 index 0000000..27cdc60 --- /dev/null +++ b/programs/verifier/src/evm/encoding_test.rs @@ -0,0 +1,161 @@ +use super::encoding::Encoder; +use crate::errors::ErrorCode; +use test_utils::report::{ + generate_report_with_signers_and_digest, test_config_digest, Report, V3Report, +}; + +const WORD_SIZE: usize = 32; +const TIMESTAMP: u32 = 1_750_000_000; + +fn signed_report(signers_per_report: usize) -> Vec { + let (report, _) = generate_report_with_signers_and_digest::( + test_config_digest(1), + 4, + signers_per_report, + Some(TIMESTAMP), + None, + ); + report +} + +fn word(data: &[u8], index: usize) -> usize { + u64::from_be_bytes(data[index * WORD_SIZE + 24..(index + 1) * WORD_SIZE].try_into().unwrap()) as usize +} + +fn set_word(data: &mut [u8], byte_offset: usize, value: u64) { + data[byte_offset..byte_offset + WORD_SIZE].fill(0); + data[byte_offset + 24..byte_offset + WORD_SIZE].copy_from_slice(&value.to_be_bytes()); +} + +fn assert_bad_verification(result: Result) { + assert!( + matches!(result, Err(ErrorCode::BadVerification)), + "expected BadVerification, got {:?}", + result + ); +} + +// Head of the signed report: report_context (3 words), then offsets of report_data, rs, ss, then raw_vs +const REPORT_DATA_OFFSET_WORD: usize = 3; +const RS_OFFSET_WORD: usize = 4; +const SS_OFFSET_WORD: usize = 5; + +#[test] +fn test_parse_signed_report() { + let report = signed_report(3); + let parsed = Encoder::parse_signed_report(&report).unwrap(); + + assert_eq!(parsed.report_context[0], test_config_digest(1)); + assert_eq!(parsed.report_context[1], [0u8; 32]); + assert_eq!(parsed.report_context[2], [0u8; 32]); + assert_eq!(parsed.report_data, V3Report::dummy(Some(TIMESTAMP)).encode().as_slice()); + assert_eq!(parsed.rs.len(), 3); + assert_eq!(parsed.ss.len(), 3); + assert!(parsed.raw_vs[..3].iter().all(|v| *v <= 1)); + assert!(parsed.raw_vs[3..].iter().all(|v| *v == 0)); +} + +#[test] +fn test_parse_signed_report_without_signatures() { + let report = signed_report(0); + let parsed = Encoder::parse_signed_report(&report).unwrap(); + + assert!(parsed.rs.is_empty()); + assert!(parsed.ss.is_empty()); +} + +#[test] +fn test_parse_report_details() { + let report_data = V3Report::dummy(Some(TIMESTAMP)).encode(); + let details = Encoder::parse_report_details_from_report(&report_data).unwrap(); + + assert_eq!(details.feed_id, &report_data[0..32]); + assert_eq!(details.feed_id[0..2], [0x00, 0x03]); + assert_eq!(details.report_timestamp, TIMESTAMP); +} + +#[test] +fn test_parse_report_details_needs_96_bytes() { + let report_data = V3Report::dummy(Some(TIMESTAMP)).encode(); + + assert!(Encoder::parse_report_details_from_report(&report_data[..96]).is_ok()); + assert_bad_verification(Encoder::parse_report_details_from_report(&report_data[..95])); + assert_bad_verification(Encoder::parse_report_details_from_report(&report_data[..31])); + assert_bad_verification(Encoder::parse_report_details_from_report(&[])); +} + +#[test] +fn test_parse_fails_on_short_input() { + assert_bad_verification(Encoder::parse_signed_report(&[])); + assert_bad_verification(Encoder::parse_signed_report(&[0u8; 7 * WORD_SIZE - 1])); +} + +#[test] +fn test_parse_fails_on_truncated_report() { + let report = signed_report(3); + + // Every truncation of a valid report must fail cleanly + for len in 0..report.len() { + assert_bad_verification(Encoder::parse_signed_report(&report[..len])); + } +} + +#[test] +fn test_parse_fails_on_offset_out_of_bounds() { + for offset_word in [REPORT_DATA_OFFSET_WORD, RS_OFFSET_WORD, SS_OFFSET_WORD] { + let mut report = signed_report(3); + let len = report.len() as u64; + + // Points at the last word, so there is no room for the data after the length + set_word(&mut report, offset_word * WORD_SIZE, len - WORD_SIZE as u64 + 1); + assert_bad_verification(Encoder::parse_signed_report(&report)); + + set_word(&mut report, offset_word * WORD_SIZE, len); + assert_bad_verification(Encoder::parse_signed_report(&report)); + + // Would overflow when adding the word size + set_word(&mut report, offset_word * WORD_SIZE, u64::MAX); + assert_bad_verification(Encoder::parse_signed_report(&report)); + } +} + +#[test] +fn test_parse_fails_on_length_out_of_bounds() { + for offset_word in [REPORT_DATA_OFFSET_WORD, RS_OFFSET_WORD, SS_OFFSET_WORD] { + let mut report = signed_report(3); + let length_position = word(&report, offset_word); + let len = report.len() as u64; + + set_word(&mut report, length_position, len); + assert_bad_verification(Encoder::parse_signed_report(&report)); + + // Would overflow when computing the end of the data + set_word(&mut report, length_position, u64::MAX); + assert_bad_verification(Encoder::parse_signed_report(&report)); + } +} + +#[test] +fn test_parse_reads_mismatched_signature_arrays() { + // The parser does not compare rs and ss lengths, verify rejects them with MismatchedSignatures + let mut report = signed_report(3); + let ss_length_position = word(&report, SS_OFFSET_WORD); + set_word(&mut report, ss_length_position, 2); + + let parsed = Encoder::parse_signed_report(&report).unwrap(); + assert_eq!(parsed.rs.len(), 3); + assert_eq!(parsed.ss.len(), 2); +} + +#[test] +fn test_parse_ignores_high_bytes_of_offsets() { + // Offsets and lengths are read from the last 8 bytes of each word, the rest is ignored. Reports + // parsed this way are still only accepted if their content is signed by the DON. + let report = signed_report(3); + let mut modified = report.clone(); + modified[REPORT_DATA_OFFSET_WORD * WORD_SIZE] = 0xff; + + let parsed = Encoder::parse_signed_report(&report).unwrap(); + let parsed_modified = Encoder::parse_signed_report(&modified).unwrap(); + assert_eq!(parsed.report_data, parsed_modified.report_data); +} diff --git a/programs/verifier/src/evm/signature_test.rs b/programs/verifier/src/evm/signature_test.rs new file mode 100644 index 0000000..0260e92 --- /dev/null +++ b/programs/verifier/src/evm/signature_test.rs @@ -0,0 +1,114 @@ +use super::encoding::Encoder; +use super::signature::{ecrecover, is_zero_address}; +use anchor_lang::solana_program::keccak::hash as keccak256; +use test_utils::report::{generate_report_with_signers_and_digest, get_signers, test_config_digest, V3Report}; + +// Signs a report with the given signers and returns the report with the hash the signatures cover +fn signed_report(signers: &[test_utils::report::Signer]) -> (Vec, [u8; 32]) { + let (report, _) = generate_report_with_signers_and_digest::( + test_config_digest(1), + signers.len(), + signers.len(), + None, + Some(signers.to_vec()), + ); + + let parsed = Encoder::parse_signed_report(&report).unwrap(); + let hash = keccak256( + &[ + &keccak256(parsed.report_data).to_bytes()[..], + &parsed.report_context[0][..], + &parsed.report_context[1][..], + &parsed.report_context[2][..], + ] + .concat(), + ) + .to_bytes(); + + (report, hash) +} + +#[test] +fn test_ecrecover_returns_signer_address() { + let signers = get_signers(4); + let (report, hash) = signed_report(&signers); + let parsed = Encoder::parse_signed_report(&report).unwrap(); + + for (i, signer) in signers.iter().enumerate() { + let address = ecrecover(&hash, &parsed.rs[i], &parsed.ss[i], parsed.raw_vs[i]).unwrap(); + assert_eq!(address, signer.signer_address); + } +} + +#[test] +fn test_ecrecover_accepts_v_as_27_or_28() { + let signers = get_signers(4); + let (report, hash) = signed_report(&signers); + let parsed = Encoder::parse_signed_report(&report).unwrap(); + + for (i, signer) in signers.iter().enumerate() { + // Reports encode v as the recovery id (0 or 1), Ethereum style v is 27 or 28 + let v = parsed.raw_vs[i]; + assert!(v <= 1); + let address = ecrecover(&hash, &parsed.rs[i], &parsed.ss[i], v + 27).unwrap(); + assert_eq!(address, signer.signer_address); + } +} + +#[test] +fn test_ecrecover_with_wrong_v_does_not_return_signer() { + let signers = get_signers(1); + let (report, hash) = signed_report(&signers); + let parsed = Encoder::parse_signed_report(&report).unwrap(); + + let flipped_v = 1 - parsed.raw_vs[0]; + if let Ok(address) = ecrecover(&hash, &parsed.rs[0], &parsed.ss[0], flipped_v) { + assert_ne!(address, signers[0].signer_address); + } +} + +#[test] +fn test_ecrecover_fails_on_invalid_recovery_id() { + let signers = get_signers(1); + let (report, hash) = signed_report(&signers); + let parsed = Encoder::parse_signed_report(&report).unwrap(); + + for v in [4u8, 26, 31, 255] { + assert!(ecrecover(&hash, &parsed.rs[0], &parsed.ss[0], v).is_err(), "v = {v}"); + } +} + +#[test] +fn test_ecrecover_with_wrong_hash_does_not_return_signer() { + let signers = get_signers(1); + let (report, mut hash) = signed_report(&signers); + let parsed = Encoder::parse_signed_report(&report).unwrap(); + hash[0] ^= 0xff; + + if let Ok(address) = ecrecover(&hash, &parsed.rs[0], &parsed.ss[0], parsed.raw_vs[0]) { + assert_ne!(address, signers[0].signer_address); + } +} + +#[test] +fn test_ecrecover_fails_on_invalid_signature() { + let hash = [1u8; 32]; + + // r and s must be in the range [1, n - 1] of the secp256k1 curve + assert!(ecrecover(&hash, &[0u8; 32], &[1u8; 32], 0).is_err()); + assert!(ecrecover(&hash, &[1u8; 32], &[0u8; 32], 0).is_err()); + assert!(ecrecover(&hash, &[0xffu8; 32], &[0xffu8; 32], 0).is_err()); +} + +#[test] +fn test_is_zero_address() { + assert!(is_zero_address(&[0u8; 20])); + + let mut address = [0u8; 20]; + address[19] = 1; + assert!(!is_zero_address(&address)); + + let mut address = [0u8; 20]; + address[0] = 1; + assert!(!is_zero_address(&address)); +} diff --git a/programs/verifier/src/lib.rs b/programs/verifier/src/lib.rs index fa18a8f..882b7c8 100644 --- a/programs/verifier/src/lib.rs +++ b/programs/verifier/src/lib.rs @@ -18,8 +18,6 @@ use state::*; use util::*; use evm::Encoder; -use hex::encode as hex_encode; -use std::borrow::BorrowMut; use std::cell::Ref; declare_id!("Gt9S41PtjR58CbG9JhJ3J6vxesqrNAswbWYbLNTMZA3c"); @@ -39,153 +37,106 @@ pub mod verifier { Ok(()) } - pub fn set_config_with_activation_time( - ctx: Context, + /// Sets the DON configuration for a config digest. Creates the config PDA derived from `[config_digest]` + pub fn set_config( + ctx: Context, + config_digest: [u8; 32], signers: Vec<[u8; 20]>, f: u8, - activation_time: u32, ) -> Result<()> { - require!(f > 0, errors::ErrorCode::FaultToleranceMustBePositive); - - require!( - signers.len() > 3 * f as usize, - errors::ErrorCode::InsufficientSigners - ); + let config_account = &mut ctx.accounts.config_account; + // An initialized config account always has a non-zero version require!( - signers.len() <= MAX_NUMBER_OF_ORACLES as usize, - errors::ErrorCode::ExcessSigners + config_account.version == 0, + errors::ErrorCode::ConfigDigestAlreadySet ); - // Check that activationTime is not in the future. - require!( - activation_time <= Clock::get()?.unix_timestamp as u32, - errors::ErrorCode::BadActivationTime - ); - - let mut verifier_account = ctx.accounts.verifier_account.load_mut()?; - - // Check we haven't reached the max number of configs - require!( - verifier_account.don_configs.len() < MAX_NUMBER_OF_DON_CONFIGS, - errors::ErrorCode::MaxNumberOfConfigsReached - ); + let sorted_signers = validate_config(&config_digest, signers, f)?; - // Sort signers to ensure donConfigId is deterministic. - let mut sorted_signers = signers; - sorted_signers.sort_unstable(); - - // Check for duplicate addresses in signers. - require!( - !SliceUtil::has_duplicates_sorted(&sorted_signers), - errors::ErrorCode::NonUniqueSignatures - ); - - let don_config_id = Encoder::compute_don_config_id(&Encoder::encode_don_config_id(&sorted_signers, f)); - - // Check if there are any existing configs - if let Some(last_don_config) = verifier_account.don_configs.last() { - // Check the config we're setting isn't already set as the current active config as this will increase search costs unnecessarily when verifying historic reports - require!( - last_don_config.don_config_id != don_config_id, - errors::ErrorCode::DonConfigAlreadyExists - ); - - // Check that activation time is after the last config - require!( - last_don_config.activation_time < activation_time, - errors::ErrorCode::BadActivationTime - ); - } - - // Register the signers for this DON - let mut signers_array = SigningKeys::default(); - for signer in sorted_signers.iter() { - require!( - !is_zero_address(signer), - errors::ErrorCode::ZeroAddress - ); - - signers_array.push(SigningKey { - key: *signer, - }); - } - - verifier_account.don_configs.push(DonConfig { - don_config_id, - f, - is_active: 1, - activation_time, - _padding: 0, - signers: signers_array, - }); + config_account.version = DIGEST_CONFIG_VERSION; + config_account.config_digest = config_digest; + config_account.f = f; + config_account.is_active = true; + config_account.bump = ctx.bumps.config_account; + config_account.signers = sorted_signers.clone(); emit!(ConfigSet { - don_config_id: hex_encode(don_config_id), + config_digest, signers: sorted_signers, f, - don_config_index: (verifier_account.don_configs.len() - 1) as u16, }); Ok(()) } - pub fn set_config( - ctx: Context, + /// Replaces the signers and fault tolerance of an existing config digest. The active state is unchanged + pub fn update_config( + ctx: Context, + config_digest: [u8; 32], signers: Vec<[u8; 20]>, f: u8, ) -> Result<()> { - set_config_with_activation_time( - ctx, - signers, + let sorted_signers = validate_config(&config_digest, signers, f)?; + + let config_account = &mut ctx.accounts.config_account; + config_account.f = f; + config_account.signers = sorted_signers.clone(); + + emit!(ConfigUpdated { + config_digest, + signers: sorted_signers, f, - Clock::get()?.unix_timestamp as u32, - ) + }); + + Ok(()) } - pub fn set_config_active( - ctx: Context, - don_config_index: u64, - is_active: u8, + pub fn activate_config( + ctx: Context, + config_digest: [u8; 32], ) -> Result<()> { - let mut verifier_account = ctx.accounts.verifier_account.load_mut()?; - require!( - don_config_index < verifier_account.don_configs.len() as u64, - errors::ErrorCode::DonConfigDoesNotExist - ); - verifier_account.don_configs[don_config_index as usize].is_active = is_active; - emit!(ConfigActivated { - don_config_id: hex_encode( - verifier_account.don_configs[don_config_index as usize].don_config_id - ), - is_active: is_active != 0, - }); + ctx.accounts.config_account.is_active = true; + emit!(ConfigActivated { config_digest }); + Ok(()) + } + + pub fn deactivate_config( + ctx: Context, + config_digest: [u8; 32], + ) -> Result<()> { + ctx.accounts.config_account.is_active = false; + emit!(ConfigDeactivated { config_digest }); + Ok(()) + } + + /// Closes the config PDA for a config digest and refunds its rent to the owner + pub fn close_config( + _ctx: Context, + config_digest: [u8; 32], + ) -> Result<()> { + emit!(ConfigClosed { config_digest }); Ok(()) } - pub fn remove_latest_config(ctx: Context) -> Result<()> { + /// Enables or disables falling back to the legacy `don_configs` when no config PDA exists for a report's digest + pub fn set_legacy_fallback(ctx: Context, enabled: bool) -> Result<()> { let mut verifier_account = ctx.accounts.verifier_account.load_mut()?; - require!( - !verifier_account.don_configs.is_empty(), - errors::ErrorCode::DonConfigDoesNotExist - ); - let c = verifier_account.don_configs.pop().unwrap(); - emit!(ConfigRemoved { - don_config_id: hex_encode(c.don_config_id) - }); + verifier_account.legacy_fallback_disabled = u8::from(!enabled); + emit!(LegacyFallbackSet { enabled }); Ok(()) } /// Used to Set the access controller - /// We use an optional access controller. - /// See https://github.com/coral-xyz/anchor/pull/2101 on how option works in Anchor + /// We use an optional access controller. + /// See https://github.com/coral-xyz/anchor/pull/2101 on how option works in Anchor pub fn set_access_controller(ctx: Context) -> Result<()> { let mut verifier_account = ctx.accounts.verifier_account.load_mut()?; verifier_account.verifier_account_config.access_controller = ctx.accounts.access_controller .as_ref() .map_or(Pubkey::default(), |ac| ac.key()); - + emit!(AccessControllerSet { access_controller: verifier_account.verifier_account_config.access_controller.key() }); @@ -201,8 +152,8 @@ pub mod verifier { } /// Initializes the verifier (admin) account data. Call after initialize + realloc - /// We use an optional access controller. - /// See https://github.com/coral-xyz/anchor/pull/2101 on how option works in Anchor + /// We use an optional access controller. + /// See https://github.com/coral-xyz/anchor/pull/2101 on how option works in Anchor pub fn initialize_account_data( ctx: Context ) -> Result<()> { @@ -237,12 +188,50 @@ pub mod verifier { } } +/// Validates a DON configuration and returns the signers sorted +fn validate_config(config_digest: &[u8; 32], signers: Vec<[u8; 20]>, f: u8) -> Result> { + require!( + *config_digest != [0u8; 32], + errors::ErrorCode::DigestEmpty + ); + + require!(f > 0, errors::ErrorCode::FaultToleranceMustBePositive); + + require!( + signers.len() > 3 * f as usize, + errors::ErrorCode::InsufficientSigners + ); + + require!( + signers.len() <= MAX_NUMBER_OF_ORACLES as usize, + errors::ErrorCode::ExcessSigners + ); + + let mut sorted_signers = signers; + sorted_signers.sort_unstable(); + + // Check for duplicate addresses in signers. + require!( + !SliceUtil::has_duplicates_sorted(&sorted_signers), + errors::ErrorCode::NonUniqueSignatures + ); + + for signer in sorted_signers.iter() { + require!( + !is_zero_address(signer), + errors::ErrorCode::ZeroAddress + ); + } + + Ok(sorted_signers) +} + fn verify_report( ctx: &Context, signed_report: &[u8], verifier_account: &Ref ) -> Result> { - + let decompressed_report = Compressor::decompress(signed_report); let SignedReport { @@ -303,36 +292,56 @@ fn verify_report( // Parse report details from report_data let report = Encoder::parse_report_details_from_report(report_data)?; - // Find the active DON configuration based on the report timestamp - let active_don_config = verifier_account - .don_configs - .iter() - .rev() - .find(|config| config.activation_time <= report.report_timestamp) - .ok_or(errors::ErrorCode::BadVerification)?; + let (f, registered_signers) = if ctx.accounts.config_account.owner == &ID { + // The config PDA for the report's digest exists + let data = ctx.accounts.config_account.try_borrow_data()?; + let digest_config = DigestConfig::try_deserialize(&mut &data[..])?; - // Ensure the active DON is indeed active - require!( - active_don_config.is_active != 0, - errors::ErrorCode::ConfigDeactivated - ); + require!( + digest_config.config_digest == report_context[0], + errors::ErrorCode::InvalidConfigAccount + ); + + require!( + digest_config.is_active, + errors::ErrorCode::ConfigDeactivated + ); + + (digest_config.f, digest_config.signers) + } else if verifier_account.legacy_fallback_disabled == 0 { + // No config PDA for the report's digest. Find the legacy DON configuration based on the report timestamp + msg!("legacy config fallback"); + + let active_don_config = verifier_account + .don_configs + .iter() + .rev() + .find(|config| config.activation_time <= report.report_timestamp) + .ok_or(errors::ErrorCode::BadVerification)?; + + // Ensure the active DON is indeed active + require!( + active_don_config.is_active != 0, + errors::ErrorCode::ConfigDeactivated + ); + + ( + active_don_config.f, + active_don_config.signers.iter().map(|s| s.key).collect::>(), + ) + } else { + return Err(errors::ErrorCode::DigestNotSet.into()); + }; // Verify that the number of signers exceeds the threshold 'f' require!( - signers.len() > active_don_config.f as usize, + signers.len() > f as usize, errors::ErrorCode::BadVerification ); - // Get registered signers - let registered_signers: Vec<&[u8; 20]> = active_don_config - .signers - .iter() - .map(|s| &s.key) - .collect(); - // Check each signer is registered for signer in signers.iter() { - if !registered_signers.iter().any(|registered| signer == *registered) { + if !registered_signers.iter().any(|registered| signer == registered) { return Err(errors::ErrorCode::BadVerification.into()); } } @@ -343,4 +352,4 @@ fn verify_report( }); Ok(report_data.to_vec()) -} \ No newline at end of file +} diff --git a/programs/verifier/src/state/digest_config.rs b/programs/verifier/src/state/digest_config.rs new file mode 100644 index 0000000..ca2e1f9 --- /dev/null +++ b/programs/verifier/src/state/digest_config.rs @@ -0,0 +1,26 @@ +use anchor_lang::prelude::*; + +pub const DIGEST_CONFIG_VERSION: u8 = 1; + +/// DON configuration for a single config digest. +/// Stored in a PDA derived from `[config_digest]`, which is the same account the client passes as +/// `config_account` when verifying a report (seed = first 32 bytes of the uncompressed report). +#[account] +#[derive(InitSpace)] +pub struct DigestConfig { + // Versioning for migrating state. 0 = uninitialized + pub version: u8, + // The OCR config digest this config is keyed by + pub config_digest: [u8; 32], + // Fault tolerance of the DON + pub f: u8, + // Whether the config is active + pub is_active: bool, + // PDA bump + pub bump: u8, + // The sorted list of signers within this config + #[max_len(31)] // MAX_NUMBER_OF_ORACLES + pub signers: Vec<[u8; 20]>, + // Reserved for future use + pub reserved: [u8; 32], +} diff --git a/programs/verifier/src/state/mod.rs b/programs/verifier/src/state/mod.rs index 24e9a55..32645c5 100644 --- a/programs/verifier/src/state/mod.rs +++ b/programs/verifier/src/state/mod.rs @@ -1,3 +1,5 @@ +mod digest_config; mod verifier_account; +pub use digest_config::*; pub use verifier_account::*; \ No newline at end of file diff --git a/programs/verifier/src/state/verifier_account.rs b/programs/verifier/src/state/verifier_account.rs index 12845f6..743f510 100644 --- a/programs/verifier/src/state/verifier_account.rs +++ b/programs/verifier/src/state/verifier_account.rs @@ -62,11 +62,14 @@ arrayvec!(DonConfigs, DonConfig, u16); pub struct VerifierAccount { // Versioning for migrating state pub version: u8, + // 0 = verify falls back to `don_configs` when no config PDA exists for the report's digest. + // 1 = fallback disabled. + pub legacy_fallback_disabled: u8, // Add padding to ensure 8-byte alignment - pub padding: [u8; 7], + pub padding: [u8; 6], // Account configuration pub verifier_account_config: VerifierAccountConfig, - // The list of DON configurations to lookup when verifying a report + // Legacy DON configurations, looked up by report timestamp. Only read by the legacy fallback in verify pub don_configs: DonConfigs } diff --git a/programs/verifier/tests/common/fixtures.rs b/programs/verifier/tests/common/fixtures.rs new file mode 100644 index 0000000..33d9280 --- /dev/null +++ b/programs/verifier/tests/common/fixtures.rs @@ -0,0 +1,25 @@ +#![allow(dead_code)] + +use hex_literal::hex; + +/// A real signed v3 report. The first 32 bytes (report_context[0]) are its config digest +pub const FIXTURE_REPORT: [u8; 736] = hex!("000906f3cbb5a230ad230e8f693aecc4aa5ff7a5c63ecf67ec7201c8a237152c000000000000000000000000000000000000000000000000000000000027018a000000000000000000000000000000000000000000000000000000010000000100000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000280010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001200003ab9412a454b0fb347d0c2c3062186f60640057203d5fb20982d7fb9c927f0000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000221896f269e60000000000000000000000000000000000000000000000000012f260aec4d6000000000000000000000000000000000000000000000000000000000067abc2c00000000000000000000000000000000000000000000000000de08c8d4fa030c80000000000000000000000000000000000000000000000000de065a57df39d200000000000000000000000000000000000000000000000000de0e2fe819758000000000000000000000000000000000000000000000000000000000000000002f173d87393dd8a9dcb97847d1a9a0710e7e4216655477631523a2284e7672790c758cd6413f08d730a3c96b3ede2aca6c9daa554f57b3221754aa579bcea720100000000000000000000000000000000000000000000000000000000000000026284f170f3e580bc532020b1f526b75d7012a632003da5d30f316434689e499509bb8dee47c9c92896e3b2350a74ffcdd564286fc250fe31df3043cfdc2951ef"); + +/// Config digest of `FIXTURE_REPORT` +pub const FIXTURE_DIGEST: [u8; 32] = hex!("000906f3cbb5a230ad230e8f693aecc4aa5ff7a5c63ecf67ec7201c8a237152c"); + +/// Fault tolerance of the DON that signed `FIXTURE_REPORT` +pub const FIXTURE_F: u8 = 1; + +/// Signers of the DON that signed `FIXTURE_REPORT` +pub fn fixture_signers() -> Vec<[u8; 20]> { + vec![ + hex!("38C7EA2f6b878509f3e2d0bbE9adF328e1Df2f6C"), + hex!("a669f0bE9F92e3fe5Eb7b28d1852dFf84C7516Cc"), + hex!("8735F9dd83c0b03571b39Fe9FfbB05e02bc08c28"), + hex!("29679cD77AAce065B885b190368f04fDD7E587AD"), + ] +} + +/// Expected verify return data (the report data) of `FIXTURE_REPORT` +pub const FIXTURE_REPORT_DATA: &str = "0003ab9412a454b0fb347d0c2c3062186f60640057203d5fb20982d7fb9c927f0000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000221896f269e60000000000000000000000000000000000000000000000000012f260aec4d6000000000000000000000000000000000000000000000000000000000067abc2c00000000000000000000000000000000000000000000000000de08c8d4fa030c80000000000000000000000000000000000000000000000000de065a57df39d200000000000000000000000000000000000000000000000000de0e2fe81975800"; diff --git a/programs/verifier/tests/common/mod.rs b/programs/verifier/tests/common/mod.rs index 3add9a5..f222fd0 100644 --- a/programs/verifier/tests/common/mod.rs +++ b/programs/verifier/tests/common/mod.rs @@ -1 +1,2 @@ +pub mod fixtures; pub mod test_setup; diff --git a/programs/verifier/tests/verifier_activate_config_test.rs b/programs/verifier/tests/verifier_activate_config_test.rs new file mode 100644 index 0000000..b61ae56 --- /dev/null +++ b/programs/verifier/tests/verifier_activate_config_test.rs @@ -0,0 +1,181 @@ +use crate::common::fixtures::{fixture_signers, FIXTURE_DIGEST, FIXTURE_F, FIXTURE_REPORT}; +use crate::common::test_setup::{VerifierTestSetup, VerifierTestSetupBuilder}; +use anchor_lang::error::ErrorCode::AccountNotInitialized; +use solana_program_test::tokio; +use solana_sdk::signature::Keypair; +use solana_sdk::signer::Signer; +use test_utils::assert::Assert; +use test_utils::report::test_config_digest; +use verifier::errors::ErrorCode; +use verifier::events::{ConfigActivated, ConfigDeactivated}; +use verifier::util::{Compressor, LogParser}; + +pub mod common; + +#[tokio::test] +async fn test_deactivate_and_activate_config() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let result = verifier_client + .set_config( + &mut environment_context, + &user, + FIXTURE_DIGEST, + fixture_signers(), + FIXTURE_F, + ) + .await; + Assert::transaction_ok(&result); + + let compressed_report = Compressor::compress(&FIXTURE_REPORT); + + // Deactivate + let result = verifier_client + .deactivate_config(&mut environment_context, &user, FIXTURE_DIGEST) + .await; + Assert::transaction_ok(&result); + + let event: Option = LogParser::parse_logs(result.unwrap().metadata.unwrap().log_messages); + assert_eq!(event.expect("ConfigDeactivated event should be emitted").config_digest, FIXTURE_DIGEST); + + let config = verifier_client + .read_digest_config(&mut environment_context, FIXTURE_DIGEST) + .await + .unwrap(); + assert!(!config.is_active); + + // Report verification should fail with inactive config + let result = verifier_client + .verify(&mut environment_context, &user, compressed_report.clone(), None) + .await; + Assert::transaction_error(&result, ErrorCode::ConfigDeactivated); + + // Activate + let result = verifier_client + .activate_config(&mut environment_context, &user, FIXTURE_DIGEST) + .await; + Assert::transaction_ok(&result); + + let event: Option = LogParser::parse_logs(result.unwrap().metadata.unwrap().log_messages); + assert_eq!(event.expect("ConfigActivated event should be emitted").config_digest, FIXTURE_DIGEST); + + let config = verifier_client + .read_digest_config(&mut environment_context, FIXTURE_DIGEST) + .await + .unwrap(); + assert!(config.is_active); + + // Report verification should pass with active config + let result = verifier_client + .verify(&mut environment_context, &user, compressed_report, None) + .await; + Assert::transaction_ok(&result); +} + +#[tokio::test] +async fn test_deactivate_config_only_affects_its_digest() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + // Same signers registered for two digests + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, FIXTURE_DIGEST, fixture_signers(), FIXTURE_F) + .await, + ); + let other_digest = test_config_digest(1); + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, other_digest, fixture_signers(), FIXTURE_F) + .await, + ); + + Assert::transaction_ok( + &verifier_client + .deactivate_config(&mut environment_context, &user, other_digest) + .await, + ); + + // The fixture report is for FIXTURE_DIGEST, which is still active + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&FIXTURE_REPORT), None) + .await; + Assert::transaction_ok(&result); +} + +#[tokio::test] +async fn test_activate_and_deactivate_unknown_digest() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let result = verifier_client + .activate_config(&mut environment_context, &user, test_config_digest(1)) + .await; + Assert::transaction_error(&result, AccountNotInitialized); + + let result = verifier_client + .deactivate_config(&mut environment_context, &user, test_config_digest(1)) + .await; + Assert::transaction_error(&result, AccountNotInitialized); +} + +#[tokio::test] +async fn test_activate_and_deactivate_with_non_owner() { + let non_owner = Keypair::new(); + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .add_user(non_owner.pubkey()) + .build() + .await; + + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, FIXTURE_DIGEST, fixture_signers(), FIXTURE_F) + .await, + ); + + let result = verifier_client + .deactivate_config(&mut environment_context, &non_owner, FIXTURE_DIGEST) + .await; + Assert::transaction_error(&result, ErrorCode::Unauthorized); + + let result = verifier_client + .activate_config(&mut environment_context, &non_owner, FIXTURE_DIGEST) + .await; + Assert::transaction_error(&result, ErrorCode::Unauthorized); +} diff --git a/programs/verifier/tests/verifier_close_config_test.rs b/programs/verifier/tests/verifier_close_config_test.rs new file mode 100644 index 0000000..9f793d1 --- /dev/null +++ b/programs/verifier/tests/verifier_close_config_test.rs @@ -0,0 +1,228 @@ +use crate::common::fixtures::{fixture_signers, FIXTURE_DIGEST, FIXTURE_F, FIXTURE_REPORT}; +use crate::common::test_setup::{VerifierTestSetup, VerifierTestSetupBuilder}; +use anchor_lang::error::ErrorCode::AccountNotInitialized; +use solana_program_test::tokio; +use solana_sdk::signature::Keypair; +use solana_sdk::signer::Signer; +use test_utils::assert::Assert; +use test_utils::client::LegacyDonConfig; +use test_utils::environment_context_operations::EnvironmentContextOperations; +use test_utils::report::test_config_digest; +use verifier::errors::ErrorCode; +use verifier::events::ConfigClosed; +use verifier::util::{Compressor, LogParser}; + +pub mod common; + +#[tokio::test] +async fn test_close_config() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + Assert::transaction_ok( + &verifier_client + .set_legacy_fallback(&mut environment_context, &user, false) + .await, + ); + + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, FIXTURE_DIGEST, fixture_signers(), FIXTURE_F) + .await, + ); + + let config_account = verifier_client.config_pda(&FIXTURE_DIGEST); + let rent = EnvironmentContextOperations::get_account(&mut environment_context, config_account) + .await + .unwrap() + .unwrap() + .lamports; + let owner_balance_before = EnvironmentContextOperations::get_account(&mut environment_context, user.pubkey()) + .await + .unwrap() + .unwrap() + .lamports; + + let result = verifier_client + .close_config(&mut environment_context, &user, FIXTURE_DIGEST) + .await; + Assert::transaction_ok(&result); + + let event: Option = LogParser::parse_logs(result.unwrap().metadata.unwrap().log_messages); + assert_eq!(event.expect("ConfigClosed event should be emitted").config_digest, FIXTURE_DIGEST); + + // Account is gone and rent is refunded to the owner (minus the transaction fee) + assert!(EnvironmentContextOperations::get_account(&mut environment_context, config_account) + .await + .unwrap() + .is_none()); + let owner_balance_after = EnvironmentContextOperations::get_account(&mut environment_context, user.pubkey()) + .await + .unwrap() + .unwrap() + .lamports; + assert!(owner_balance_after > owner_balance_before); + assert!(owner_balance_after <= owner_balance_before + rent); + + // Reports for the digest no longer verify + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&FIXTURE_REPORT), None) + .await; + Assert::transaction_error(&result, ErrorCode::DigestNotSet); +} + +#[tokio::test] +async fn test_config_can_be_set_again_after_close() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, FIXTURE_DIGEST, fixture_signers(), FIXTURE_F) + .await, + ); + Assert::transaction_ok( + &verifier_client + .close_config(&mut environment_context, &user, FIXTURE_DIGEST) + .await, + ); + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, FIXTURE_DIGEST, fixture_signers(), FIXTURE_F) + .await, + ); + + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&FIXTURE_REPORT), None) + .await; + Assert::transaction_ok(&result); +} + +#[tokio::test] +async fn test_closed_config_falls_back_to_legacy_when_enabled() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + // The same signers exist as a legacy config + verifier_client + .set_legacy_don_configs( + &mut environment_context, + &[LegacyDonConfig { + signers: fixture_signers(), + f: FIXTURE_F, + activation_time: 1, + is_active: true, + }], + ) + .await; + + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, FIXTURE_DIGEST, fixture_signers(), FIXTURE_F) + .await, + ); + Assert::transaction_ok( + &verifier_client + .close_config(&mut environment_context, &user, FIXTURE_DIGEST) + .await, + ); + + // While the legacy fallback is enabled a closed digest still verifies through the legacy configs + let compressed_report = Compressor::compress(&FIXTURE_REPORT); + let result = verifier_client + .verify(&mut environment_context, &user, compressed_report.clone(), None) + .await; + Assert::transaction_ok(&result); + + // Once the fallback is disabled it no longer does + Assert::transaction_ok( + &verifier_client + .set_legacy_fallback(&mut environment_context, &user, false) + .await, + ); + let result = verifier_client + .verify(&mut environment_context, &user, compressed_report, None) + .await; + Assert::transaction_error(&result, ErrorCode::DigestNotSet); +} + +#[tokio::test] +async fn test_close_unknown_digest() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let result = verifier_client + .close_config(&mut environment_context, &user, test_config_digest(1)) + .await; + + Assert::transaction_error(&result, AccountNotInitialized); +} + +#[tokio::test] +async fn test_close_config_with_non_owner() { + let non_owner = Keypair::new(); + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .add_user(non_owner.pubkey()) + .build() + .await; + + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, FIXTURE_DIGEST, fixture_signers(), FIXTURE_F) + .await, + ); + + let result = verifier_client + .close_config(&mut environment_context, &non_owner, FIXTURE_DIGEST) + .await; + Assert::transaction_error(&result, ErrorCode::Unauthorized); + + assert!(verifier_client + .read_digest_config(&mut environment_context, FIXTURE_DIGEST) + .await + .is_some()); +} diff --git a/programs/verifier/tests/verifier_legacy_fallback_test.rs b/programs/verifier/tests/verifier_legacy_fallback_test.rs new file mode 100644 index 0000000..9587d8c --- /dev/null +++ b/programs/verifier/tests/verifier_legacy_fallback_test.rs @@ -0,0 +1,446 @@ +use crate::common::test_setup::{VerifierTestSetup, VerifierTestSetupBuilder}; +use solana_program_test::tokio; +use solana_sdk::signature::Keypair; +use solana_sdk::signer::Signer; +use test_utils::assert::Assert; +use test_utils::client::LegacyDonConfig; +use test_utils::report::{ + generate_report_with_signers, generate_report_with_signers_and_digest, get_signers, + test_config_digest, V3Report, +}; +use verifier::errors::ErrorCode; +use verifier::events::LegacyFallbackSet; +use verifier::state::MAX_NUMBER_OF_DON_CONFIGS; +use verifier::util::{Compressor, LogParser}; + +pub mod common; + +fn legacy_config(signers: Vec<[u8; 20]>, f: u8, activation_time: u32) -> LegacyDonConfig { + LegacyDonConfig { + signers, + f, + activation_time, + is_active: true, + } +} + +#[tokio::test] +async fn test_legacy_fallback_enabled_by_default() { + let VerifierTestSetup { + mut environment_context, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let verifier_account = verifier_client + .read_verifier_account(&mut environment_context) + .await + .unwrap(); + + assert_eq!(verifier_account.legacy_fallback_disabled, 0); +} + +#[tokio::test] +async fn test_legacy_fallback_verifies_unregistered_digest() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let (report, signers) = generate_report_with_signers_and_digest::(test_config_digest(1), 16, 6, None, None); + + verifier_client + .set_legacy_don_configs(&mut environment_context, &[legacy_config(signers, 5, 1_600_000_000)]) + .await; + + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&report), None) + .await; + Assert::transaction_ok(&result); + + let logs = result.unwrap().metadata.unwrap().log_messages; + assert!( + logs.iter().any(|l| l.contains("legacy config fallback")), + "Verify should log when the legacy fallback is used" + ); +} + +#[tokio::test] +async fn test_legacy_fallback_without_configs() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let (report, _) = generate_report_with_signers_and_digest::(test_config_digest(1), 16, 6, None, None); + + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&report), None) + .await; + + Assert::transaction_error(&result, ErrorCode::BadVerification); +} + +#[tokio::test] +async fn test_digest_config_takes_precedence_over_legacy() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let digest = test_config_digest(1); + let legacy_signers = get_signers(16); + let digest_signers = get_signers(16); + + verifier_client + .set_legacy_don_configs( + &mut environment_context, + &[legacy_config(legacy_signers.iter().map(|s| s.signer_address).collect(), 5, 1_600_000_000)], + ) + .await; + Assert::transaction_ok( + &verifier_client + .set_config( + &mut environment_context, + &user, + digest, + digest_signers.iter().map(|s| s.signer_address).collect(), + 5, + ) + .await, + ); + + // Signed by the legacy signers, but the digest has its own config + let (legacy_signed, _) = generate_report_with_signers_and_digest::(digest, 16, 6, None, Some(legacy_signers)); + Assert::transaction_error( + &verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&legacy_signed), None) + .await, + ErrorCode::BadVerification, + ); + + let (digest_signed, _) = generate_report_with_signers_and_digest::(digest, 16, 6, None, Some(digest_signers)); + Assert::transaction_ok( + &verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&digest_signed), None) + .await, + ); +} + +#[tokio::test] +async fn test_disable_and_enable_legacy_fallback() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let signers = get_signers(16); + let signer_addresses: Vec<[u8; 20]> = signers.iter().map(|s| s.signer_address).collect(); + + verifier_client + .set_legacy_don_configs(&mut environment_context, &[legacy_config(signer_addresses.clone(), 5, 1_600_000_000)]) + .await; + + // A registered digest and an unregistered digest, signed by the same signers + let registered_digest = test_config_digest(1); + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, registered_digest, signer_addresses, 5) + .await, + ); + let (registered_report, _) = generate_report_with_signers_and_digest::(registered_digest, 16, 6, None, Some(signers.clone())); + let (unregistered_report, _) = generate_report_with_signers_and_digest::(test_config_digest(2), 16, 6, None, Some(signers)); + let registered_report = Compressor::compress(®istered_report); + let unregistered_report = Compressor::compress(&unregistered_report); + + Assert::transaction_ok( + &verifier_client + .verify(&mut environment_context, &user, unregistered_report.clone(), None) + .await, + ); + + // Disable + let result = verifier_client + .set_legacy_fallback(&mut environment_context, &user, false) + .await; + Assert::transaction_ok(&result); + + let event: Option = LogParser::parse_logs(result.unwrap().metadata.unwrap().log_messages); + assert!(!event.expect("LegacyFallbackSet event should be emitted").enabled); + + let verifier_account = verifier_client + .read_verifier_account(&mut environment_context) + .await + .unwrap(); + assert_eq!(verifier_account.legacy_fallback_disabled, 1); + + Assert::transaction_error( + &verifier_client + .verify(&mut environment_context, &user, unregistered_report.clone(), None) + .await, + ErrorCode::DigestNotSet, + ); + Assert::transaction_ok( + &verifier_client + .verify(&mut environment_context, &user, registered_report.clone(), None) + .await, + ); + + // Enable + let result = verifier_client + .set_legacy_fallback(&mut environment_context, &user, true) + .await; + Assert::transaction_ok(&result); + + let event: Option = LogParser::parse_logs(result.unwrap().metadata.unwrap().log_messages); + assert!(event.expect("LegacyFallbackSet event should be emitted").enabled); + + let verifier_account = verifier_client + .read_verifier_account(&mut environment_context) + .await + .unwrap(); + assert_eq!(verifier_account.legacy_fallback_disabled, 0); + + Assert::transaction_ok( + &verifier_client + .verify(&mut environment_context, &user, unregistered_report, None) + .await, + ); + Assert::transaction_ok( + &verifier_client + .verify(&mut environment_context, &user, registered_report, None) + .await, + ); +} + +#[tokio::test] +async fn test_set_legacy_fallback_with_non_owner() { + let non_owner = Keypair::new(); + let VerifierTestSetup { + mut environment_context, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .add_user(non_owner.pubkey()) + .build() + .await; + + let result = verifier_client + .set_legacy_fallback(&mut environment_context, &non_owner, false) + .await; + + Assert::transaction_error(&result, ErrorCode::Unauthorized); +} + +// The tests below cover the legacy, timestamp based config lookup which is unchanged + +#[tokio::test] +async fn test_legacy_can_verify_older_reports_with_older_configs() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + // Report for config A with timestamp between config A and B's activation times + let (report_a, signers_a) = generate_report_with_signers::(16, 6, Some(1_500_000_000), None); + let (_, signers_b) = generate_report_with_signers::(16, 6, None, None); + + verifier_client + .set_legacy_don_configs( + &mut environment_context, + &[ + legacy_config(signers_a, 5, 1_400_000_000), + legacy_config(signers_b, 5, 1_600_000_000), + ], + ) + .await; + + // Uses config A since the report timestamp is before config B's activation + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&report_a), None) + .await; + Assert::transaction_ok(&result); +} + +#[tokio::test] +async fn test_legacy_rolling_out_configuration() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let signers_a = get_signers(16); + + // Config B adds one more signer + let mut signers_b = signers_a.clone(); + signers_b.extend(get_signers(1)); + + verifier_client + .set_legacy_don_configs( + &mut environment_context, + &[ + legacy_config(signers_a.iter().map(|s| s.signer_address).collect(), 5, 1_600_000_000), + legacy_config(signers_b.iter().map(|s| s.signer_address).collect(), 5, 1_700_000_000), + ], + ) + .await; + + // Report signed by the last 6 signers of config B, which includes the new signer + let report_signers = signers_b[signers_b.len() - 6..].to_vec(); + let (report, _) = generate_report_with_signers::(16, 6, None, Some(report_signers)); + + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&report), None) + .await; + Assert::transaction_ok(&result); +} + +#[tokio::test] +async fn test_legacy_verify_fails_when_report_is_older_than_config() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let (report, signers) = generate_report_with_signers::(16, 6, Some(1_500_000_000), None); + + verifier_client + .set_legacy_don_configs(&mut environment_context, &[legacy_config(signers, 5, 1_600_000_000)]) + .await; + + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&report), None) + .await; + Assert::transaction_error(&result, ErrorCode::BadVerification); +} + +#[tokio::test] +async fn test_legacy_deactivated_config() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let (report, signers) = generate_report_with_signers::(16, 6, None, None); + + verifier_client + .set_legacy_don_configs( + &mut environment_context, + &[LegacyDonConfig { + signers, + f: 5, + activation_time: 1_600_000_000, + is_active: false, + }], + ) + .await; + + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&report), None) + .await; + Assert::transaction_error(&result, ErrorCode::ConfigDeactivated); +} + +#[tokio::test] +async fn test_legacy_verify_with_max_configs() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let (first_report, first_signers) = generate_report_with_signers::(16, 6, Some(1_600_000_000), None); + let last_activation_time = 1_600_000_000 + MAX_NUMBER_OF_DON_CONFIGS as u32; + let (last_report, last_signers) = generate_report_with_signers::(16, 6, Some(last_activation_time), None); + + let mut configs = vec![legacy_config(first_signers, 5, 1_600_000_000)]; + for i in 1..MAX_NUMBER_OF_DON_CONFIGS - 1 { + let (_, signers) = generate_report_with_signers::(16, 6, None, None); + configs.push(legacy_config(signers, 5, 1_600_000_000 + i as u32)); + } + configs.push(legacy_config(last_signers, 5, last_activation_time)); + + verifier_client + .set_legacy_don_configs(&mut environment_context, &configs) + .await; + + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&first_report), None) + .await; + Assert::transaction_ok(&result); + + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&last_report), None) + .await; + Assert::transaction_ok(&result); +} diff --git a/programs/verifier/tests/verifier_remove_latest_config_test.rs b/programs/verifier/tests/verifier_remove_latest_config_test.rs deleted file mode 100644 index f0af463..0000000 --- a/programs/verifier/tests/verifier_remove_latest_config_test.rs +++ /dev/null @@ -1,174 +0,0 @@ -use solana_program_test::tokio; - -pub mod common; -use crate::common::test_setup::{VerifierTestSetup, VerifierTestSetupBuilder}; -use solana_sdk::signature::{Keypair, Signer}; -use test_utils::{assert::Assert, report::{generate_report_with_signers, V3Report}}; -use verifier::{errors::ErrorCode, events::ConfigRemoved, state::VerifierAccount, util::{Compressor, LogParser}}; - -#[tokio::test] -async fn test_remove_latest_config_when_no_config_should_fail() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - let result = verifier_client - .remove_latest_config(&mut environment_context, &user) - .await - .expect("transaction failed"); - - assert!(result.result.is_err(), "remove_latest_config should fail"); -} - -#[tokio::test] -async fn test_remove_latest_config() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - // Generate signers for config A - let (_, signers_a) = generate_report_with_signers::(16, 6, None, None); - let f_a = (signers_a.len() / 3) as u8; - - // config A - verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_a.clone(), - f_a, - 1_600_000_000, - ) - .await - .expect("transaction failed") - .result - .expect("set_config_with_activation_time failed"); - - // Generate different signers for config B - let (report_b, signers_b) = generate_report_with_signers::(16, 6, None, None); - let f_b = (signers_b.len() / 3) as u8; - - // config B - verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_b.clone(), - f_b, - 1_700_000_000, // increase the activation time - ) - .await - .expect("transaction failed") - .result - .expect("set_config_with_activation_time failed"); - - let verifier_account: VerifierAccount = verifier_client - .read_verifier_account(&mut environment_context) - .await - .unwrap(); - - assert_eq!( - verifier_account.don_configs.len(), - 2, - "DonConfigs should have 2 elements" - ); - - let result = verifier_client - .remove_latest_config(&mut environment_context, &user) - .await - .expect("remove_latest_config failed"); - - let verifier_account_after_remove: VerifierAccount = verifier_client - .read_verifier_account(&mut environment_context) - .await - .unwrap(); - - assert_eq!( - verifier_account_after_remove.don_configs.len(), - 1, - "DonConfigs should have 1 element" - ); - - // on success emit event - // Get the logs from the tx - let logs: Option = LogParser::parse_logs(result.metadata.unwrap().log_messages); - assert!(logs.is_some(), "Logs should be present"); - let logs = logs.unwrap(); - - assert!(logs.don_config_id.len() > 0, "don_config_id should not be empty"); - - // remaining config is preserved - let latest_don_config = verifier_account_after_remove.don_configs.last().unwrap(); - - // Note: The don_config_id might be different now due to the new way of generating signers - // You may need to update this assertion - assert!(hex::encode(latest_don_config.don_config_id).len() > 0, "don_config_id should not be empty"); - - // Re-add config B again to ensure we can re-add a deleted thing - let r = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_b.clone(), - f_b, - 1_700_000_001, // using future timestamp (1 second after the previous one) - ) - .await - .expect("transaction failed") - .result; - - assert!( - r.is_ok(), - "set_config_with_activation_time failed {:?}", - r.err() - ); - - // Compress report_b for verification - let compressed_report_b = Compressor::compress(&report_b); - - // Report verification should pass with active config - let result = verifier_client - .verify(&mut environment_context, &user, compressed_report_b, None) - .await; - - Assert::transaction_ok(&result); - -} - -#[tokio::test] -async fn test_remove_latest_config_with_non_owner() { - let non_owner = Keypair::new(); - let VerifierTestSetup { - mut environment_context, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .add_user(non_owner.pubkey()) - .build() - .await; - - let result = verifier_client - .remove_latest_config(&mut environment_context, &non_owner) - .await; - - Assert::transaction_error(&result, ErrorCode::Unauthorized); -} diff --git a/programs/verifier/tests/verifier_set_config_active_test.rs b/programs/verifier/tests/verifier_set_config_active_test.rs deleted file mode 100644 index 6269354..0000000 --- a/programs/verifier/tests/verifier_set_config_active_test.rs +++ /dev/null @@ -1,118 +0,0 @@ -use crate::common::test_setup::{VerifierTestSetup, VerifierTestSetupBuilder}; -use hex_literal::hex; -use solana_program_test::tokio; -use solana_sdk::signature::Keypair; -use solana_sdk::signer::Signer; - -use test_utils::assert::Assert; -use verifier::errors::ErrorCode; -use verifier::util::Compressor; - -pub mod common; - -#[tokio::test] -async fn test_set_config_active_unknown_don_config_id() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - let result = verifier_client - .set_config_active(&mut environment_context, &user, 1, true) - .await; - - Assert::transaction_error(&result, ErrorCode::DonConfigDoesNotExist); - -} - -#[tokio::test] -async fn test_set_config_active() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - // Add configs - // signers list (as configured when example report was generated) - let signers: Vec<[u8; 20]> = vec![ - hex!("38C7EA2f6b878509f3e2d0bbE9adF328e1Df2f6C"), - hex!("a669f0bE9F92e3fe5Eb7b28d1852dFf84C7516Cc"), - hex!("8735F9dd83c0b03571b39Fe9FfbB05e02bc08c28"), - hex!("29679cD77AAce065B885b190368f04fDD7E587AD"), - ]; - - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 1, // f - 1 // timestamp prior to report timestamp - ) - .await; - - Assert::transaction_ok(&result); - - let result = verifier_client - .set_config_active(&mut environment_context, &user, 0, false) - .await; - - Assert::transaction_ok(&result); - - let test_report_input = hex!("000906f3cbb5a230ad230e8f693aecc4aa5ff7a5c63ecf67ec7201c8a237152c000000000000000000000000000000000000000000000000000000000027018a000000000000000000000000000000000000000000000000000000010000000100000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000280010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001200003ab9412a454b0fb347d0c2c3062186f60640057203d5fb20982d7fb9c927f0000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000221896f269e60000000000000000000000000000000000000000000000000012f260aec4d6000000000000000000000000000000000000000000000000000000000067abc2c00000000000000000000000000000000000000000000000000de08c8d4fa030c80000000000000000000000000000000000000000000000000de065a57df39d200000000000000000000000000000000000000000000000000de0e2fe819758000000000000000000000000000000000000000000000000000000000000000002f173d87393dd8a9dcb97847d1a9a0710e7e4216655477631523a2284e7672790c758cd6413f08d730a3c96b3ede2aca6c9daa554f57b3221754aa579bcea720100000000000000000000000000000000000000000000000000000000000000026284f170f3e580bc532020b1f526b75d7012a632003da5d30f316434689e499509bb8dee47c9c92896e3b2350a74ffcdd564286fc250fe31df3043cfdc2951ef"); - let compressed_report = Compressor::compress(&test_report_input); - - // Report verification should fail with inactive config - let result = verifier_client - .verify(&mut environment_context, &user, compressed_report.clone(), None) - .await; - Assert::transaction_error(&result, ErrorCode::ConfigDeactivated); - - // Set Config Active - let result = verifier_client - .set_config_active(&mut environment_context, &user, 0, true) - .await; - Assert::transaction_ok(&result); - - // Report verification should pass with active config - let result = verifier_client - .verify(&mut environment_context, &user, compressed_report, None) - .await; - Assert::transaction_ok(&result); -} - -#[tokio::test] -async fn test_set_config_active_with_non_owner() { - let non_owner = Keypair::new(); - let VerifierTestSetup { - mut environment_context, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .add_user(non_owner.pubkey()) - .build() - .await; - - let result = verifier_client - .set_config_active(&mut environment_context, &non_owner, 0, true) - .await; - - Assert::transaction_error(&result, ErrorCode::Unauthorized); -} \ No newline at end of file diff --git a/programs/verifier/tests/verifier_set_config_test.rs b/programs/verifier/tests/verifier_set_config_test.rs index 95c5faa..15bd29f 100644 --- a/programs/verifier/tests/verifier_set_config_test.rs +++ b/programs/verifier/tests/verifier_set_config_test.rs @@ -1,11 +1,127 @@ use crate::common::test_setup::{VerifierTestSetup, VerifierTestSetupBuilder}; +use anchor_lang::Space; +use solana_program::pubkey::Pubkey; +use solana_program::rent::Rent; use solana_program_test::tokio; use solana_sdk::signature::{Keypair, Signer}; use test_utils::assert::Assert; +use test_utils::environment_context_operations::EnvironmentContextOperations; +use test_utils::report::{generate_report_with_signers, test_config_digest, V3Report}; +use verifier::common::MAX_NUMBER_OF_ORACLES; use verifier::errors::ErrorCode; +use verifier::events::ConfigSet; +use verifier::state::{DigestConfig, DIGEST_CONFIG_VERSION}; +use verifier::util::LogParser; pub mod common; +fn test_signers(count: u8) -> Vec<[u8; 20]> { + (0..count) + .map(|i| { + let mut signer = [0u8; 20]; + signer[0] = i + 1; + signer + }) + .collect() +} + +#[tokio::test] +async fn test_set_config() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let digest = test_config_digest(1); + // Unsorted signers are stored sorted + let mut signers = test_signers(16); + signers.reverse(); + let f: u8 = 5; + + let result = verifier_client + .set_config(&mut environment_context, &user, digest, signers.clone(), f) + .await; + Assert::transaction_ok(&result); + + let mut sorted_signers = signers.clone(); + sorted_signers.sort_unstable(); + + // Config PDA state + let config = verifier_client + .read_digest_config(&mut environment_context, digest) + .await + .expect("Config account should exist"); + + let (expected_address, expected_bump) = + Pubkey::find_program_address(&[digest.as_ref()], &verifier::ID); + assert_eq!(verifier_client.config_pda(&digest), expected_address); + assert_eq!(config.version, DIGEST_CONFIG_VERSION); + assert_eq!(config.config_digest, digest); + assert_eq!(config.f, f); + assert!(config.is_active); + assert_eq!(config.bump, expected_bump); + assert_eq!(config.signers, sorted_signers); + + // Every config account has the same size, large enough for the max number of signers + let account = EnvironmentContextOperations::get_account(&mut environment_context, expected_address) + .await + .unwrap() + .unwrap(); + assert_eq!(account.owner, verifier::ID); + assert_eq!(account.data.len(), 8 + DigestConfig::INIT_SPACE); + assert_eq!(account.lamports, Rent::default().minimum_balance(8 + DigestConfig::INIT_SPACE)); + + // Event + let event: Option = LogParser::parse_logs(result.unwrap().metadata.unwrap().log_messages); + let event = event.expect("ConfigSet event should be emitted"); + assert_eq!(event.config_digest, digest); + assert_eq!(event.signers, sorted_signers); + assert_eq!(event.f, f); + + // Legacy configs are not touched + let verifier_account = verifier_client + .read_verifier_account(&mut environment_context) + .await + .unwrap(); + assert!(verifier_account.don_configs.is_empty()); +} + +#[tokio::test] +async fn test_set_config_with_max_signers() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let digest = test_config_digest(1); + let signers = test_signers(MAX_NUMBER_OF_ORACLES); + + let result = verifier_client + .set_config(&mut environment_context, &user, digest, signers.clone(), 10) + .await; + Assert::transaction_ok(&result); + + let config = verifier_client + .read_digest_config(&mut environment_context, digest) + .await + .unwrap(); + assert_eq!(config.signers.len(), MAX_NUMBER_OF_ORACLES as usize); +} + #[tokio::test] async fn test_set_config_with_non_owner() { let non_owner = Keypair::new(); @@ -21,14 +137,235 @@ async fn test_set_config_with_non_owner() { .build() .await; + let digest = test_config_digest(1); let result = verifier_client - .set_config( - &mut environment_context, - &non_owner, - vec![[0; 20]], - 1, - ) + .set_config(&mut environment_context, &non_owner, digest, test_signers(4), 1) .await; Assert::transaction_error(&result, ErrorCode::Unauthorized); + + assert!(verifier_client + .read_digest_config(&mut environment_context, digest) + .await + .is_none()); +} + +#[tokio::test] +async fn test_set_config_fails_when_digest_already_set() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let digest = test_config_digest(1); + + let result = verifier_client + .set_config(&mut environment_context, &user, digest, test_signers(4), 1) + .await; + Assert::transaction_ok(&result); + + // Same digest, same config + let result = verifier_client + .set_config(&mut environment_context, &user, digest, test_signers(4), 1) + .await; + Assert::transaction_error(&result, ErrorCode::ConfigDigestAlreadySet); + + // Same digest, different config + let result = verifier_client + .set_config(&mut environment_context, &user, digest, test_signers(16), 5) + .await; + Assert::transaction_error(&result, ErrorCode::ConfigDigestAlreadySet); + + // The original config is unchanged + let config = verifier_client + .read_digest_config(&mut environment_context, digest) + .await + .unwrap(); + assert_eq!(config.f, 1); + assert_eq!(config.signers, test_signers(4)); +} + +#[tokio::test] +async fn test_set_config_same_signers_for_multiple_digests() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + // e.g. blue/green configs of the same DON + for n in 1..=3 { + let result = verifier_client + .set_config(&mut environment_context, &user, test_config_digest(n), test_signers(4), 1) + .await; + Assert::transaction_ok(&result); + } + + for n in 1..=3 { + assert!(verifier_client + .read_digest_config(&mut environment_context, test_config_digest(n)) + .await + .is_some()); + } +} + +#[tokio::test] +async fn test_set_config_fails_on_empty_digest() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let result = verifier_client + .set_config(&mut environment_context, &user, [0u8; 32], test_signers(4), 1) + .await; + + Assert::transaction_error(&result, ErrorCode::DigestEmpty); +} + +#[tokio::test] +async fn test_set_config_fails_on_too_many_signers() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + // 32 is too many + let result = verifier_client + .set_config(&mut environment_context, &user, test_config_digest(1), test_signers(32), 2) + .await; + + Assert::transaction_error(&result, ErrorCode::ExcessSigners); +} + +#[tokio::test] +async fn test_set_config_fails_on_too_high_f() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let digest = test_config_digest(1); + + // 16 signers requires f <= 5 + let result = verifier_client + .set_config(&mut environment_context, &user, digest, test_signers(16), 6) + .await; + Assert::transaction_error(&result, ErrorCode::InsufficientSigners); + + // internal calc (86 * 3 = 258) > u8 (256) would overflow the u8 + let result = verifier_client + .set_config(&mut environment_context, &user, digest, test_signers(10), 86) + .await; + Assert::transaction_error(&result, ErrorCode::InsufficientSigners); +} + +#[tokio::test] +async fn test_set_config_fails_on_zero_fault_tolerance() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let result = verifier_client + .set_config(&mut environment_context, &user, test_config_digest(1), test_signers(15), 0) + .await; + + Assert::transaction_error(&result, ErrorCode::FaultToleranceMustBePositive); +} + +#[tokio::test] +async fn test_set_config_fails_on_duplicate_signer() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let signers: Vec<[u8; 20]> = vec![ + [0x12; 20], // Signer 1 + [0x34; 20], // Signer 2 + [0x56; 20], // Signer 3 + [0x56; 20], // Signer 3 -- duplicate + ]; + + let result = verifier_client + .set_config(&mut environment_context, &user, test_config_digest(1), signers, 1) + .await; + + Assert::transaction_error(&result, ErrorCode::NonUniqueSignatures); +} + +#[tokio::test] +async fn test_set_config_fails_on_zero_address_signer() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let (_, mut signers) = generate_report_with_signers::(16, 6, None, None); + let f = (signers.len() / 3) as u8; + + // Add zero address + signers.push([0u8; 20]); + + let result = verifier_client + .set_config(&mut environment_context, &user, test_config_digest(1), signers, f) + .await; + + Assert::transaction_error(&result, ErrorCode::ZeroAddress); } diff --git a/programs/verifier/tests/verifier_set_config_with_activation_time_test.rs b/programs/verifier/tests/verifier_set_config_with_activation_time_test.rs deleted file mode 100644 index cf6aba5..0000000 --- a/programs/verifier/tests/verifier_set_config_with_activation_time_test.rs +++ /dev/null @@ -1,778 +0,0 @@ -use crate::common::test_setup::{VerifierTestSetup, VerifierTestSetupBuilder}; -use solana_program_test::tokio; -use solana_sdk::signature::{Keypair, Signer}; -use test_utils::assert::Assert; -use test_utils::report::{generate_report_with_signers, V3Report}; -use verifier::common::MAX_NUMBER_OF_ORACLES; -use verifier::errors::ErrorCode; -use verifier::events::ConfigSet; -use verifier::state::VerifierAccount; -use verifier::util::LogParser; -use verifier::state::MAX_NUMBER_OF_DON_CONFIGS; - -pub mod common; - -#[tokio::test] -async fn set_config_with_activation_time_success_test() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - let mut test_signers: Vec<[u8; 20]> = Vec::new(); - for i in 0..16 { - let mut signer = [0u8; 20]; - signer[0] = (i + 1) as u8; - test_signers.push(signer); - } - - let f: u8 = 5; - - let activation_time: u32 = 1_600_000_000; - - // 6. Call set_config_with_activation_time - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - test_signers.clone(), - f, - activation_time, - ) - .await - .unwrap(); - - assert!( - result.result.is_ok(), - "set_config_with_activation_time returned an error: {:?}", - result.result.err() - ); - - // 7. Load the verifier account state and deserialize it - let verifier_account: VerifierAccount = verifier_client - .read_verifier_account(&mut environment_context) - .await - .unwrap(); - - // 8. Verify that the new DonConfig was added correctly - assert!( - !verifier_account.don_configs.is_empty(), - "DonConfigs should not be empty" - ); - - let latest_don_config = verifier_account.don_configs.last().unwrap(); - - // Check the fault tolerance parameter - assert_eq!( - latest_don_config.f, f, - "Fault tolerance parameter 'f' does not match" - ); - - // Check the activation time - assert_eq!( - latest_don_config.activation_time, activation_time, - "Activation time does not match" - ); - - // Check that the signers are correctly populated - for (i, signer) in test_signers.iter().enumerate() { - assert_eq!( - latest_don_config.signers[i].key, *signer, - "Signer at index {} does not match", - i - ); - } - - // Check that the remaining signers are set to default ([0u8; 20]) - for signer in latest_don_config.signers.iter().skip(test_signers.len()) { - assert_eq!( - signer.key, [0u8; 20], - "Remaining signers should be default [0u8; 20]" - ); - } - - assert_eq!( - latest_don_config.signers.len(), test_signers.len(), - "Signers should be same size as test signers" - ); - - assert_eq!( - latest_don_config.signers.capacity() as u8, MAX_NUMBER_OF_ORACLES, - "Signers should be max size of allowed signers" - ); - - // on success emit event - // Get the logs from the tx - let logs: Option = LogParser::parse_logs(result.metadata.unwrap().log_messages); - assert!(logs.is_some(), "Logs should be present"); - - let logs = logs.unwrap(); - - assert_eq!( - logs.don_config_id, - "80ac182049e96c9dbcbd806ba6034cac25ba9a3aa29271e8" - ); - assert_eq!(logs.signers, test_signers); - assert_eq!(logs.f, f); - assert_eq!( - logs.don_config_index, - verifier_account.don_configs.len() as u16 - 1 - ); -} - -#[tokio::test] -async fn set_config_with_activation_time_fails_on_duplicate_don_config_test() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - // 5. Test signers - let signers: Vec<[u8; 20]> = vec![ - [0x12; 20], // Signer 1 - [0x34; 20], // Signer 2 - [0x56; 20], // Signer 3 - [0x78; 20], // Signer 4 - ]; - - // 6. Call set_config_with_activation_time - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 1, // f - 1_600_000_000, - ) - .await; - - Assert::transaction_ok(&result); - - let verifier_account: VerifierAccount = verifier_client - .read_verifier_account(&mut environment_context) - .await - .unwrap(); - - assert!( - !verifier_account.don_configs.is_empty(), - "DonConfigs should not be empty" - ); - - // Call set_config_with_activation_time again with the same signers + f. Should fail. - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 1, // f - 1_700_000_000, // notably different activation time - ) - .await - .unwrap(); - - assert!( - result.result.is_err(), - "set_config_with_activation_time should have failed due to duplicate signers" - ); -} - -#[tokio::test] -async fn set_config_with_activation_time_fails_on_too_many_signers_test() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - // 5. Test signers - 32 is too many - let mut signers: Vec<[u8; 20]> = Vec::new(); - for i in 0..32 { - let signer = [i as u8; 20]; // Create a signer with the value of `i` repeated 20 times - signers.push(signer); - } - - // 6. Call set_config_with_activation_time - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 2, // f - 1_600_000_000, - ) - .await; - - Assert::transaction_error(&result, ErrorCode::ExcessSigners); -} - -#[tokio::test] -async fn set_config_with_activation_time_fails_on_too_high_f_test() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - let mut signers: Vec<[u8; 20]> = Vec::new(); - for i in 0..10 { - let signer = [i as u8; 20]; - signers.push(signer); - } - - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 86, // internal calc (86 * 3 = 258) > u8 (256) would overflow the u8 - 1_600_000_000, - ) - .await; - - Assert::transaction_error(&result, ErrorCode::InsufficientSigners); -} - -#[tokio::test] -async fn set_config_with_activation_time_fails_on_zero_fault_tolerance_test() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - let mut signers: Vec<[u8; 20]> = Vec::new(); - for i in 0..15 { - let signer = [i as u8; 20]; // Create a signer with the value of `i` repeated 20 times - signers.push(signer); - } - - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 0, // f - 1_600_000_000, - ) - .await; - - Assert::transaction_error(&result, ErrorCode::FaultToleranceMustBePositive); -} - -#[tokio::test] -async fn set_config_with_activation_time_fails_on_duplicate_signer_test() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - let signers: Vec<[u8; 20]> = vec![ - [0x12; 20], // Signer 1 - [0x34; 20], // Signer 2 - [0x56; 20], // Signer 3 - [0x56; 20], // Signer 3 -- duplicate - ]; - - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 1, // f - 1_600_000_000, - ) - .await; - - Assert::transaction_error(&result, ErrorCode::NonUniqueSignatures); -} - -#[tokio::test] -async fn set_config_with_activation_time_fails_future_activation_time_test() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - let signers: Vec<[u8; 20]> = vec![ - [0x12; 20], // Signer 1 - [0x34; 20], // Signer 2 - [0x56; 20], // Signer 3 - [0x78; 20], // Signer 4 - ]; - - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 1, // f - 4_000_000_000, // invalid timestamp - future timestamp (year 2096) - ) - .await; - - Assert::transaction_error(&result, ErrorCode::BadActivationTime); -} - -#[tokio::test] -async fn set_config_with_activation_time_fails_on_activation_time_less_than_latest_activation_time_test( -) { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - // 5. Test signers - let signers_1: Vec<[u8; 20]> = vec![ - [0x12; 20], // Signer 1 - [0x34; 20], // Signer 2 - [0x56; 20], // Signer 3 - [0x78; 20], // Signer 4 - ]; - - // 6. Call set_config_with_activation_time - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_1.clone(), - 1, // f - 1_600_000_000, - ) - .await; - - Assert::transaction_ok(&result); - - let verifier_account: VerifierAccount = verifier_client - .read_verifier_account(&mut environment_context) - .await - .unwrap(); - - assert!( - !verifier_account.don_configs.is_empty(), - "DonConfigs should not be empty" - ); - - let signers_2: Vec<[u8; 20]> = vec![ - [0x22; 20], // Signer 1 - [0x44; 20], // Signer 2 - [0x66; 20], // Signer 3 - [0x88; 20], // Signer 4 - ]; - - // Call set_config_with_activation_time again with the same signers + f. Should fail. - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_2.clone(), - 1, // f - 1_500_000_000, // Activation time to less than the previous activation time - ) - .await; - - Assert::transaction_error(&result, ErrorCode::BadActivationTime); -} - -#[tokio::test] -async fn test_set_config_with_activation_time_with_non_owner() { - let non_owner = Keypair::new(); - - let VerifierTestSetup { - mut environment_context, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .add_user(non_owner.pubkey()) - .build() - .await; - - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &non_owner, - vec![[0; 20]], - 1, - 1_600_000_000 - ) - .await; - - Assert::transaction_error(&result, ErrorCode::Unauthorized); -} - - -#[tokio::test] -async fn test_setting_duplicate_config_with_back_to_back_signers() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - // Generate signers for config A - let (_, signers_a) = generate_report_with_signers::(16, 6, None, None); - let f_a = (signers_a.len() / 3) as u8; - - // Set config A - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_a.clone(), - f_a, - 1_600_000_000, - ) - .await; - Assert::transaction_ok(&result); - - // Try to set the same config again with a later activation time - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_a.clone(), - f_a, - 1_600_000_001, - ) - .await; - - // This should fail due to duplicate DON config - Assert::transaction_error(&result, ErrorCode::DonConfigAlreadyExists); -} - - -#[tokio::test] -async fn test_set_config_with_signers_containing_zero_address() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - // Generate signers - let (_, mut signers) = generate_report_with_signers::(16, 6, None, None); - let f = (signers.len() / 3) as u8; - - // Add zero address - signers.push([0u8; 20]); - - // Try to set config with zero address - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - f, - 1_600_000_000, - ) - .await; - - Assert::transaction_error(&result, ErrorCode::ZeroAddress); -} - - -#[tokio::test] -async fn test_setting_duplicate_config_not_back_to_back() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - // Generate signers for config A - let (_, signers_a) = generate_report_with_signers::(16, 6, None, None); - let f_a = (signers_a.len() / 3) as u8; - - // Generate different signers for config B - let (_, signers_b) = generate_report_with_signers::(16, 6, None, None); - let f_b = (signers_b.len() / 3) as u8; - - // Set config A - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_a.clone(), - f_a, - 1_600_000_000, - ) - .await; - Assert::transaction_ok(&result); - - // Set config B - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_b, - f_b, - 1_600_000_001, - ) - .await; - Assert::transaction_ok(&result); - - // Set config A again - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_a, - f_a, - 1_600_000_002, - ) - .await; - Assert::transaction_ok(&result); -} - - -#[tokio::test] -async fn test_set_config_with_f_too_high() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - // Generate signers - let (_, signers) = generate_report_with_signers::(16, 6, None, None); - - // Try to set config with invalid f - let invalid_f = 6; - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - invalid_f, - 1_600_000_000, - ) - .await; - Assert::transaction_error(&result, ErrorCode::InsufficientSigners); - -} - -#[tokio::test] -async fn test_verify_emits_correct_don_config_id() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - // Create fixed set of 16 signers - let signers: Vec<[u8; 20]> = (1..17) - .map(|i| { - let mut signer = [0u8; 20]; - signer[19] = i as u8; - signer - }) - .collect(); - - let f = 5; // Set f value - - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers, - f, - 1_600_000_000, - ) - .await; - - Assert::transaction_ok(&result); - - // Get the logs from the tx - let logs: Option = LogParser::parse_logs(result.unwrap().metadata.unwrap().log_messages); - assert!(logs.is_some(), "Logs should be present"); - - let logs = logs.unwrap(); - - // Check don_config_id matches expected value from Solidity - assert_eq!( - logs.don_config_id, - "56a39dda91c8613fb4720b757cc603299afbcb36340a1cf7" - ); -} - -#[tokio::test] -async fn test_setting_maximum_configs_and_above_max() { - let VerifierTestSetup { - mut environment_context, - user, - verifier_client, - .. - } = VerifierTestSetupBuilder::new() - .program_name("verifier") - .program_id(verifier::ID) - .access_controller(access_controller::ID) - .build() - .await; - - - // Set MAX_NUMBER_OF_DON_CONFIGS configs except the last one which will be set later - for i in 0..(MAX_NUMBER_OF_DON_CONFIGS - 1) as u32 { - // Generate signers using generate_report_with_signers - let (_, signers) = generate_report_with_signers::(16, 0, None, None); - - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 4, // f - 1_600_000_000 + i, // Increment activation time to make each config unique - ) - .await; - - Assert::transaction_ok(&result); - } - - // Generate signers for the final config - let (_, signers) = generate_report_with_signers::(16, 0, None, None); - - // Set the max config - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 4, // f - 1_600_000_000 + (MAX_NUMBER_OF_DON_CONFIGS as u32), // Final activation time - ) - .await; - - Assert::transaction_ok(&result); - - // Verify the last config was set correctly - let verifier_account: VerifierAccount = verifier_client - .read_verifier_account(&mut environment_context) - .await - .unwrap(); - - assert_eq!( - verifier_account.don_configs.len() as usize, - MAX_NUMBER_OF_DON_CONFIGS, - "Should have maximum number of configs" - ); - - // Sort the signers to compare - let mut sorted_signers = signers.clone(); - sorted_signers.sort(); - - - // Verify the configs match as a quick sanity check - let last_config = verifier_account.don_configs.last().unwrap(); - assert_eq!(last_config.f, 4); - assert_eq!(last_config.activation_time, 1_600_000_000 + (MAX_NUMBER_OF_DON_CONFIGS as u32)); - - for (i, signer) in sorted_signers.iter().enumerate() { - assert_eq!( - last_config.signers[i].key, - *signer, - "Signer at index {} does not match", - i - ); - } - - // Try to add one more config beyond the max - let (_, signers) = generate_report_with_signers::(16, 0, None, None); - - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 4, // f - 1_600_000_000 + (MAX_NUMBER_OF_DON_CONFIGS as u32), - ) - .await; - - // Should fail with MaxNumberOfConfigsReached error - Assert::transaction_error(&result, ErrorCode::MaxNumberOfConfigsReached); -} \ No newline at end of file diff --git a/programs/verifier/tests/verifier_update_config_test.rs b/programs/verifier/tests/verifier_update_config_test.rs new file mode 100644 index 0000000..ad2acd0 --- /dev/null +++ b/programs/verifier/tests/verifier_update_config_test.rs @@ -0,0 +1,239 @@ +use crate::common::test_setup::{VerifierTestSetup, VerifierTestSetupBuilder}; +use anchor_lang::error::ErrorCode::AccountNotInitialized; +use solana_program_test::tokio; +use solana_sdk::signature::{Keypair, Signer}; +use test_utils::assert::Assert; +use test_utils::report::{generate_report_with_signers_and_digest, get_signers, test_config_digest, V3Report}; +use verifier::errors::ErrorCode; +use verifier::events::ConfigUpdated; +use verifier::util::{Compressor, LogParser}; + +pub mod common; + +#[tokio::test] +async fn test_update_config() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let digest = test_config_digest(1); + let old_signers = get_signers(16); + let new_signers = get_signers(7); + + Assert::transaction_ok( + &verifier_client + .set_config( + &mut environment_context, + &user, + digest, + old_signers.iter().map(|s| s.signer_address).collect(), + 5, + ) + .await, + ); + + let (old_report, _) = generate_report_with_signers_and_digest::(digest, 16, 6, None, Some(old_signers)); + let (new_report, new_signer_addresses) = generate_report_with_signers_and_digest::(digest, 7, 3, None, Some(new_signers)); + + // New signers can not verify yet + Assert::transaction_error( + &verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&new_report), None) + .await, + ErrorCode::BadVerification, + ); + + let result = verifier_client + .update_config(&mut environment_context, &user, digest, new_signer_addresses.clone(), 2) + .await; + Assert::transaction_ok(&result); + + let mut sorted_signers = new_signer_addresses.clone(); + sorted_signers.sort_unstable(); + + let event: Option = LogParser::parse_logs(result.unwrap().metadata.unwrap().log_messages); + let event = event.expect("ConfigUpdated event should be emitted"); + assert_eq!(event.config_digest, digest); + assert_eq!(event.signers, sorted_signers); + assert_eq!(event.f, 2); + + let config = verifier_client + .read_digest_config(&mut environment_context, digest) + .await + .unwrap(); + assert_eq!(config.config_digest, digest); + assert_eq!(config.f, 2); + assert_eq!(config.signers, sorted_signers); + assert!(config.is_active); + + // Old signers no longer verify, new signers do + Assert::transaction_error( + &verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&old_report), None) + .await, + ErrorCode::BadVerification, + ); + Assert::transaction_ok( + &verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&new_report), None) + .await, + ); +} + +#[tokio::test] +async fn test_update_config_keeps_active_state() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let digest = test_config_digest(1); + let signers: Vec<[u8; 20]> = get_signers(4).iter().map(|s| s.signer_address).collect(); + + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, digest, signers.clone(), 1) + .await, + ); + Assert::transaction_ok( + &verifier_client + .deactivate_config(&mut environment_context, &user, digest) + .await, + ); + Assert::transaction_ok( + &verifier_client + .update_config(&mut environment_context, &user, digest, signers, 1) + .await, + ); + + let config = verifier_client + .read_digest_config(&mut environment_context, digest) + .await + .unwrap(); + assert!(!config.is_active); +} + +#[tokio::test] +async fn test_update_config_fails_when_digest_not_set() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let signers: Vec<[u8; 20]> = get_signers(4).iter().map(|s| s.signer_address).collect(); + + let result = verifier_client + .update_config(&mut environment_context, &user, test_config_digest(1), signers, 1) + .await; + + Assert::transaction_error(&result, AccountNotInitialized); +} + +#[tokio::test] +async fn test_update_config_validates_config() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; + + let digest = test_config_digest(1); + let signers: Vec<[u8; 20]> = get_signers(4).iter().map(|s| s.signer_address).collect(); + + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, digest, signers.clone(), 1) + .await, + ); + + Assert::transaction_error( + &verifier_client + .update_config(&mut environment_context, &user, digest, signers.clone(), 0) + .await, + ErrorCode::FaultToleranceMustBePositive, + ); + Assert::transaction_error( + &verifier_client + .update_config(&mut environment_context, &user, digest, signers.clone(), 2) + .await, + ErrorCode::InsufficientSigners, + ); + + let mut duplicate_signers = signers.clone(); + duplicate_signers.push(signers[0]); + Assert::transaction_error( + &verifier_client + .update_config(&mut environment_context, &user, digest, duplicate_signers, 1) + .await, + ErrorCode::NonUniqueSignatures, + ); + + let mut zero_address_signers = signers.clone(); + zero_address_signers.push([0u8; 20]); + Assert::transaction_error( + &verifier_client + .update_config(&mut environment_context, &user, digest, zero_address_signers, 1) + .await, + ErrorCode::ZeroAddress, + ); +} + +#[tokio::test] +async fn test_update_config_with_non_owner() { + let non_owner = Keypair::new(); + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .add_user(non_owner.pubkey()) + .build() + .await; + + let digest = test_config_digest(1); + let signers: Vec<[u8; 20]> = get_signers(4).iter().map(|s| s.signer_address).collect(); + + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, digest, signers.clone(), 1) + .await, + ); + + let result = verifier_client + .update_config(&mut environment_context, &non_owner, digest, signers, 1) + .await; + + Assert::transaction_error(&result, ErrorCode::Unauthorized); +} diff --git a/programs/verifier/tests/verifier_verify_test.rs b/programs/verifier/tests/verifier_verify_test.rs index d8913b0..74010f0 100644 --- a/programs/verifier/tests/verifier_verify_test.rs +++ b/programs/verifier/tests/verifier_verify_test.rs @@ -1,19 +1,29 @@ +use crate::common::fixtures::{ + fixture_signers, FIXTURE_DIGEST, FIXTURE_F, FIXTURE_REPORT, FIXTURE_REPORT_DATA, +}; use crate::common::test_setup::{VerifierTestSetup, VerifierTestSetupBuilder}; use access_controller::AccessController; -use anchor_lang::Discriminator; +use anchor_lang::{Discriminator, ToAccountMetas}; +use chainlink_solana_data_streams::VerifierInstructions; use hex::encode as hex_encode; use hex_literal::hex; use solana_program::pubkey::Pubkey; +use solana_program::system_instruction; use solana_program_test::tokio; use solana_sdk::signer::keypair::Keypair; use solana_sdk::signer::Signer; -use test_utils::report::{generate_report_with_signers, get_signers, DummyReport, V3Report}; -use verifier::state::{VerifierAccount, MAX_NUMBER_OF_DON_CONFIGS}; use std::mem::size_of; use anchor_lang::error::ErrorCode::AccountOwnedByWrongProgram; use test_utils::assert::Assert; +use test_utils::client::LegacyDonConfig; +use test_utils::environment_context_operations::EnvironmentContextOperations; +use test_utils::report::{ + generate_report_with_signers_and_digest, get_signers, test_config_digest, DummyReport, + V3Report, +}; use verifier::errors::ErrorCode; use verifier::errors::ErrorCode::{InvalidAccessController, Unauthorized}; +use verifier::state::VerifierAccount; use verifier::util::Compressor; pub mod common; @@ -32,50 +42,137 @@ async fn test_verify_report() { .build() .await; - let test_report_input = hex!("000906f3cbb5a230ad230e8f693aecc4aa5ff7a5c63ecf67ec7201c8a237152c000000000000000000000000000000000000000000000000000000000027018a000000000000000000000000000000000000000000000000000000010000000100000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000280010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001200003ab9412a454b0fb347d0c2c3062186f60640057203d5fb20982d7fb9c927f0000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000221896f269e60000000000000000000000000000000000000000000000000012f260aec4d6000000000000000000000000000000000000000000000000000000000067abc2c00000000000000000000000000000000000000000000000000de08c8d4fa030c80000000000000000000000000000000000000000000000000de065a57df39d200000000000000000000000000000000000000000000000000de0e2fe819758000000000000000000000000000000000000000000000000000000000000000002f173d87393dd8a9dcb97847d1a9a0710e7e4216655477631523a2284e7672790c758cd6413f08d730a3c96b3ede2aca6c9daa554f57b3221754aa579bcea720100000000000000000000000000000000000000000000000000000000000000026284f170f3e580bc532020b1f526b75d7012a632003da5d30f316434689e499509bb8dee47c9c92896e3b2350a74ffcdd564286fc250fe31df3043cfdc2951ef"); - let compressed_report = Compressor::compress(&test_report_input); + let compressed_report = Compressor::compress(&FIXTURE_REPORT); - // signers list (as configured when example report was generated) - let signers: Vec<[u8; 20]> = vec![ - hex!("38C7EA2f6b878509f3e2d0bbE9adF328e1Df2f6C"), - hex!("a669f0bE9F92e3fe5Eb7b28d1852dFf84C7516Cc"), - hex!("8735F9dd83c0b03571b39Fe9FfbB05e02bc08c28"), - hex!("29679cD77AAce065B885b190368f04fDD7E587AD"), - ]; let result = verifier_client - .set_config_with_activation_time( + .set_config( &mut environment_context, &user, - signers.clone(), - 1, // f - 1_600_000_000, + FIXTURE_DIGEST, + fixture_signers(), + FIXTURE_F, ) - .await - .unwrap(); + .await; + Assert::transaction_ok(&result); + + let result = verifier_client + .verify(&mut environment_context, &user, compressed_report, None) + .await; + + Assert::transaction_ok(&result); + + let metadata = result + .expect("Transaction result should be present") + .metadata + .expect("Metadata should be present"); + + // The digest config was used, not the legacy fallback assert!( - result.result.is_ok(), - "set_config_with_activation_time returned an error: {:?}", - result.result.err() + !metadata.log_messages.iter().any(|l| l.contains("legacy config fallback")), + "Verify should not use the legacy fallback when the config PDA exists" ); - // -- End Add Configs + + let data = metadata + .return_data + .expect("Return data should be present") + .data; + + assert_eq!(hex_encode(&data), FIXTURE_REPORT_DATA); +} + +#[tokio::test] +async fn test_verify_with_sdk_instruction() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + access_controller_account_address, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .build() + .await; let result = verifier_client - .verify(&mut environment_context, &user, compressed_report, None) + .set_config( + &mut environment_context, + &user, + FIXTURE_DIGEST, + fixture_signers(), + FIXTURE_F, + ) .await; + Assert::transaction_ok(&result); + // Build the instruction exactly as integrators do with the published SDK + let instruction = VerifierInstructions::verify( + &verifier::ID, + &VerifierInstructions::get_verifier_config_pda(&verifier::ID), + &access_controller_account_address.unwrap(), + &user.pubkey(), + &VerifierInstructions::get_config_pda(&FIXTURE_REPORT, &verifier::ID), + Compressor::compress(&FIXTURE_REPORT), + ); + + let result = EnvironmentContextOperations::send_transaction( + &mut environment_context, + &[instruction], + Some(&user.pubkey()), + &[&user], + ) + .await; Assert::transaction_ok(&result); let data = result - .expect("Transaction result should be present") + .unwrap() .metadata - .expect("Metadata should be present") + .unwrap() .return_data .expect("Return data should be present") .data; + assert_eq!(hex_encode(&data), FIXTURE_REPORT_DATA); +} - let encoded = hex_encode(&data); +#[test] +fn test_verify_interface_matches_sdk() { + // Instruction discriminator + assert_eq!( + chainlink_solana_data_streams::discriminator::VERIFY, + verifier::instruction::Verify::DISCRIMINATOR + ); + + // Account order, signer and writable flags + let verifier_account = Pubkey::new_unique(); + let access_controller = Pubkey::new_unique(); + let user = Pubkey::new_unique(); + let config_account = Pubkey::new_unique(); - assert_eq!(encoded, "0003ab9412a454b0fb347d0c2c3062186f60640057203d5fb20982d7fb9c927f0000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000221896f269e60000000000000000000000000000000000000000000000000012f260aec4d6000000000000000000000000000000000000000000000000000000000067abc2c00000000000000000000000000000000000000000000000000de08c8d4fa030c80000000000000000000000000000000000000000000000000de065a57df39d200000000000000000000000000000000000000000000000000de0e2fe81975800"); + let program_metas = verifier::accounts::VerifyContext { + verifier_account, + access_controller, + user, + config_account, + } + .to_account_metas(None); + + let sdk_metas = VerifierInstructions::verify( + &verifier::ID, + &verifier_account, + &access_controller, + &user, + &config_account, + vec![], + ) + .accounts; + + assert_eq!(program_metas.len(), sdk_metas.len()); + for (program_meta, sdk_meta) in program_metas.iter().zip(sdk_metas.iter()) { + assert_eq!(program_meta.pubkey, sdk_meta.pubkey); + assert_eq!(program_meta.is_signer, sdk_meta.is_signer); + assert_eq!(program_meta.is_writable, sdk_meta.is_writable); + } } #[tokio::test] @@ -92,8 +189,7 @@ async fn test_fail_to_verify_report_if_signer_not_in_config() { .build() .await; - let test_report_input = hex!("000906f3cbb5a230ad230e8f693aecc4aa5ff7a5c63ecf67ec7201c8a237152c000000000000000000000000000000000000000000000000000000000027018a000000000000000000000000000000000000000000000000000000010000000100000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000280010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001200003ab9412a454b0fb347d0c2c3062186f60640057203d5fb20982d7fb9c927f0000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000000067aa71400000000000000000000000000000000000000000000000000000221896f269e60000000000000000000000000000000000000000000000000012f260aec4d6000000000000000000000000000000000000000000000000000000000067abc2c00000000000000000000000000000000000000000000000000de08c8d4fa030c80000000000000000000000000000000000000000000000000de065a57df39d200000000000000000000000000000000000000000000000000de0e2fe819758000000000000000000000000000000000000000000000000000000000000000002f173d87393dd8a9dcb97847d1a9a0710e7e4216655477631523a2284e7672790c758cd6413f08d730a3c96b3ede2aca6c9daa554f57b3221754aa579bcea720100000000000000000000000000000000000000000000000000000000000000026284f170f3e580bc532020b1f526b75d7012a632003da5d30f316434689e499509bb8dee47c9c92896e3b2350a74ffcdd564286fc250fe31df3043cfdc2951ef"); - let compressed_report = Compressor::compress(&test_report_input); + let compressed_report = Compressor::compress(&FIXTURE_REPORT); // signers list (as configured when example report was generated) // but missing signer `29679cD77AAce065B885b190368f04fDD7E587AD` @@ -105,16 +201,9 @@ async fn test_fail_to_verify_report_if_signer_not_in_config() { ]; let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 1, // f - 1_600_000_000, - ) + .set_config(&mut environment_context, &user, FIXTURE_DIGEST, signers, FIXTURE_F) .await; Assert::transaction_ok(&result); - // -- End Add Configs let result = verifier_client .verify(&mut environment_context, &user, compressed_report, None) @@ -151,18 +240,13 @@ async fn test_can_verify_with_non_owner() { .await; Assert::transaction_ok(&result); - let (report, signers) = generate_report_with_signers::(16, 6, None, None); + let digest = test_config_digest(1); + let (report, signers) = generate_report_with_signers_and_digest::(digest, 16, 6, None, None); let compressed_report = Compressor::compress(&report); // Set up the configuration let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 5, // f - 1_600_000_000, - ) + .set_config(&mut environment_context, &user, digest, signers, 5) .await; Assert::transaction_ok(&result); @@ -197,18 +281,13 @@ async fn test_can_verify_without_access() { .build() .await; - let (report, signers) = generate_report_with_signers::(16, 6, None, None); + let digest = test_config_digest(1); + let (report, signers) = generate_report_with_signers_and_digest::(digest, 16, 6, None, None); let compressed_report = Compressor::compress(&report); // Set up the configuration let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 5, // f - 1_600_000_000, - ) + .set_config(&mut environment_context, &user, digest, signers, 5) .await; Assert::transaction_ok(&result); @@ -240,27 +319,28 @@ async fn test_verify_fails_with_invalid_access_controller() { .add_zero_copy_account(access_controller::ID, dummy_access_controller, size_of::(), Some(AccessController::discriminator())) .build() .await; - + // Mock that user will attempt to pass an invalid access controller verifier_client.access_controller_data_account_override(Some(dummy_access_controller)); - + let verifier_account: VerifierAccount = verifier_client .read_verifier_account(&mut environment_context) .await .unwrap(); - + // Verifier account should have a valid access controller assert_ne!(verifier_account.verifier_account_config.access_controller, Pubkey::default()); assert_ne!(verifier_account.verifier_account_config.access_controller, dummy_access_controller); - let (report, signers) = generate_report_with_signers::(16, 6, None, None); + let digest = test_config_digest(1); + let (report, _) = generate_report_with_signers_and_digest::(digest, 16, 6, None, None); let compressed_report = Compressor::compress(&report); let result = verifier_client .verify(&mut environment_context, &user, compressed_report, None) .await; - - + + Assert::transaction_error(&result, InvalidAccessController); } @@ -279,7 +359,8 @@ async fn test_incorrect_config_account_fails_verification() { .build() .await; - let (report, signers) = generate_report_with_signers::(16, 6, None, None); + let digest = test_config_digest(1); + let (report, _) = generate_report_with_signers_and_digest::(digest, 16, 6, None, None); let compressed_report = Compressor::compress(&report); let result = verifier_client @@ -289,9 +370,8 @@ async fn test_incorrect_config_account_fails_verification() { Assert::transaction_error(&result, ErrorCode::InvalidConfigAccount); } - #[tokio::test] -async fn test_fail_to_verify_report_if_not_enough_signers() { +async fn test_config_account_of_another_digest_fails_verification() { let VerifierTestSetup { mut environment_context, user, @@ -304,34 +384,38 @@ async fn test_fail_to_verify_report_if_not_enough_signers() { .build() .await; - // Generate report with only 1 active signer - let (report, signers) = generate_report_with_signers::(16, 1, None, None); - let f = 5; // Requires more than 1 signer - - // Set the config first + let digest_a = test_config_digest(1); + let digest_b = test_config_digest(2); + + let (report_a, signers_a) = generate_report_with_signers_and_digest::(digest_a, 16, 6, None, None); + let (_, signers_b) = generate_report_with_signers_and_digest::(digest_b, 16, 6, None, None); + + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, digest_a, signers_a, 5) + .await, + ); + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, digest_b, signers_b, 5) + .await, + ); + + // Passing an existing config account that does not belong to the report's digest is rejected let result = verifier_client - .set_config_with_activation_time( + .verify( &mut environment_context, &user, - signers.clone(), - f, - 1_600_000_000, + Compressor::compress(&report_a), + Some(verifier_client.config_pda(&digest_b)), ) .await; - Assert::transaction_ok(&result); - - // Try to verify with insufficient signers - let compressed_report = Compressor::compress(&report); - let result = verifier_client - .verify(&mut environment_context, &user, compressed_report, None) - .await; - - Assert::transaction_error(&result, ErrorCode::BadVerification); + Assert::transaction_error(&result, ErrorCode::InvalidConfigAccount); } #[tokio::test] -async fn test_fail_to_verify_report_if_no_signers() { +async fn test_verify_reports_from_multiple_dons() { let VerifierTestSetup { mut environment_context, user, @@ -344,34 +428,63 @@ async fn test_fail_to_verify_report_if_no_signers() { .build() .await; - // Generate report with 0 active signers - let (report, signers) = generate_report_with_signers::(16, 0, None, None); - let f = 5; - - // Set the config first - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - f, - 1_600_000_000, - ) - .await; + // e.g. DON 3: 4 signers, f = 1 + let digest_a = test_config_digest(3); + let signers_a = get_signers(4); + // e.g. DON 4: 16 signers, f = 5 + let digest_b = test_config_digest(4); + let signers_b = get_signers(16); - Assert::transaction_ok(&result); + Assert::transaction_ok( + &verifier_client + .set_config( + &mut environment_context, + &user, + digest_a, + signers_a.iter().map(|s| s.signer_address).collect(), + 1, + ) + .await, + ); + Assert::transaction_ok( + &verifier_client + .set_config( + &mut environment_context, + &user, + digest_b, + signers_b.iter().map(|s| s.signer_address).collect(), + 5, + ) + .await, + ); - // Try to verify with no signers - let compressed_report = Compressor::compress(&report); - let result = verifier_client - .verify(&mut environment_context, &user, compressed_report, None) - .await; + // Reports from both DONs verify, regardless of report timestamps or the order configs were set + let (report_a, _) = generate_report_with_signers_and_digest::(digest_a, 4, 2, Some(1), Some(signers_a.clone())); + let (report_b, _) = generate_report_with_signers_and_digest::(digest_b, 16, 6, None, Some(signers_b.clone())); - Assert::transaction_error(&result, ErrorCode::NoSigners); + Assert::transaction_ok( + &verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&report_a), None) + .await, + ); + Assert::transaction_ok( + &verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&report_b), None) + .await, + ); + + // A report signed by DON A's signers for DON B's digest does not verify + let (cross_report, _) = generate_report_with_signers_and_digest::(digest_b, 4, 4, None, Some(signers_a)); + Assert::transaction_error( + &verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&cross_report), None) + .await, + ErrorCode::BadVerification, + ); } #[tokio::test] -async fn test_fail_to_verify_report_if_dup_signers() { +async fn test_deactivated_config_does_not_use_legacy_fallback() { let VerifierTestSetup { mut environment_context, user, @@ -384,42 +497,42 @@ async fn test_fail_to_verify_report_if_dup_signers() { .build() .await; - // Generate signers for the config - let signers = get_signers(16); - let signer_pub_keys = signers.iter().map(|s| s.signer_address).collect(); - - // Add a duplicate signer to generate a malformed report - let mut signers_with_duplicate = signers[0..6].to_vec(); - signers_with_duplicate.push(signers[0].clone()); + let digest = test_config_digest(1); + let (report, signers) = generate_report_with_signers_and_digest::(digest, 16, 6, None, None); - // Generate report with duplicate signers - let (report, _) = generate_report_with_signers::(16, 7, None, Some(signers_with_duplicate)); - let f = 5; - - // Set the config first - let result = verifier_client - .set_config_with_activation_time( + // A matching legacy config exists and the fallback is enabled + verifier_client + .set_legacy_don_configs( &mut environment_context, - &user, - signer_pub_keys, - f, - 1_600_000_000, + &[LegacyDonConfig { + signers: signers.clone(), + f: 5, + activation_time: 1_600_000_000, + is_active: true, + }], ) .await; - Assert::transaction_ok(&result); + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, digest, signers, 5) + .await, + ); + Assert::transaction_ok( + &verifier_client + .deactivate_config(&mut environment_context, &user, digest) + .await, + ); - // Try to verify with duplicate signers - let compressed_report = Compressor::compress(&report); let result = verifier_client - .verify(&mut environment_context, &user, compressed_report, None) + .verify(&mut environment_context, &user, Compressor::compress(&report), None) .await; - Assert::transaction_error(&result, ErrorCode::BadVerification); + Assert::transaction_error(&result, ErrorCode::ConfigDeactivated); } #[tokio::test] -async fn test_verify_with_too_many_signers() { +async fn test_verify_unregistered_digest_fails_when_legacy_fallback_disabled() { let VerifierTestSetup { mut environment_context, user, @@ -432,34 +545,21 @@ async fn test_verify_with_too_many_signers() { .build() .await; - // Generate report with 8 signers - let (report, signer_pub_keys) = generate_report_with_signers::(16, 7, None, None); - let f = 5; - - // Set the config - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signer_pub_keys, - f, - 1_600_000_000, - ) - .await; - - Assert::transaction_ok(&result); + Assert::transaction_ok( + &verifier_client + .set_legacy_fallback(&mut environment_context, &user, false) + .await, + ); - // Try to verify with too many signers - let compressed_report = Compressor::compress(&report); let result = verifier_client - .verify(&mut environment_context, &user, compressed_report, None) + .verify(&mut environment_context, &user, Compressor::compress(&FIXTURE_REPORT), None) .await; - Assert::transaction_ok(&result); + Assert::transaction_error(&result, ErrorCode::DigestNotSet); } #[tokio::test] -async fn test_report_verify_with_latest_config_after_removal() { +async fn test_verify_with_prefunded_config_account() { let VerifierTestSetup { mut environment_context, user, @@ -472,55 +572,53 @@ async fn test_report_verify_with_latest_config_after_removal() { .build() .await; - // Generate report and signers for config A - let (report_a, signers_a) = generate_report_with_signers::(16, 6, None, None); - let f_a = 5; + Assert::transaction_ok( + &verifier_client + .set_legacy_fallback(&mut environment_context, &user, false) + .await, + ); - // Set config A - let result = verifier_client - .set_config_with_activation_time( + // Anyone can send lamports to the config PDA address before the config is set + let config_account = verifier_client.config_pda(&FIXTURE_DIGEST); + let transfer = system_instruction::transfer(&user.pubkey(), &config_account, 1_000_000); + Assert::transaction_ok( + &EnvironmentContextOperations::send_transaction( &mut environment_context, - &user, - signers_a.clone(), - f_a, - 1_600_000_000, + &[transfer], + Some(&user.pubkey()), + &[&user], ) - .await; - Assert::transaction_ok(&result); - - // Generate different signers for config B - let (_, signers_b) = generate_report_with_signers::(16, 6, None, None); - let f_b = 5; + .await, + ); - // Set config B with later activation time + // A system owned account is not treated as a config + let compressed_report = Compressor::compress(&FIXTURE_REPORT); let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_b, - f_b, - 1_700_000_000, - ) + .verify(&mut environment_context, &user, compressed_report.clone(), None) .await; - Assert::transaction_ok(&result); + Assert::transaction_error(&result, ErrorCode::DigestNotSet); - // Remove latest config (B) - let result = verifier_client - .remove_latest_config(&mut environment_context, &user) - .await; - Assert::transaction_ok(&result); + // The config can still be set on the prefunded address + Assert::transaction_ok( + &verifier_client + .set_config( + &mut environment_context, + &user, + FIXTURE_DIGEST, + fixture_signers(), + FIXTURE_F, + ) + .await, + ); - // Verify report A still works with config A - let compressed_report = Compressor::compress(&report_a); let result = verifier_client .verify(&mut environment_context, &user, compressed_report, None) .await; - Assert::transaction_ok(&result); } #[tokio::test] -async fn test_can_verify_older_reports_with_older_configs() { +async fn test_fail_to_verify_report_if_not_enough_signers() { let VerifierTestSetup { mut environment_context, user, @@ -533,63 +631,29 @@ async fn test_can_verify_older_reports_with_older_configs() { .build() .await; - // Generate report and signers for config A with timestamp between config A and B's activation times - let (report_a, signers_a) = generate_report_with_signers::(16, 6, Some(1_500_000_000), None); - let f_a = 5; - - // Set config A with activation time 1_400_000_000 - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_a.clone(), - f_a, - 1_400_000_000, - ) - .await; - Assert::transaction_ok(&result); - - // Generate different signers for config B - let (_, signers_b) = generate_report_with_signers::(16, 6, None, None); - let f_b = 5; - - // Set config B with later activation time 1_600_000_000 - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_b, - f_b, - 1_600_000_000, - ) - .await; - Assert::transaction_ok(&result); - - // Compress the report generated earlier - let compressed_report = Compressor::compress(&report_a); + // Generate report with only 1 active signer + let digest = test_config_digest(1); + let (report, signers) = generate_report_with_signers_and_digest::(digest, 16, 1, None, None); + let f = 5; // Requires more than 1 signer - // Verify report - should use config A since report timestamp is before config B's activation + // Set the config first let result = verifier_client - .verify(&mut environment_context, &user, compressed_report.clone(), None) + .set_config(&mut environment_context, &user, digest, signers, f) .await; - Assert::transaction_ok(&result); - // Disable config A to ensure it was the config used - let result = verifier_client - .set_config_active(&mut environment_context, &user, 0, false) - .await; Assert::transaction_ok(&result); - // Verify should now fail since config is disabled + // Try to verify with insufficient signers + let compressed_report = Compressor::compress(&report); let result = verifier_client .verify(&mut environment_context, &user, compressed_report, None) .await; - Assert::transaction_error(&result, ErrorCode::ConfigDeactivated); - + + Assert::transaction_error(&result, ErrorCode::BadVerification); } #[tokio::test] -async fn test_can_verify_non_standard_reports() { +async fn test_fail_to_verify_report_if_no_signers() { let VerifierTestSetup { mut environment_context, user, @@ -602,36 +666,29 @@ async fn test_can_verify_non_standard_reports() { .build() .await; - // Generate report with signers - let (report, signers) = generate_report_with_signers::(16, 6, None, None); - let compressed_report = Compressor::compress(&report); + // Generate report with 0 active signers + let digest = test_config_digest(1); + let (report, signers) = generate_report_with_signers_and_digest::(digest, 16, 0, None, None); + let f = 5; - // Set up the configuration + // Set the config first let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers, - 5, // f - 1_600_000_000, - ) + .set_config(&mut environment_context, &user, digest, signers, f) .await; + Assert::transaction_ok(&result); - // Verify the report + // Try to verify with no signers + let compressed_report = Compressor::compress(&report); let result = verifier_client - .verify( - &mut environment_context, - &user, - compressed_report, - None, - ) + .verify(&mut environment_context, &user, compressed_report, None) .await; - Assert::transaction_ok(&result); + Assert::transaction_error(&result, ErrorCode::NoSigners); } + #[tokio::test] -async fn test_rolling_out_configuration() { +async fn test_fail_to_verify_report_if_mismatched_signatures() { let VerifierTestSetup { mut environment_context, user, @@ -644,54 +701,28 @@ async fn test_rolling_out_configuration() { .build() .await; - // Generate initial signers for config A - let signers_a = get_signers(16); - let f = 5; - - // Set config A - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_a.iter().map(|s| s.signer_address).collect(), - f, - 1_600_000_000, - ) - .await; - Assert::transaction_ok(&result); - - // Create config B by adding one more signer - let mut signers_b = signers_a.clone(); - let additional_signer = get_signers(1); - signers_b.extend(additional_signer); + let digest = test_config_digest(1); + let (mut report, signers) = generate_report_with_signers_and_digest::(digest, 16, 6, None, None); - // Set config B with later activation time - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers_b.iter().map(|s| s.signer_address).collect(), - f, - 1_700_000_000, - ) - .await; - Assert::transaction_ok(&result); + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, digest, signers, 5) + .await, + ); - // Generate report using the last 6 signers from config B which includes the new signer - let report_signers = signers_b[signers_b.len()-6..].to_vec(); - let (report, _) = generate_report_with_signers::(16, 6, None, Some(report_signers)); + // Shorten the ss array by one, the offset of ss is the 6th word of the report + let ss_offset = u64::from_be_bytes(report[5 * 32 + 24..6 * 32].try_into().unwrap()) as usize; + report[ss_offset + 31] -= 1; - // Verify the report - let compressed_report = Compressor::compress(&report); let result = verifier_client - .verify(&mut environment_context, &user, compressed_report, None) + .verify(&mut environment_context, &user, Compressor::compress(&report), None) .await; - Assert::transaction_ok(&result); + Assert::transaction_error(&result, ErrorCode::MismatchedSignatures); } #[tokio::test] -async fn test_report_does_not_verify_when_config_is_disabled() { +async fn test_fail_to_verify_report_if_dup_signers() { let VerifierTestSetup { mut environment_context, user, @@ -704,47 +735,37 @@ async fn test_report_does_not_verify_when_config_is_disabled() { .build() .await; - // Generate report with signers - let (report, signers) = generate_report_with_signers::(16, 7, None, None); + // Generate signers for the config + let signers = get_signers(16); + let signer_pub_keys = signers.iter().map(|s| s.signer_address).collect(); + + // Add a duplicate signer to generate a malformed report + let mut signers_with_duplicate = signers[0..6].to_vec(); + signers_with_duplicate.push(signers[0].clone()); + + // Generate report with duplicate signers + let digest = test_config_digest(1); + let (report, _) = generate_report_with_signers_and_digest::(digest, 16, 7, None, Some(signers_with_duplicate)); let f = 5; - + // Set the config first let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - f, - 1_600_000_000, - ) + .set_config(&mut environment_context, &user, digest, signer_pub_keys, f) .await; Assert::transaction_ok(&result); - // Verify report works initially + // Try to verify with duplicate signers let compressed_report = Compressor::compress(&report); - let result = verifier_client - .verify(&mut environment_context, &user, compressed_report.clone(), None) - .await; - - Assert::transaction_ok(&result); - - // Disable the config by setting it inactive - let result = verifier_client - .set_config_active(&mut environment_context, &user, 0, false) - .await; - Assert::transaction_ok(&result); - - // Try to verify after disabling let result = verifier_client .verify(&mut environment_context, &user, compressed_report, None) .await; - Assert::transaction_error(&result, ErrorCode::ConfigDeactivated); + Assert::transaction_error(&result, ErrorCode::BadVerification); } #[tokio::test] -async fn test_verify_fails_when_report_is_older_than_config() { +async fn test_verify_with_too_many_signers() { let VerifierTestSetup { mut environment_context, user, @@ -754,36 +775,35 @@ async fn test_verify_fails_when_report_is_older_than_config() { .program_name("verifier") .program_id(verifier::ID) .access_controller(access_controller::ID) + // 7 signatures is close to the default 200k CU limit, and the on-chain config PDA + // derivation cost varies with the digest + .with_compute_max_units(400_000) .build() .await; - // Generate report with timestamp before config activation time - let (report, signers) = generate_report_with_signers::(16, 6, Some(1_500_000_000), None); + // Generate report with 7 signatures, more than the f + 1 required + let digest = test_config_digest(1); + let (report, signer_pub_keys) = generate_report_with_signers_and_digest::(digest, 16, 7, None, None); let f = 5; - // Set config with later activation time + // Set the config let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers, - f, - 1_600_000_000, - ) + .set_config(&mut environment_context, &user, digest, signer_pub_keys, f) .await; + Assert::transaction_ok(&result); - // Try to verify report from before config was active + // More than f + 1 signatures still verifies let compressed_report = Compressor::compress(&report); let result = verifier_client .verify(&mut environment_context, &user, compressed_report, None) .await; - Assert::transaction_error(&result, ErrorCode::BadVerification); + Assert::transaction_ok(&result); } #[tokio::test] -async fn test_verify_with_max_configs() { +async fn test_can_verify_non_standard_reports() { let VerifierTestSetup { mut environment_context, user, @@ -796,59 +816,26 @@ async fn test_verify_with_max_configs() { .build() .await; - // Add first config - let (first_report, first_signers) = generate_report_with_signers::(16, 6, Some(1_600_000_000), None); + // Generate report with signers + let digest = test_config_digest(1); + let (report, signers) = generate_report_with_signers_and_digest::(digest, 16, 6, None, None); + let compressed_report = Compressor::compress(&report); + + // Set up the configuration let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - first_signers, - 5, - 1_600_000_000, - ) + .set_config(&mut environment_context, &user, digest, signers, 5) .await; Assert::transaction_ok(&result); - // Add middle configs - for i in 1..MAX_NUMBER_OF_DON_CONFIGS - 1 { - let (_, signers) = generate_report_with_signers::(16, 6, None, None); - let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers, - 5, - 1_600_000_000 + i as u32, - ) - .await; - Assert::transaction_ok(&result); - } - - // Add last config - let (last_report, last_signers) = generate_report_with_signers::(16, 6, Some(1_600_000_000 + MAX_NUMBER_OF_DON_CONFIGS as u32), None); + // Verify the report let result = verifier_client - .set_config_with_activation_time( + .verify( &mut environment_context, &user, - last_signers, - 5, - 1_600_000_000 + MAX_NUMBER_OF_DON_CONFIGS as u32, + compressed_report, + None, ) .await; - Assert::transaction_ok(&result); - - // Verify report with first config - let compressed_first_report = Compressor::compress(&first_report); - let result = verifier_client - .verify(&mut environment_context, &user, compressed_first_report, None) - .await; - Assert::transaction_ok(&result); - - // Verify report with last config - let compressed_last_report = Compressor::compress(&last_report); - let result = verifier_client - .verify(&mut environment_context, &user, compressed_last_report, None) - .await; Assert::transaction_ok(&result); } @@ -869,18 +856,13 @@ async fn test_verify_with_max_signers() { .await; // Generate report with 31 signers - let (report, signers) = generate_report_with_signers::(31, 11, None, None); - let f = 10; - + let digest = test_config_digest(1); + let (report, signers) = generate_report_with_signers_and_digest::(digest, 31, 11, None, None); + let f = 10; + // Set the config first let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers, - f, - 1_600_000_000, - ) + .set_config(&mut environment_context, &user, digest, signers, f) .await; Assert::transaction_ok(&result); @@ -894,6 +876,67 @@ async fn test_verify_with_max_signers() { Assert::transaction_ok(&result); } +#[tokio::test] +async fn test_verify_compute_units_digest_config_vs_legacy() { + let VerifierTestSetup { + mut environment_context, + user, + verifier_client, + .. + } = VerifierTestSetupBuilder::new() + .program_name("verifier") + .program_id(verifier::ID) + .access_controller(access_controller::ID) + .with_compute_max_units(2_000_000) + .build() + .await; + + let signers = get_signers(16); + let signer_addresses: Vec<[u8; 20]> = signers.iter().map(|s| s.signer_address).collect(); + + // Legacy path: report digest has no config PDA + verifier_client + .set_legacy_don_configs( + &mut environment_context, + &[LegacyDonConfig { + signers: signer_addresses.clone(), + f: 5, + activation_time: 1_600_000_000, + is_active: true, + }], + ) + .await; + let (legacy_report, _) = generate_report_with_signers_and_digest::(test_config_digest(1), 16, 6, None, Some(signers.clone())); + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&legacy_report), None) + .await; + Assert::transaction_ok(&result); + let legacy_units = result.unwrap().metadata.unwrap().compute_units_consumed; + + // Digest path: same signers and signature count + let digest = test_config_digest(2); + Assert::transaction_ok( + &verifier_client + .set_config(&mut environment_context, &user, digest, signer_addresses, 5) + .await, + ); + let (digest_report, _) = generate_report_with_signers_and_digest::(digest, 16, 6, None, Some(signers)); + let result = verifier_client + .verify(&mut environment_context, &user, Compressor::compress(&digest_report), None) + .await; + Assert::transaction_ok(&result); + let digest_units = result.unwrap().metadata.unwrap().compute_units_consumed; + + println!("verify compute units: legacy = {legacy_units}, digest config = {digest_units}"); + + // Integrators size their compute budget for today's verify, so the digest path must not cost + // noticeably more + assert!( + digest_units <= legacy_units + 5_000, + "digest config verify ({digest_units} CU) costs more than legacy verify ({legacy_units} CU)" + ); +} + #[tokio::test] async fn test_verify_with_disabled_access_controller() { let unauthorized_user = Keypair::new(); @@ -924,18 +967,13 @@ async fn test_verify_with_disabled_access_controller() { assert_ne!(access_controller_account_address.unwrap(), Pubkey::default()); assert_ne!(verifier_account.verifier_account_config.access_controller, Pubkey::default()); - let (report, signers) = generate_report_with_signers::(16, 6, None, None); + let digest = test_config_digest(1); + let (report, signers) = generate_report_with_signers_and_digest::(digest, 16, 6, None, None); let compressed_report = Compressor::compress(&report); // Set up the configuration let result = verifier_client - .set_config_with_activation_time( - &mut environment_context, - &user, - signers.clone(), - 5, // f - 1_600_000_000, - ) + .set_config(&mut environment_context, &user, digest, signers, 5) .await; Assert::transaction_ok(&result); @@ -959,7 +997,7 @@ async fn test_verify_with_disabled_access_controller() { ) .await; Assert::transaction_ok(&result); - + // Non-access user cannot verify when access controller is enabled let result = verifier_client .verify( @@ -988,7 +1026,7 @@ async fn test_verify_with_disabled_access_controller() { Pubkey::default(), "Access controller should be disabled in account (should equal Pubkey::default())" ); - + // When access controller is set we can verify using an existing access controller account even when disabled assert_eq!( verifier_client.access_controller_data_account.unwrap(), @@ -1006,7 +1044,7 @@ async fn test_verify_with_disabled_access_controller() { ) .await; Assert::transaction_ok(&result); - + // Non-access user can verify when access controller is disabled let result = verifier_client .verify( @@ -1017,7 +1055,7 @@ async fn test_verify_with_disabled_access_controller() { ) .await; Assert::transaction_ok(&result); - + // Transactions with `Pubkey::default()` as AC account will fail during Anchor checks verifier_client.access_controller_data_account_override(Some(Pubkey::default())); let result = verifier_client @@ -1086,7 +1124,7 @@ async fn test_verify_with_disabled_access_controller() { ) .await; Assert::transaction_error(&result, AccountOwnedByWrongProgram); - + verifier_client.access_controller_data_account_override(Some(verifier::ID)); let result = verifier_client .verify( @@ -1108,5 +1146,4 @@ async fn test_verify_with_disabled_access_controller() { ) .await; Assert::transaction_error(&result, AccountOwnedByWrongProgram); - -} \ No newline at end of file +} diff --git a/target/idl/verifier.json b/target/idl/verifier.json index 11b4282..1cd58d4 100644 --- a/target/idl/verifier.json +++ b/target/idl/verifier.json @@ -1,5 +1,5 @@ { - "version": "0.4.0", + "version": "0.5.0", "name": "verifier", "instructions": [ { @@ -34,20 +34,42 @@ ] }, { - "name": "setConfigWithActivationTime", + "name": "setConfig", + "docs": [ + "Sets the DON configuration for a config digest. Creates the config PDA derived from `[config_digest]`" + ], "accounts": [ { "name": "verifierAccount", + "isMut": false, + "isSigner": false + }, + { + "name": "configAccount", "isMut": true, "isSigner": false }, { "name": "owner", - "isMut": false, + "isMut": true, "isSigner": true + }, + { + "name": "systemProgram", + "isMut": false, + "isSigner": false } ], "args": [ + { + "name": "configDigest", + "type": { + "array": [ + "u8", + 32 + ] + } + }, { "name": "signers", "type": { @@ -62,18 +84,22 @@ { "name": "f", "type": "u8" - }, - { - "name": "activationTime", - "type": "u32" } ] }, { - "name": "setConfig", + "name": "updateConfig", + "docs": [ + "Replaces the signers and fault tolerance of an existing config digest. The active state is unchanged" + ], "accounts": [ { "name": "verifierAccount", + "isMut": false, + "isSigner": false + }, + { + "name": "configAccount", "isMut": true, "isSigner": false }, @@ -84,6 +110,15 @@ } ], "args": [ + { + "name": "configDigest", + "type": { + "array": [ + "u8", + 32 + ] + } + }, { "name": "signers", "type": { @@ -102,10 +137,15 @@ ] }, { - "name": "setConfigActive", + "name": "activateConfig", "accounts": [ { "name": "verifierAccount", + "isMut": false, + "isSigner": false + }, + { + "name": "configAccount", "isMut": true, "isSigner": false }, @@ -117,17 +157,86 @@ ], "args": [ { - "name": "donConfigIndex", - "type": "u64" + "name": "configDigest", + "type": { + "array": [ + "u8", + 32 + ] + } + } + ] + }, + { + "name": "deactivateConfig", + "accounts": [ + { + "name": "verifierAccount", + "isMut": false, + "isSigner": false }, { - "name": "isActive", - "type": "u8" + "name": "configAccount", + "isMut": true, + "isSigner": false + }, + { + "name": "owner", + "isMut": false, + "isSigner": true + } + ], + "args": [ + { + "name": "configDigest", + "type": { + "array": [ + "u8", + 32 + ] + } } ] }, { - "name": "removeLatestConfig", + "name": "closeConfig", + "docs": [ + "Closes the config PDA for a config digest and refunds its rent to the owner" + ], + "accounts": [ + { + "name": "verifierAccount", + "isMut": false, + "isSigner": false + }, + { + "name": "configAccount", + "isMut": true, + "isSigner": false + }, + { + "name": "owner", + "isMut": true, + "isSigner": true + } + ], + "args": [ + { + "name": "configDigest", + "type": { + "array": [ + "u8", + 32 + ] + } + } + ] + }, + { + "name": "setLegacyFallback", + "docs": [ + "Enables or disables falling back to the legacy `don_configs` when no config PDA exists for a report's digest" + ], "accounts": [ { "name": "verifierAccount", @@ -140,7 +249,12 @@ "isSigner": true } ], - "args": [] + "args": [ + { + "name": "enabled", + "type": "bool" + } + ] }, { "name": "setAccessController", @@ -320,6 +434,64 @@ } ], "accounts": [ + { + "name": "DigestConfig", + "docs": [ + "DON configuration for a single config digest.", + "Stored in a PDA derived from `[config_digest]`, which is the same account the client passes as", + "`config_account` when verifying a report (seed = first 32 bytes of the uncompressed report)." + ], + "type": { + "kind": "struct", + "fields": [ + { + "name": "version", + "type": "u8" + }, + { + "name": "configDigest", + "type": { + "array": [ + "u8", + 32 + ] + } + }, + { + "name": "f", + "type": "u8" + }, + { + "name": "isActive", + "type": "bool" + }, + { + "name": "bump", + "type": "u8" + }, + { + "name": "signers", + "type": { + "vec": { + "array": [ + "u8", + 20 + ] + } + } + }, + { + "name": "reserved", + "type": { + "array": [ + "u8", + 32 + ] + } + } + ] + } + }, { "name": "VerifierAccount", "type": { @@ -329,12 +501,16 @@ "name": "version", "type": "u8" }, + { + "name": "legacyFallbackDisabled", + "type": "u8" + }, { "name": "padding", "type": { "array": [ "u8", - 7 + 6 ] } }, @@ -492,23 +668,43 @@ "name": "ConfigActivated", "fields": [ { - "name": "donConfigId", - "type": "string", + "name": "configDigest", + "type": { + "array": [ + "u8", + 32 + ] + }, "index": false - }, + } + ] + }, + { + "name": "ConfigDeactivated", + "fields": [ { - "name": "isActive", - "type": "bool", + "name": "configDigest", + "type": { + "array": [ + "u8", + 32 + ] + }, "index": false } ] }, { - "name": "ConfigRemoved", + "name": "ConfigClosed", "fields": [ { - "name": "donConfigId", - "type": "string", + "name": "configDigest", + "type": { + "array": [ + "u8", + 32 + ] + }, "index": false } ] @@ -537,8 +733,13 @@ "name": "ConfigSet", "fields": [ { - "name": "donConfigId", - "type": "string", + "name": "configDigest", + "type": { + "array": [ + "u8", + 32 + ] + }, "index": false }, { @@ -557,10 +758,47 @@ "name": "f", "type": "u8", "index": false + } + ] + }, + { + "name": "ConfigUpdated", + "fields": [ + { + "name": "configDigest", + "type": { + "array": [ + "u8", + 32 + ] + }, + "index": false }, { - "name": "donConfigIndex", - "type": "u16", + "name": "signers", + "type": { + "vec": { + "array": [ + "u8", + 20 + ] + } + }, + "index": false + }, + { + "name": "f", + "type": "u8", + "index": false + } + ] + }, + { + "name": "LegacyFallbackSet", + "fields": [ + { + "name": "enabled", + "type": "bool", "index": false } ] @@ -666,6 +904,21 @@ "code": 6017, "name": "InvalidInputs", "msg": "Invalid inputs" + }, + { + "code": 6018, + "name": "DigestEmpty", + "msg": "Config digest is empty" + }, + { + "code": 6019, + "name": "DigestNotSet", + "msg": "Config digest is not set" + }, + { + "code": 6020, + "name": "ConfigDigestAlreadySet", + "msg": "Config digest is already set" } ] } \ No newline at end of file diff --git a/test_utils/Cargo.toml b/test_utils/Cargo.toml index 03640fb..2c8dfcc 100644 --- a/test_utils/Cargo.toml +++ b/test_utils/Cargo.toml @@ -18,6 +18,7 @@ access-controller = { path = "../programs/access-controller" } tiny-keccak = "2.0.2" secp256k1 = { version = "0.30.0", features = ["recovery", "std", "rand"] } arrayref = "0.3.9" +bytemuck = "1.19.0" solana-test-framework = { git = "https://github.com/halbornteam/solana-test-framework", branch = "solana1.18" } [dev-dependencies] diff --git a/test_utils/src/client/verifier_client.rs b/test_utils/src/client/verifier_client.rs index a5da18b..e680d14 100644 --- a/test_utils/src/client/verifier_client.rs +++ b/test_utils/src/client/verifier_client.rs @@ -6,27 +6,41 @@ use solana_program::system_program; use solana_program_test::{ BanksClientError, BanksTransactionResultWithMetadata, ProgramTestContext, }; +use solana_sdk::account::AccountSharedData; use solana_sdk::signature::Keypair; use solana_sdk::signer::Signer; use verifier::accounts::InitializeAccountDataContext; use verifier::accounts::{ - AcceptOwnershipContext, InitializeContext, ReallocContext, SetAccessControllerContext, - TransferOwnershipContext, UpdateConfigContext, VerifyContext, + AcceptOwnershipContext, CloseConfigContext, InitializeContext, ReallocContext, + SetAccessControllerContext, SetConfigContext, TransferOwnershipContext, UpdateConfigContext, + UpdateDigestConfigContext, VerifyContext, }; use verifier::instruction::AcceptOwnership as AcceptOwnershipParams; +use verifier::instruction::ActivateConfig as ActivateConfigParams; +use verifier::instruction::CloseConfig as CloseConfigParams; +use verifier::instruction::DeactivateConfig as DeactivateConfigParams; use verifier::instruction::Initialize as InitializeParams; use verifier::instruction::InitializeAccountData; use verifier::instruction::ReallocAccount as ReallocParams; -use verifier::instruction::RemoveLatestConfig as RemoveLatestConfigParams; use verifier::instruction::SetAccessController as SetAccessControllerParams; use verifier::instruction::SetConfig as SetConfigParams; -use verifier::instruction::SetConfigActive as SetConfigActiveParams; -use verifier::instruction::SetConfigWithActivationTime as SetConfigWithActivationTimeParams; +use verifier::instruction::SetLegacyFallback as SetLegacyFallbackParams; use verifier::instruction::TransferOwnership as TransferOwnershipParams; +use verifier::instruction::UpdateConfig as UpdateConfigParams; use verifier::instruction::Verify as VerifyParams; -use verifier::state::VerifierAccount; +use verifier::state::{DigestConfig, DonConfig, SigningKey, SigningKeys, VerifierAccount}; use verifier::util::Compressor; +/// A legacy (timestamp based) DON config written directly into the verifier account by +/// `VerifierClient::set_legacy_don_configs`. The legacy setters no longer exist, so this mimics +/// state that was set on-chain before the upgrade. +pub struct LegacyDonConfig { + pub signers: Vec<[u8; 20]>, + pub f: u8, + pub activation_time: u32, + pub is_active: bool, +} + // Verifier struct using ContractOperations // This is a client wrapper to abstract interacting with the Verifier program pub struct VerifierClient { @@ -243,126 +257,121 @@ impl VerifierClient { .await } - pub async fn set_config_with_activation_time( + pub async fn set_config( &self, context: &mut ProgramTestContext, user: &Keypair, + config_digest: [u8; 32], signers: Vec<[u8; 20]>, f: u8, - activation_time: u32, ) -> Result { - let data = SetConfigWithActivationTimeParams { + let data = SetConfigParams { + config_digest, signers, f, - activation_time, }; - let owner_context = UpdateConfigContext { + let set_config_context = SetConfigContext { verifier_account: self.data_account, + config_account: self.config_pda(&config_digest), owner: user.pubkey(), + system_program: system_program::ID, }; - let instruction = Instruction { - program_id: self.program_id, - accounts: owner_context.to_account_metas(None), - data: data.data(), + self.send(context, user, set_config_context.to_account_metas(None), data.data()) + .await + } + + pub async fn update_config( + &self, + context: &mut ProgramTestContext, + user: &Keypair, + config_digest: [u8; 32], + signers: Vec<[u8; 20]>, + f: u8, + ) -> Result { + let data = UpdateConfigParams { + config_digest, + signers, + f, }; - EnvironmentContextOperations::send_transaction( + self.send( context, - &[instruction], - Some(&user.pubkey()), - &[user], + user, + self.update_digest_config_context(user, &config_digest), + data.data(), ) .await } - pub async fn set_config( + pub async fn activate_config( &self, context: &mut ProgramTestContext, user: &Keypair, - signers: Vec<[u8; 20]>, - f: u8, + config_digest: [u8; 32], ) -> Result { - let data = SetConfigParams { signers, f }; + let data = ActivateConfigParams { config_digest }; - let owner_context = UpdateConfigContext { - verifier_account: self.data_account, - owner: user.pubkey(), - }; + self.send( + context, + user, + self.update_digest_config_context(user, &config_digest), + data.data(), + ) + .await + } - let instruction = Instruction { - program_id: self.program_id, - accounts: owner_context.to_account_metas(None), - data: data.data(), - }; + pub async fn deactivate_config( + &self, + context: &mut ProgramTestContext, + user: &Keypair, + config_digest: [u8; 32], + ) -> Result { + let data = DeactivateConfigParams { config_digest }; - EnvironmentContextOperations::send_transaction( + self.send( context, - &[instruction], - Some(&user.pubkey()), - &[user], + user, + self.update_digest_config_context(user, &config_digest), + data.data(), ) .await } - pub async fn set_config_active( + pub async fn close_config( &self, context: &mut ProgramTestContext, user: &Keypair, - don_config_index: u64, - is_active: bool, + config_digest: [u8; 32], ) -> Result { - let data = SetConfigActiveParams { - don_config_index, - is_active: u8::from(is_active), - }; + let data = CloseConfigParams { config_digest }; - let owner_context = UpdateConfigContext { + let close_config_context = CloseConfigContext { verifier_account: self.data_account, + config_account: self.config_pda(&config_digest), owner: user.pubkey(), }; - let instruction = Instruction { - program_id: self.program_id, - accounts: owner_context.to_account_metas(None), - data: data.data(), - }; - - EnvironmentContextOperations::send_transaction( - context, - &[instruction], - Some(&user.pubkey()), - &[user], - ) - .await + self.send(context, user, close_config_context.to_account_metas(None), data.data()) + .await } - pub async fn remove_latest_config( + pub async fn set_legacy_fallback( &self, context: &mut ProgramTestContext, user: &Keypair, + enabled: bool, ) -> Result { - let data = RemoveLatestConfigParams {}; + let data = SetLegacyFallbackParams { enabled }; let owner_context = UpdateConfigContext { verifier_account: self.data_account, owner: user.pubkey(), }; - let instruction = Instruction { - program_id: self.program_id, - accounts: owner_context.to_account_metas(None), - data: data.data(), - }; - - EnvironmentContextOperations::send_transaction( - context, - &[instruction], - Some(&user.pubkey()), - &[user], - ) - .await + self.send(context, user, owner_context.to_account_metas(None), data.data()) + .await } pub async fn transfer_ownership( @@ -428,7 +437,7 @@ impl VerifierClient { .await .unwrap() .unwrap(); - + // Verify account size if account.data.len() < 8 + std::mem::size_of::() { return Err(ProgramError::AccountDataTooSmall); @@ -441,6 +450,60 @@ impl VerifierClient { Ok(verifier_account) } + /// Reads the config PDA for a config digest. Returns `None` if it does not exist + pub async fn read_digest_config( + &self, + context: &mut ProgramTestContext, + config_digest: [u8; 32], + ) -> Option { + let account = + EnvironmentContextOperations::get_account(context, self.config_pda(&config_digest)) + .await + .unwrap()?; + + if account.owner != self.program_id { + return None; + } + + DigestConfig::try_deserialize(&mut &account.data[..]).ok() + } + + /// Writes legacy DON configs directly into the verifier account data, mimicking state that + /// was set on-chain before the upgrade + pub async fn set_legacy_don_configs( + &self, + context: &mut ProgramTestContext, + configs: &[LegacyDonConfig], + ) { + let mut account = EnvironmentContextOperations::get_account(context, self.data_account) + .await + .unwrap() + .unwrap(); + + let size = std::mem::size_of::(); + let mut verifier_account: VerifierAccount = + bytemuck::pod_read_unaligned(&account.data[8..8 + size]); + + for (i, config) in configs.iter().enumerate() { + let mut signers = SigningKeys::default(); + for signer in config.signers.iter() { + signers.push(SigningKey { key: *signer }); + } + + verifier_account.don_configs.push(DonConfig { + activation_time: config.activation_time, + don_config_id: [(i as u8).wrapping_add(1); 24], + f: config.f, + is_active: u8::from(config.is_active), + _padding: 0, + signers, + }); + } + + account.data[8..8 + size].copy_from_slice(bytemuck::bytes_of(&verifier_account)); + context.set_account(&self.data_account, &AccountSharedData::from(account)); + } + pub fn access_controller_data_account_override( &mut self, access_controller_data_account: Option, @@ -466,4 +529,44 @@ impl VerifierClient { let (program_data_address, _) = Pubkey::find_program_address(&[seed], &self.program_id); program_data_address } + + /// The config PDA for a config digest + pub fn config_pda(&self, config_digest: &[u8; 32]) -> Pubkey { + Pubkey::find_program_address(&[config_digest.as_ref()], &self.program_id).0 + } + + fn update_digest_config_context( + &self, + user: &Keypair, + config_digest: &[u8; 32], + ) -> Vec { + UpdateDigestConfigContext { + verifier_account: self.data_account, + config_account: self.config_pda(config_digest), + owner: user.pubkey(), + } + .to_account_metas(None) + } + + async fn send( + &self, + context: &mut ProgramTestContext, + user: &Keypair, + accounts: Vec, + data: Vec, + ) -> Result { + let instruction = Instruction { + program_id: self.program_id, + accounts, + data, + }; + + EnvironmentContextOperations::send_transaction( + context, + &[instruction], + Some(&user.pubkey()), + &[user], + ) + .await + } } diff --git a/test_utils/src/report.rs b/test_utils/src/report.rs index bd8d4d5..b8039e5 100644 --- a/test_utils/src/report.rs +++ b/test_utils/src/report.rs @@ -241,8 +241,21 @@ fn create_random_signer() -> Signer { } } +/// Generates a config digest with the LLO prefix (0x0009) for tests. Different `n` give different digests +pub fn test_config_digest(n: u8) -> [u8; 32] { + let mut digest = keccak256(&[n]); + digest[0] = 0x00; + digest[1] = 0x09; + digest +} + pub fn generate_report_with_signers(total_signers: usize, signers_per_report: usize, observation_timestamp: Option, override_signers: Option>) -> (Vec, Vec<[u8; 20]>) { - let report_context: [[u8; 32]; 3] = [[0u8; 32], [0u8; 32], [0u8; 32]]; + generate_report_with_signers_and_digest::([0u8; 32], total_signers, signers_per_report, observation_timestamp, override_signers) +} + +/// Same as `generate_report_with_signers` but signs the report for the given config digest (report_context[0]) +pub fn generate_report_with_signers_and_digest(config_digest: [u8; 32], total_signers: usize, signers_per_report: usize, observation_timestamp: Option, override_signers: Option>) -> (Vec, Vec<[u8; 20]>) { + let report_context: [[u8; 32]; 3] = [config_digest, [0u8; 32], [0u8; 32]]; let signer_set = match override_signers { Some(signers) => signers, None => get_signers(total_signers) From bd3d714c38944277de55008e62db12f03ffa341f Mon Sep 17 00:00:00 2001 From: Justin Franco Date: Mon, 19 Oct 2026 13:20:17 -0600 Subject: [PATCH 2/4] Updates cross don test --- programs/verifier/tests/verifier_verify_test.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/programs/verifier/tests/verifier_verify_test.rs b/programs/verifier/tests/verifier_verify_test.rs index 74010f0..48ba26d 100644 --- a/programs/verifier/tests/verifier_verify_test.rs +++ b/programs/verifier/tests/verifier_verify_test.rs @@ -473,8 +473,9 @@ async fn test_verify_reports_from_multiple_dons() { .await, ); - // A report signed by DON A's signers for DON B's digest does not verify - let (cross_report, _) = generate_report_with_signers_and_digest::(digest_b, 4, 4, None, Some(signers_a)); + // A report for DON A's digest signed by DON B's signers does not verify. Two signatures pass + // A's signature count (f = 1), so it is rejected because the signers are not registered for A + let (cross_report, _) = generate_report_with_signers_and_digest::(digest_a, 16, 2, None, Some(signers_b)); Assert::transaction_error( &verifier_client .verify(&mut environment_context, &user, Compressor::compress(&cross_report), None) From 5a08b5cfa941b8220681100f300966b2cea06afd Mon Sep 17 00:00:00 2001 From: Justin Franco Date: Wed, 4 Nov 2026 16:00:14 -0600 Subject: [PATCH 3/4] Adds solana-verify README instructions and fixes comment --- README.md | 26 ++++++++++++++++++++++++++ programs/verifier/README.md | 3 +++ programs/verifier/src/errors.rs | 2 +- 3 files changed, 30 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 9a6871e..71047ff 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,32 @@ anchor 0.29.0 rustc 1.82.0 ``` +`anchor build` is for development and tests. Release binaries are built with `solana-verify`, see below. + +## Building a release +Programs deployed to devnet or mainnet are built with [solana-verify](https://github.com/Ellipsis-Labs/solana-verifiable-build), +which compiles inside a pinned Docker image so anyone can rebuild a commit and get the same binary. + +Requires Docker and `solana-verify` (tested with 0.5.2). Installing `solana-verify` from source needs Rust 1.85 or +newer, newer than this repo's toolchain. That only affects building the tool: the program itself is compiled by the +Solana platform tools inside the image. +```bash +cargo +1.91 install solana-verify --locked +``` + +Build from a tagged commit: +```bash +git checkout +solana-verify build --library-name verifier +``` +The binary is `target/deploy/verifier.so` and the last line of output is its hash; publish that hash with the +release. `solana-verify` hashes the program without its trailing zero bytes, so the hash differs from `sha256sum` of +the file. Rebuilding the same commit gives the same hash. + +The program ID is compiled in (`declare_id!` in `programs/verifier/src/lib.rs`), so a build for another deployment, +such as staging, needs that line changed first. Those builds are reproducible with the same change, but can't be +verified against a public commit. + ## Generate Go bindings Generate the bindings if contract interface is changed diff --git a/programs/verifier/README.md b/programs/verifier/README.md index 7b04140..9f27c47 100644 --- a/programs/verifier/README.md +++ b/programs/verifier/README.md @@ -66,6 +66,9 @@ anchor build The compiled programs will be in `target/deploy/` folder and the IDL will be in `target/idl/` folder. +This build is for development and tests. Binaries for devnet or mainnet are built with `solana-verify`, see +[Building a release](../../README.md#building-a-release). + Testing the programs Note: We set a large stack size as tests will use Anchor deserialization of the full account data to validate state. diff --git a/programs/verifier/src/errors.rs b/programs/verifier/src/errors.rs index 05c7f0b..524d4bf 100644 --- a/programs/verifier/src/errors.rs +++ b/programs/verifier/src/errors.rs @@ -1,5 +1,6 @@ use anchor_lang::error_code; +// New errors must be appended to keep existing error codes stable for integrators #[error_code] pub enum ErrorCode { #[msg("Zero Address")] @@ -38,7 +39,6 @@ pub enum ErrorCode { ConfigDeactivated, #[msg("Invalid inputs")] InvalidInputs, - // New errors must be appended to keep existing error codes stable for integrators #[msg("Config digest is empty")] DigestEmpty, #[msg("Config digest is not set")] From d5f9ce017cd8d0e8a80f88b44555bb1c65f14516 Mon Sep 17 00:00:00 2001 From: Justin Franco Date: Wed, 4 Nov 2026 16:18:32 -0600 Subject: [PATCH 4/4] Adds codeowners file --- .github/CODEOWNERS | 1 + 1 file changed, 1 insertion(+) create mode 100644 .github/CODEOWNERS diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..207b398 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1 @@ +* @smartcontractkit/data-streams-engineers