From 02216cc73b8f4d8e56da20b50d413e3a47d96f53 Mon Sep 17 00:00:00 2001 From: ilija42 Date: Wed, 5 Aug 2026 22:42:24 +0200 Subject: [PATCH 1/2] Add stellar to web resolver --- .mockery.yaml | 1 + core/services/keystore/mocks/stellar.go | 533 +++++++++++++++++++++++ core/web/resolver/query.go | 13 + core/web/resolver/resolver_test.go | 2 + core/web/resolver/stellar_key.go | 49 +++ core/web/resolver/stellar_key_test.go | 77 ++++ core/web/schema/schema.graphql | 1 + core/web/schema/type/stellar_key.graphql | 8 + 8 files changed, 684 insertions(+) create mode 100644 core/services/keystore/mocks/stellar.go create mode 100644 core/web/resolver/stellar_key.go create mode 100644 core/web/resolver/stellar_key_test.go create mode 100644 core/web/schema/type/stellar_key.graphql diff --git a/.mockery.yaml b/.mockery.yaml index 62976901ecd..47f67276a92 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -187,6 +187,7 @@ packages: Tron: TON: Sui: + Stellar: VRF: Workflow: github.com/smartcontractkit/chainlink/v2/core/services/ocr: diff --git a/core/services/keystore/mocks/stellar.go b/core/services/keystore/mocks/stellar.go new file mode 100644 index 00000000000..9658b1ce112 --- /dev/null +++ b/core/services/keystore/mocks/stellar.go @@ -0,0 +1,533 @@ +// Code generated by mockery v2.53.0. DO NOT EDIT. + +package mocks + +import ( + context "context" + + stellarkey "github.com/smartcontractkit/chainlink-common/keystore/corekeys/stellarkey" + mock "github.com/stretchr/testify/mock" +) + +// Stellar is an autogenerated mock type for the Stellar type +type Stellar struct { + mock.Mock +} + +type Stellar_Expecter struct { + mock *mock.Mock +} + +func (_m *Stellar) EXPECT() *Stellar_Expecter { + return &Stellar_Expecter{mock: &_m.Mock} +} + +// Add provides a mock function with given fields: ctx, key +func (_m *Stellar) Add(ctx context.Context, key stellarkey.Key) error { + ret := _m.Called(ctx, key) + + if len(ret) == 0 { + panic("no return value specified for Add") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, stellarkey.Key) error); ok { + r0 = rf(ctx, key) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Stellar_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add' +type Stellar_Add_Call struct { + *mock.Call +} + +// Add is a helper method to define mock.On call +// - ctx context.Context +// - key stellarkey.Key +func (_e *Stellar_Expecter) Add(ctx interface{}, key interface{}) *Stellar_Add_Call { + return &Stellar_Add_Call{Call: _e.mock.On("Add", ctx, key)} +} + +func (_c *Stellar_Add_Call) Run(run func(ctx context.Context, key stellarkey.Key)) *Stellar_Add_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(stellarkey.Key)) + }) + return _c +} + +func (_c *Stellar_Add_Call) Return(_a0 error) *Stellar_Add_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Stellar_Add_Call) RunAndReturn(run func(context.Context, stellarkey.Key) error) *Stellar_Add_Call { + _c.Call.Return(run) + return _c +} + +// Create provides a mock function with given fields: ctx +func (_m *Stellar) Create(ctx context.Context) (stellarkey.Key, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Create") + } + + var r0 stellarkey.Key + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (stellarkey.Key, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) stellarkey.Key); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(stellarkey.Key) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Stellar_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type Stellar_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - ctx context.Context +func (_e *Stellar_Expecter) Create(ctx interface{}) *Stellar_Create_Call { + return &Stellar_Create_Call{Call: _e.mock.On("Create", ctx)} +} + +func (_c *Stellar_Create_Call) Run(run func(ctx context.Context)) *Stellar_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Stellar_Create_Call) Return(_a0 stellarkey.Key, _a1 error) *Stellar_Create_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Stellar_Create_Call) RunAndReturn(run func(context.Context) (stellarkey.Key, error)) *Stellar_Create_Call { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with given fields: ctx, id +func (_m *Stellar) Delete(ctx context.Context, id string) (stellarkey.Key, error) { + ret := _m.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 stellarkey.Key + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (stellarkey.Key, error)); ok { + return rf(ctx, id) + } + if rf, ok := ret.Get(0).(func(context.Context, string) stellarkey.Key); ok { + r0 = rf(ctx, id) + } else { + r0 = ret.Get(0).(stellarkey.Key) + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, id) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Stellar_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type Stellar_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *Stellar_Expecter) Delete(ctx interface{}, id interface{}) *Stellar_Delete_Call { + return &Stellar_Delete_Call{Call: _e.mock.On("Delete", ctx, id)} +} + +func (_c *Stellar_Delete_Call) Run(run func(ctx context.Context, id string)) *Stellar_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *Stellar_Delete_Call) Return(_a0 stellarkey.Key, _a1 error) *Stellar_Delete_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Stellar_Delete_Call) RunAndReturn(run func(context.Context, string) (stellarkey.Key, error)) *Stellar_Delete_Call { + _c.Call.Return(run) + return _c +} + +// EnsureKey provides a mock function with given fields: ctx +func (_m *Stellar) EnsureKey(ctx context.Context) error { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for EnsureKey") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Stellar_EnsureKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureKey' +type Stellar_EnsureKey_Call struct { + *mock.Call +} + +// EnsureKey is a helper method to define mock.On call +// - ctx context.Context +func (_e *Stellar_Expecter) EnsureKey(ctx interface{}) *Stellar_EnsureKey_Call { + return &Stellar_EnsureKey_Call{Call: _e.mock.On("EnsureKey", ctx)} +} + +func (_c *Stellar_EnsureKey_Call) Run(run func(ctx context.Context)) *Stellar_EnsureKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *Stellar_EnsureKey_Call) Return(_a0 error) *Stellar_EnsureKey_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Stellar_EnsureKey_Call) RunAndReturn(run func(context.Context) error) *Stellar_EnsureKey_Call { + _c.Call.Return(run) + return _c +} + +// Export provides a mock function with given fields: id, password +func (_m *Stellar) Export(id string, password string) ([]byte, error) { + ret := _m.Called(id, password) + + if len(ret) == 0 { + panic("no return value specified for Export") + } + + var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func(string, string) ([]byte, error)); ok { + return rf(id, password) + } + if rf, ok := ret.Get(0).(func(string, string) []byte); ok { + r0 = rf(id, password) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]byte) + } + } + + if rf, ok := ret.Get(1).(func(string, string) error); ok { + r1 = rf(id, password) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Stellar_Export_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Export' +type Stellar_Export_Call struct { + *mock.Call +} + +// Export is a helper method to define mock.On call +// - id string +// - password string +func (_e *Stellar_Expecter) Export(id interface{}, password interface{}) *Stellar_Export_Call { + return &Stellar_Export_Call{Call: _e.mock.On("Export", id, password)} +} + +func (_c *Stellar_Export_Call) Run(run func(id string, password string)) *Stellar_Export_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *Stellar_Export_Call) Return(_a0 []byte, _a1 error) *Stellar_Export_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Stellar_Export_Call) RunAndReturn(run func(string, string) ([]byte, error)) *Stellar_Export_Call { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function with given fields: id +func (_m *Stellar) Get(id string) (stellarkey.Key, error) { + ret := _m.Called(id) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + var r0 stellarkey.Key + var r1 error + if rf, ok := ret.Get(0).(func(string) (stellarkey.Key, error)); ok { + return rf(id) + } + if rf, ok := ret.Get(0).(func(string) stellarkey.Key); ok { + r0 = rf(id) + } else { + r0 = ret.Get(0).(stellarkey.Key) + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(id) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Stellar_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type Stellar_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - id string +func (_e *Stellar_Expecter) Get(id interface{}) *Stellar_Get_Call { + return &Stellar_Get_Call{Call: _e.mock.On("Get", id)} +} + +func (_c *Stellar_Get_Call) Run(run func(id string)) *Stellar_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *Stellar_Get_Call) Return(_a0 stellarkey.Key, _a1 error) *Stellar_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Stellar_Get_Call) RunAndReturn(run func(string) (stellarkey.Key, error)) *Stellar_Get_Call { + _c.Call.Return(run) + return _c +} + +// GetAll provides a mock function with no fields +func (_m *Stellar) GetAll() ([]stellarkey.Key, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetAll") + } + + var r0 []stellarkey.Key + var r1 error + if rf, ok := ret.Get(0).(func() ([]stellarkey.Key, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []stellarkey.Key); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]stellarkey.Key) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Stellar_GetAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAll' +type Stellar_GetAll_Call struct { + *mock.Call +} + +// GetAll is a helper method to define mock.On call +func (_e *Stellar_Expecter) GetAll() *Stellar_GetAll_Call { + return &Stellar_GetAll_Call{Call: _e.mock.On("GetAll")} +} + +func (_c *Stellar_GetAll_Call) Run(run func()) *Stellar_GetAll_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Stellar_GetAll_Call) Return(_a0 []stellarkey.Key, _a1 error) *Stellar_GetAll_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Stellar_GetAll_Call) RunAndReturn(run func() ([]stellarkey.Key, error)) *Stellar_GetAll_Call { + _c.Call.Return(run) + return _c +} + +// Import provides a mock function with given fields: ctx, keyJSON, password +func (_m *Stellar) Import(ctx context.Context, keyJSON []byte, password string) (stellarkey.Key, error) { + ret := _m.Called(ctx, keyJSON, password) + + if len(ret) == 0 { + panic("no return value specified for Import") + } + + var r0 stellarkey.Key + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, []byte, string) (stellarkey.Key, error)); ok { + return rf(ctx, keyJSON, password) + } + if rf, ok := ret.Get(0).(func(context.Context, []byte, string) stellarkey.Key); ok { + r0 = rf(ctx, keyJSON, password) + } else { + r0 = ret.Get(0).(stellarkey.Key) + } + + if rf, ok := ret.Get(1).(func(context.Context, []byte, string) error); ok { + r1 = rf(ctx, keyJSON, password) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Stellar_Import_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Import' +type Stellar_Import_Call struct { + *mock.Call +} + +// Import is a helper method to define mock.On call +// - ctx context.Context +// - keyJSON []byte +// - password string +func (_e *Stellar_Expecter) Import(ctx interface{}, keyJSON interface{}, password interface{}) *Stellar_Import_Call { + return &Stellar_Import_Call{Call: _e.mock.On("Import", ctx, keyJSON, password)} +} + +func (_c *Stellar_Import_Call) Run(run func(ctx context.Context, keyJSON []byte, password string)) *Stellar_Import_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]byte), args[2].(string)) + }) + return _c +} + +func (_c *Stellar_Import_Call) Return(_a0 stellarkey.Key, _a1 error) *Stellar_Import_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *Stellar_Import_Call) RunAndReturn(run func(context.Context, []byte, string) (stellarkey.Key, error)) *Stellar_Import_Call { + _c.Call.Return(run) + return _c +} + +// Sign provides a mock function with given fields: ctx, id, msg +func (_m *Stellar) Sign(ctx context.Context, id string, msg []byte) ([]byte, error) { + ret := _m.Called(ctx, id, msg) + + if len(ret) == 0 { + panic("no return value specified for Sign") + } + + var r0 []byte + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, []byte) ([]byte, error)); ok { + return rf(ctx, id, msg) + } + if rf, ok := ret.Get(0).(func(context.Context, string, []byte) []byte); ok { + r0 = rf(ctx, id, msg) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]byte) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, []byte) error); ok { + r1 = rf(ctx, id, msg) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Stellar_Sign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sign' +type Stellar_Sign_Call struct { + *mock.Call +} + +// Sign is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - msg []byte +func (_e *Stellar_Expecter) Sign(ctx interface{}, id interface{}, msg interface{}) *Stellar_Sign_Call { + return &Stellar_Sign_Call{Call: _e.mock.On("Sign", ctx, id, msg)} +} + +func (_c *Stellar_Sign_Call) Run(run func(ctx context.Context, id string, msg []byte)) *Stellar_Sign_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]byte)) + }) + return _c +} + +func (_c *Stellar_Sign_Call) Return(signature []byte, err error) *Stellar_Sign_Call { + _c.Call.Return(signature, err) + return _c +} + +func (_c *Stellar_Sign_Call) RunAndReturn(run func(context.Context, string, []byte) ([]byte, error)) *Stellar_Sign_Call { + _c.Call.Return(run) + return _c +} + +// NewStellar creates a new instance of Stellar. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStellar(t interface { + mock.TestingT + Cleanup(func()) +}) *Stellar { + mock := &Stellar{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/core/web/resolver/query.go b/core/web/resolver/query.go index 4d88b351db6..792be64a72f 100644 --- a/core/web/resolver/query.go +++ b/core/web/resolver/query.go @@ -632,6 +632,19 @@ func (r *Resolver) SuiKeys(ctx context.Context) (*SuiKeysPayloadResolver, error) return NewSuiKeysPayload(keys), nil } +func (r *Resolver) StellarKeys(ctx context.Context) (*StellarKeysPayloadResolver, error) { + if err := authenticateUser(ctx); err != nil { + return nil, err + } + + keys, err := r.App.GetKeyStore().Stellar().GetAll() + if err != nil { + return nil, err + } + + return NewStellarKeysPayload(keys), nil +} + func (r *Resolver) StarkNetKeys(ctx context.Context) (*StarkNetKeysPayloadResolver, error) { if err := authenticateUser(ctx); err != nil { return nil, err diff --git a/core/web/resolver/resolver_test.go b/core/web/resolver/resolver_test.go index 4126fd8201f..5d58cded550 100644 --- a/core/web/resolver/resolver_test.go +++ b/core/web/resolver/resolver_test.go @@ -52,6 +52,7 @@ type mocks struct { solana *keystoreMocks.Solana aptos *keystoreMocks.Aptos sui *keystoreMocks.Sui + stellar *keystoreMocks.Stellar cosmos *keystoreMocks.Cosmos starknet *keystoreMocks.StarkNet tron *keystoreMocks.Tron @@ -114,6 +115,7 @@ func setupFramework(t *testing.T) *gqlTestFramework { cosmos: keystoreMocks.NewCosmos(t), starknet: keystoreMocks.NewStarkNet(t), sui: keystoreMocks.NewSui(t), + stellar: keystoreMocks.NewStellar(t), tron: keystoreMocks.NewTron(t), ton: keystoreMocks.NewTON(t), chain: legacyEvmORMMocks.NewChain(t), diff --git a/core/web/resolver/stellar_key.go b/core/web/resolver/stellar_key.go new file mode 100644 index 00000000000..303452066c3 --- /dev/null +++ b/core/web/resolver/stellar_key.go @@ -0,0 +1,49 @@ +package resolver + +import ( + "github.com/graph-gophers/graphql-go" + + "github.com/smartcontractkit/chainlink-common/keystore/corekeys/stellarkey" +) + +type StellarKeyResolver struct { + key stellarkey.Key +} + +func NewStellarKey(key stellarkey.Key) *StellarKeyResolver { + return &StellarKeyResolver{key: key} +} + +func NewStellarKeys(keys []stellarkey.Key) []*StellarKeyResolver { + resolvers := make([]*StellarKeyResolver, 0, len(keys)) + + for _, k := range keys { + resolvers = append(resolvers, NewStellarKey(k)) + } + + return resolvers +} + +func (r *StellarKeyResolver) ID() graphql.ID { + return graphql.ID(r.key.ID()) +} + +// Account is the Stellar account address in StrKey form (G…), which is what a +// feeds-manager chain config stores as its accountAddr. +func (r *StellarKeyResolver) Account() string { + return r.key.Account() +} + +// -- GetStellarKeys Query -- + +type StellarKeysPayloadResolver struct { + keys []stellarkey.Key +} + +func NewStellarKeysPayload(keys []stellarkey.Key) *StellarKeysPayloadResolver { + return &StellarKeysPayloadResolver{keys: keys} +} + +func (r *StellarKeysPayloadResolver) Results() []*StellarKeyResolver { + return NewStellarKeys(r.keys) +} diff --git a/core/web/resolver/stellar_key_test.go b/core/web/resolver/stellar_key_test.go new file mode 100644 index 00000000000..860040bc95f --- /dev/null +++ b/core/web/resolver/stellar_key_test.go @@ -0,0 +1,77 @@ +package resolver + +import ( + "context" + "errors" + "fmt" + "testing" + + gqlerrors "github.com/graph-gophers/graphql-go/errors" + + "github.com/smartcontractkit/chainlink-common/keystore/corekeys/stellarkey" + + "github.com/smartcontractkit/chainlink/v2/core/internal/testutils/keystest" +) + +func TestResolver_StellarKeys(t *testing.T) { + t.Parallel() + + query := ` + query GetStellarKeys { + stellarKeys { + results { + id + account + } + } + }` + k := stellarkey.MustNewInsecure(keystest.NewRandReaderFromSeed(1)) + result := fmt.Sprintf(` + { + "stellarKeys": { + "results": [ + { + "id": "%s", + "account": "%s" + } + ] + } + }`, k.ID(), k.Account()) + gError := errors.New("error") + + testCases := []GQLTestCase{ + unauthorizedTestCase(GQLTestCase{query: query}, "stellarKeys"), + { + name: "success", + authenticated: true, + before: func(ctx context.Context, f *gqlTestFramework) { + f.Mocks.stellar.On("GetAll").Return([]stellarkey.Key{k}, nil) + f.Mocks.keystore.On("Stellar").Return(f.Mocks.stellar) + f.App.On("GetKeyStore").Return(f.Mocks.keystore) + }, + query: query, + result: result, + }, + { + name: "no keys returned by GetAll", + authenticated: true, + before: func(ctx context.Context, f *gqlTestFramework) { + f.Mocks.stellar.On("GetAll").Return([]stellarkey.Key{}, gError) + f.Mocks.keystore.On("Stellar").Return(f.Mocks.stellar) + f.App.On("GetKeyStore").Return(f.Mocks.keystore) + }, + query: query, + result: `null`, + errors: []*gqlerrors.QueryError{ + { + Extensions: nil, + ResolverError: gError, + Path: []any{"stellarKeys"}, + Message: gError.Error(), + }, + }, + }, + } + + RunGQLTests(t, testCases) +} diff --git a/core/web/schema/schema.graphql b/core/web/schema/schema.graphql index 66cf1dd68f4..a0275af45b1 100644 --- a/core/web/schema/schema.graphql +++ b/core/web/schema/schema.graphql @@ -39,6 +39,7 @@ type Query { starknetKeys: StarkNetKeysPayload! tronKeys: TronKeysPayload! tonKeys: TONKeysPayload! + stellarKeys: StellarKeysPayload! sqlLogging: GetSQLLoggingPayload! vrfKey(id: ID!): VRFKeyPayload! vrfKeys: VRFKeysPayload! diff --git a/core/web/schema/type/stellar_key.graphql b/core/web/schema/type/stellar_key.graphql new file mode 100644 index 00000000000..774b74b9818 --- /dev/null +++ b/core/web/schema/type/stellar_key.graphql @@ -0,0 +1,8 @@ +type StellarKey { + id: ID! + account: String! +} + +type StellarKeysPayload { + results: [StellarKey!]! +} From 3e9f23aeb262f2fd89cc66ec2cee8f049c8f4ea4 Mon Sep 17 00:00:00 2001 From: ilija42 Date: Thu, 6 Aug 2026 11:02:31 +0200 Subject: [PATCH 2/2] run generate --- core/services/keystore/mocks/stellar.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/core/services/keystore/mocks/stellar.go b/core/services/keystore/mocks/stellar.go index 9658b1ce112..bcf5217928b 100644 --- a/core/services/keystore/mocks/stellar.go +++ b/core/services/keystore/mocks/stellar.go @@ -1,12 +1,13 @@ -// Code generated by mockery v2.53.0. DO NOT EDIT. +// Code generated by mockery v2.53.6. DO NOT EDIT. package mocks import ( context "context" - stellarkey "github.com/smartcontractkit/chainlink-common/keystore/corekeys/stellarkey" mock "github.com/stretchr/testify/mock" + + stellarkey "github.com/smartcontractkit/chainlink-common/keystore/corekeys/stellarkey" ) // Stellar is an autogenerated mock type for the Stellar type